gi-gtksource 3.0.16 → 3.0.18

raw patch · 86 files changed

+43850/−10 lines, 86 filesdep ~haskell-gidep ~haskell-gi-basePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: haskell-gi, haskell-gi-base

API changes (from Hackage documentation)

Files

• ChangeLog.md +8/−0
• GI/GtkSource.hs +56/−0
• GI/GtkSource/Enums.hs +619/−0
• GI/GtkSource/Enums.hs-boot +57/−0
• GI/GtkSource/Flags.hs +482/−0
• GI/GtkSource/Flags.hs-boot +52/−0
• GI/GtkSource/Functions.hs +137/−0
• GI/GtkSource/Interfaces.hs +47/−0
• GI/GtkSource/Interfaces/CompletionProposal.hs +701/−0
• GI/GtkSource/Interfaces/CompletionProposal.hs-boot +62/−0
• GI/GtkSource/Interfaces/CompletionProvider.hs +816/−0
• GI/GtkSource/Interfaces/CompletionProvider.hs-boot +68/−0
• GI/GtkSource/Interfaces/StyleSchemeChooser.hs +294/−0
• GI/GtkSource/Interfaces/StyleSchemeChooser.hs-boot +38/−0
• GI/GtkSource/Interfaces/UndoManager.hs +670/−0
• GI/GtkSource/Interfaces/UndoManager.hs-boot +59/−0
• GI/GtkSource/Objects.hs +99/−0
• GI/GtkSource/Objects/Buffer.hs +3199/−0
• GI/GtkSource/Objects/Buffer.hs-boot +173/−0
• GI/GtkSource/Objects/Completion.hs +1882/−0
• GI/GtkSource/Objects/Completion.hs-boot +107/−0
• GI/GtkSource/Objects/CompletionContext.hs +575/−0
• GI/GtkSource/Objects/CompletionContext.hs-boot +50/−0
• GI/GtkSource/Objects/CompletionInfo.hs +819/−0
• GI/GtkSource/Objects/CompletionInfo.hs-boot +41/−0
• GI/GtkSource/Objects/CompletionItem.hs +1277/−0
• GI/GtkSource/Objects/CompletionItem.hs-boot +71/−0
• GI/GtkSource/Objects/CompletionWords.hs +834/−0
• GI/GtkSource/Objects/CompletionWords.hs-boot +59/−0
• GI/GtkSource/Objects/File.hs +926/−0
• GI/GtkSource/Objects/File.hs-boot +74/−0
• GI/GtkSource/Objects/FileLoader.hs +996/−0
• GI/GtkSource/Objects/FileLoader.hs-boot +71/−0
• GI/GtkSource/Objects/FileSaver.hs +1360/−0
• GI/GtkSource/Objects/FileSaver.hs-boot +89/−0
• GI/GtkSource/Objects/Gutter.hs +856/−0
• GI/GtkSource/Objects/Gutter.hs-boot +71/−0
• GI/GtkSource/Objects/GutterRenderer.hs +2423/−0
• GI/GtkSource/Objects/GutterRenderer.hs-boot +143/−0
• GI/GtkSource/Objects/GutterRendererPixbuf.hs +876/−0
• GI/GtkSource/Objects/GutterRendererPixbuf.hs-boot +65/−0
• GI/GtkSource/Objects/GutterRendererText.hs +542/−0
• GI/GtkSource/Objects/GutterRendererText.hs-boot +47/−0
• GI/GtkSource/Objects/Language.hs +822/−0
• GI/GtkSource/Objects/Language.hs-boot +71/−0
• GI/GtkSource/Objects/LanguageManager.hs +632/−0
• GI/GtkSource/Objects/LanguageManager.hs-boot +50/−0
• GI/GtkSource/Objects/Map.hs +817/−0
• GI/GtkSource/Objects/Map.hs-boot +41/−0
• GI/GtkSource/Objects/Mark.hs +402/−0
• GI/GtkSource/Objects/Mark.hs-boot +41/−0
• GI/GtkSource/Objects/MarkAttributes.hs +1324/−0
• GI/GtkSource/Objects/MarkAttributes.hs-boot +89/−0
• GI/GtkSource/Objects/PrintCompositor.hs +3042/−0
• GI/GtkSource/Objects/PrintCompositor.hs-boot +170/−0
• GI/GtkSource/Objects/Region.hs +808/−0
• GI/GtkSource/Objects/Region.hs-boot +65/−0
• GI/GtkSource/Objects/SearchContext.hs +1984/−0
• GI/GtkSource/Objects/SearchContext.hs-boot +116/−0
• GI/GtkSource/Objects/SearchSettings.hs +1011/−0
• GI/GtkSource/Objects/SearchSettings.hs-boot +74/−0
• GI/GtkSource/Objects/SpaceDrawer.hs +704/−0
• GI/GtkSource/Objects/SpaceDrawer.hs-boot +56/−0
• GI/GtkSource/Objects/Style.hs +1240/−0
• GI/GtkSource/Objects/Style.hs-boot +92/−0
• GI/GtkSource/Objects/StyleScheme.hs +616/−0
• GI/GtkSource/Objects/StyleScheme.hs-boot +59/−0
• GI/GtkSource/Objects/StyleSchemeChooserButton.hs +499/−0
• GI/GtkSource/Objects/StyleSchemeChooserButton.hs-boot +29/−0
• GI/GtkSource/Objects/StyleSchemeChooserWidget.hs +463/−0
• GI/GtkSource/Objects/StyleSchemeChooserWidget.hs-boot +29/−0
• GI/GtkSource/Objects/StyleSchemeManager.hs +663/−0
• GI/GtkSource/Objects/StyleSchemeManager.hs-boot +56/−0
• GI/GtkSource/Objects/Tag.hs +319/−0
• GI/GtkSource/Objects/Tag.hs-boot +35/−0
• GI/GtkSource/Objects/View.hs +4393/−0
• GI/GtkSource/Objects/View.hs-boot +218/−0
• GI/GtkSource/Structs.hs +43/−0
• GI/GtkSource/Structs/Encoding.hs +501/−0
• GI/GtkSource/Structs/Encoding.hs-boot +41/−0
• GI/GtkSource/Structs/RegionIter.hs +241/−0
• GI/GtkSource/Structs/RegionIter.hs-boot +35/−0
• LICENSE +14/−0
• README.md +1/−1
• gi-gtksource.cabal +52/−8
• stack.yaml +1/−1

@@ -1,3 +1,11 @@+### 3.0.18+++ Update to haskell-gi(-base) 0.22++### 3.0.17+++ Update stack version to 12.10+ ### 3.0.16  + Remove enable-overloading flags, and use instead explicit CPP checks for 'haskell-gi-overloading-1.0', see [how to disable overloading](https://github.com/haskell-gi/haskell-gi/wiki/Overloading\#disabling-overloading).

@@ -0,0 +1,56 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GtkSource+    (     module GI.GtkSource.Enums               ,+    module GI.GtkSource.Flags               ,+    module GI.GtkSource.Functions           ,+    module GI.GtkSource.Interfaces          ,+    module GI.GtkSource.Objects             ,+    module GI.GtkSource.Structs             ,++++    module Data.GI.Base                     ,+++    ) where++import GI.GtkSource.Enums+import GI.GtkSource.Flags+import GI.GtkSource.Functions+import GI.GtkSource.Interfaces+import GI.GtkSource.Objects+import GI.GtkSource.Structs++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 Data.GI.Base+

@@ -0,0 +1,619 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GtkSource.Enums+    ( ++ -- * Enumerations+-- ** BackgroundPatternType #enum:BackgroundPatternType#++    BackgroundPatternType(..)               ,+++-- ** BracketMatchType #enum:BracketMatchType#++    BracketMatchType(..)                    ,+++-- ** ChangeCaseType #enum:ChangeCaseType#++    ChangeCaseType(..)                      ,+++-- ** CompletionError #enum:CompletionError#++    CompletionError(..)                     ,+    catchCompletionError                    ,+    handleCompletionError                   ,+++-- ** CompressionType #enum:CompressionType#++    CompressionType(..)                     ,+++-- ** FileLoaderError #enum:FileLoaderError#++    FileLoaderError(..)                     ,+    catchFileLoaderError                    ,+    handleFileLoaderError                   ,+++-- ** FileSaverError #enum:FileSaverError#++    FileSaverError(..)                      ,+    catchFileSaverError                     ,+    handleFileSaverError                    ,+++-- ** GutterRendererAlignmentMode #enum:GutterRendererAlignmentMode#++    GutterRendererAlignmentMode(..)         ,+++-- ** NewlineType #enum:NewlineType#++    NewlineType(..)                         ,+++-- ** SmartHomeEndType #enum:SmartHomeEndType#++    SmartHomeEndType(..)                    ,+++-- ** ViewGutterPosition #enum:ViewGutterPosition#++    ViewGutterPosition(..)                  ,+++++    ) 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+++-- Enum ViewGutterPosition+{- |+/No description available in the introspection data./+-}+data ViewGutterPosition = +      ViewGutterPositionLines+    {- ^+    the gutter position of the lines+    renderer+    -}+    | ViewGutterPositionMarks+    {- ^+    the gutter position of the marks+    renderer+    -}+    | AnotherViewGutterPosition Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum ViewGutterPosition where+    fromEnum ViewGutterPositionLines = -30+    fromEnum ViewGutterPositionMarks = -20+    fromEnum (AnotherViewGutterPosition k) = k++    toEnum -30 = ViewGutterPositionLines+    toEnum -20 = ViewGutterPositionMarks+    toEnum k = AnotherViewGutterPosition k++instance P.Ord ViewGutterPosition where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gtk_source_view_gutter_position_get_type" c_gtk_source_view_gutter_position_get_type :: +    IO GType++instance BoxedEnum ViewGutterPosition where+    boxedEnumType _ = c_gtk_source_view_gutter_position_get_type++-- Enum SmartHomeEndType+{- |+/No description available in the introspection data./+-}+data SmartHomeEndType = +      SmartHomeEndTypeDisabled+    {- ^+    smart-home-end disabled.+    -}+    | SmartHomeEndTypeBefore+    {- ^+    move to the first\/last+    non-whitespace character on the first press of the HOME\/END keys and+    to the beginning\/end of the line on the second press.+    -}+    | SmartHomeEndTypeAfter+    {- ^+    move to the beginning\/end of the+    line on the first press of the HOME\/END keys and to the first\/last+    non-whitespace character on the second press.+    -}+    | SmartHomeEndTypeAlways+    {- ^+    always move to the first\/last+    non-whitespace character when the HOME\/END keys are pressed.+    -}+    | AnotherSmartHomeEndType Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum SmartHomeEndType where+    fromEnum SmartHomeEndTypeDisabled = 0+    fromEnum SmartHomeEndTypeBefore = 1+    fromEnum SmartHomeEndTypeAfter = 2+    fromEnum SmartHomeEndTypeAlways = 3+    fromEnum (AnotherSmartHomeEndType k) = k++    toEnum 0 = SmartHomeEndTypeDisabled+    toEnum 1 = SmartHomeEndTypeBefore+    toEnum 2 = SmartHomeEndTypeAfter+    toEnum 3 = SmartHomeEndTypeAlways+    toEnum k = AnotherSmartHomeEndType k++instance P.Ord SmartHomeEndType where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gtk_source_smart_home_end_type_get_type" c_gtk_source_smart_home_end_type_get_type :: +    IO GType++instance BoxedEnum SmartHomeEndType where+    boxedEnumType _ = c_gtk_source_smart_home_end_type_get_type++-- Enum NewlineType+{- |+/No description available in the introspection data./++/Since: 3.14/+-}+data NewlineType = +      NewlineTypeLf+    {- ^+    line feed, used on UNIX.+    -}+    | NewlineTypeCr+    {- ^+    carriage return, used on Mac.+    -}+    | NewlineTypeCrLf+    {- ^+    carriage return followed by a line feed, used+      on Windows.+    -}+    | AnotherNewlineType Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum NewlineType where+    fromEnum NewlineTypeLf = 0+    fromEnum NewlineTypeCr = 1+    fromEnum NewlineTypeCrLf = 2+    fromEnum (AnotherNewlineType k) = k++    toEnum 0 = NewlineTypeLf+    toEnum 1 = NewlineTypeCr+    toEnum 2 = NewlineTypeCrLf+    toEnum k = AnotherNewlineType k++instance P.Ord NewlineType where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gtk_source_newline_type_get_type" c_gtk_source_newline_type_get_type :: +    IO GType++instance BoxedEnum NewlineType where+    boxedEnumType _ = c_gtk_source_newline_type_get_type++-- Enum GutterRendererAlignmentMode+{- |+The alignment mode of the renderer, when a cell spans multiple lines (due to+text wrapping).+-}+data GutterRendererAlignmentMode = +      GutterRendererAlignmentModeCell+    {- ^+    The full cell.+    -}+    | GutterRendererAlignmentModeFirst+    {- ^+    The first line.+    -}+    | GutterRendererAlignmentModeLast+    {- ^+    The last line.+    -}+    | AnotherGutterRendererAlignmentMode Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum GutterRendererAlignmentMode where+    fromEnum GutterRendererAlignmentModeCell = 0+    fromEnum GutterRendererAlignmentModeFirst = 1+    fromEnum GutterRendererAlignmentModeLast = 2+    fromEnum (AnotherGutterRendererAlignmentMode k) = k++    toEnum 0 = GutterRendererAlignmentModeCell+    toEnum 1 = GutterRendererAlignmentModeFirst+    toEnum 2 = GutterRendererAlignmentModeLast+    toEnum k = AnotherGutterRendererAlignmentMode k++instance P.Ord GutterRendererAlignmentMode where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gtk_source_gutter_renderer_alignment_mode_get_type" c_gtk_source_gutter_renderer_alignment_mode_get_type :: +    IO GType++instance BoxedEnum GutterRendererAlignmentMode where+    boxedEnumType _ = c_gtk_source_gutter_renderer_alignment_mode_get_type++-- Enum FileSaverError+{- |+An error code used with the @/GTK_SOURCE_FILE_SAVER_ERROR/@ domain.++/Since: 3.14/+-}+data FileSaverError = +      FileSaverErrorInvalidChars+    {- ^+    The buffer contains invalid+      characters.+    -}+    | FileSaverErrorExternallyModified+    {- ^+    The file is externally+      modified.+    -}+    | AnotherFileSaverError Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum FileSaverError where+    fromEnum FileSaverErrorInvalidChars = 0+    fromEnum FileSaverErrorExternallyModified = 1+    fromEnum (AnotherFileSaverError k) = k++    toEnum 0 = FileSaverErrorInvalidChars+    toEnum 1 = FileSaverErrorExternallyModified+    toEnum k = AnotherFileSaverError k++instance P.Ord FileSaverError where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++instance GErrorClass FileSaverError where+    gerrorClassDomain _ = "gtk-source-file-saver-error"++-- | Catch exceptions of type `FileSaverError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.+catchFileSaverError ::+    IO a ->+    (FileSaverError -> GErrorMessage -> IO a) ->+    IO a+catchFileSaverError = catchGErrorJustDomain++-- | Handle exceptions of type `FileSaverError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.+handleFileSaverError ::+    (FileSaverError -> GErrorMessage -> IO a) ->+    IO a ->+    IO a+handleFileSaverError = handleGErrorJustDomain++foreign import ccall "gtk_source_file_saver_error_get_type" c_gtk_source_file_saver_error_get_type :: +    IO GType++instance BoxedEnum FileSaverError where+    boxedEnumType _ = c_gtk_source_file_saver_error_get_type++-- Enum FileLoaderError+{- |+An error code used with the @/GTK_SOURCE_FILE_LOADER_ERROR/@ domain.+-}+data FileLoaderError = +      FileLoaderErrorTooBig+    {- ^+    The file is too big.+    -}+    | FileLoaderErrorEncodingAutoDetectionFailed+    {- ^+    It is not+    possible to detect the encoding automatically.+    -}+    | FileLoaderErrorConversionFallback+    {- ^+    There was an encoding+    conversion error and it was needed to use a fallback character.+    -}+    | AnotherFileLoaderError Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum FileLoaderError where+    fromEnum FileLoaderErrorTooBig = 0+    fromEnum FileLoaderErrorEncodingAutoDetectionFailed = 1+    fromEnum FileLoaderErrorConversionFallback = 2+    fromEnum (AnotherFileLoaderError k) = k++    toEnum 0 = FileLoaderErrorTooBig+    toEnum 1 = FileLoaderErrorEncodingAutoDetectionFailed+    toEnum 2 = FileLoaderErrorConversionFallback+    toEnum k = AnotherFileLoaderError k++instance P.Ord FileLoaderError where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++instance GErrorClass FileLoaderError where+    gerrorClassDomain _ = "gtk-source-file-loader-error"++-- | Catch exceptions of type `FileLoaderError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.+catchFileLoaderError ::+    IO a ->+    (FileLoaderError -> GErrorMessage -> IO a) ->+    IO a+catchFileLoaderError = catchGErrorJustDomain++-- | Handle exceptions of type `FileLoaderError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.+handleFileLoaderError ::+    (FileLoaderError -> GErrorMessage -> IO a) ->+    IO a ->+    IO a+handleFileLoaderError = handleGErrorJustDomain++foreign import ccall "gtk_source_file_loader_error_get_type" c_gtk_source_file_loader_error_get_type :: +    IO GType++instance BoxedEnum FileLoaderError where+    boxedEnumType _ = c_gtk_source_file_loader_error_get_type++-- Enum CompressionType+{- |+/No description available in the introspection data./++/Since: 3.14/+-}+data CompressionType = +      CompressionTypeNone+    {- ^+    plain text.+    -}+    | CompressionTypeGzip+    {- ^+    gzip compression.+    -}+    | AnotherCompressionType Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum CompressionType where+    fromEnum CompressionTypeNone = 0+    fromEnum CompressionTypeGzip = 1+    fromEnum (AnotherCompressionType k) = k++    toEnum 0 = CompressionTypeNone+    toEnum 1 = CompressionTypeGzip+    toEnum k = AnotherCompressionType k++instance P.Ord CompressionType where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gtk_source_compression_type_get_type" c_gtk_source_compression_type_get_type :: +    IO GType++instance BoxedEnum CompressionType where+    boxedEnumType _ = c_gtk_source_compression_type_get_type++-- Enum CompletionError+{- |+An error code used with @/GTK_SOURCE_COMPLETION_ERROR/@ in a 'GError' returned+from a completion-related function.+-}+data CompletionError = +      CompletionErrorAlreadyBound+    {- ^+    The 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'+    is already bound to the 'GI.GtkSource.Objects.Completion.Completion' object.+    -}+    | CompletionErrorNotBound+    {- ^+    The 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider' is+    not bound to the 'GI.GtkSource.Objects.Completion.Completion' object.+    -}+    | AnotherCompletionError Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum CompletionError where+    fromEnum CompletionErrorAlreadyBound = 0+    fromEnum CompletionErrorNotBound = 1+    fromEnum (AnotherCompletionError k) = k++    toEnum 0 = CompletionErrorAlreadyBound+    toEnum 1 = CompletionErrorNotBound+    toEnum k = AnotherCompletionError k++instance P.Ord CompletionError where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++instance GErrorClass CompletionError where+    gerrorClassDomain _ = "gtk-source-completion-error-quark"++-- | Catch exceptions of type `CompletionError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.+catchCompletionError ::+    IO a ->+    (CompletionError -> GErrorMessage -> IO a) ->+    IO a+catchCompletionError = catchGErrorJustDomain++-- | Handle exceptions of type `CompletionError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.+handleCompletionError ::+    (CompletionError -> GErrorMessage -> IO a) ->+    IO a ->+    IO a+handleCompletionError = handleGErrorJustDomain++foreign import ccall "gtk_source_completion_error_get_type" c_gtk_source_completion_error_get_type :: +    IO GType++instance BoxedEnum CompletionError where+    boxedEnumType _ = c_gtk_source_completion_error_get_type++-- Enum ChangeCaseType+{- |+/No description available in the introspection data./++/Since: 3.12/+-}+data ChangeCaseType = +      ChangeCaseTypeLower+    {- ^+    change case to lowercase.+    -}+    | ChangeCaseTypeUpper+    {- ^+    change case to uppercase.+    -}+    | ChangeCaseTypeToggle+    {- ^+    toggle case of each character.+    -}+    | ChangeCaseTypeTitle+    {- ^+    capitalize each word.+    -}+    | AnotherChangeCaseType Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum ChangeCaseType where+    fromEnum ChangeCaseTypeLower = 0+    fromEnum ChangeCaseTypeUpper = 1+    fromEnum ChangeCaseTypeToggle = 2+    fromEnum ChangeCaseTypeTitle = 3+    fromEnum (AnotherChangeCaseType k) = k++    toEnum 0 = ChangeCaseTypeLower+    toEnum 1 = ChangeCaseTypeUpper+    toEnum 2 = ChangeCaseTypeToggle+    toEnum 3 = ChangeCaseTypeTitle+    toEnum k = AnotherChangeCaseType k++instance P.Ord ChangeCaseType where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gtk_source_change_case_type_get_type" c_gtk_source_change_case_type_get_type :: +    IO GType++instance BoxedEnum ChangeCaseType where+    boxedEnumType _ = c_gtk_source_change_case_type_get_type++-- Enum BracketMatchType+{- |+/No description available in the introspection data./+-}+data BracketMatchType = +      BracketMatchTypeNone+    {- ^+    there is no bracket to match.+    -}+    | BracketMatchTypeOutOfRange+    {- ^+    matching a bracket+     failed because the maximum range was reached.+    -}+    | BracketMatchTypeNotFound+    {- ^+    a matching bracket was not found.+    -}+    | BracketMatchTypeFound+    {- ^+    a matching bracket was found.+    -}+    | AnotherBracketMatchType Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum BracketMatchType where+    fromEnum BracketMatchTypeNone = 0+    fromEnum BracketMatchTypeOutOfRange = 1+    fromEnum BracketMatchTypeNotFound = 2+    fromEnum BracketMatchTypeFound = 3+    fromEnum (AnotherBracketMatchType k) = k++    toEnum 0 = BracketMatchTypeNone+    toEnum 1 = BracketMatchTypeOutOfRange+    toEnum 2 = BracketMatchTypeNotFound+    toEnum 3 = BracketMatchTypeFound+    toEnum k = AnotherBracketMatchType k++instance P.Ord BracketMatchType where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gtk_source_bracket_match_type_get_type" c_gtk_source_bracket_match_type_get_type :: +    IO GType++instance BoxedEnum BracketMatchType where+    boxedEnumType _ = c_gtk_source_bracket_match_type_get_type++-- Enum BackgroundPatternType+{- |+/No description available in the introspection data./++/Since: 3.16/+-}+data BackgroundPatternType = +      BackgroundPatternTypeNone+    {- ^+    no pattern+    -}+    | BackgroundPatternTypeGrid+    {- ^+    grid pattern+    -}+    | AnotherBackgroundPatternType Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum BackgroundPatternType where+    fromEnum BackgroundPatternTypeNone = 0+    fromEnum BackgroundPatternTypeGrid = 1+    fromEnum (AnotherBackgroundPatternType k) = k++    toEnum 0 = BackgroundPatternTypeNone+    toEnum 1 = BackgroundPatternTypeGrid+    toEnum k = AnotherBackgroundPatternType k++instance P.Ord BackgroundPatternType where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gtk_source_background_pattern_type_get_type" c_gtk_source_background_pattern_type_get_type :: +    IO GType++instance BoxedEnum BackgroundPatternType where+    boxedEnumType _ = c_gtk_source_background_pattern_type_get_type++

@@ -0,0 +1,57 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.GtkSource.Enums 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++data ViewGutterPosition+instance P.Enum ViewGutterPosition where+instance BoxedEnum ViewGutterPosition where+data SmartHomeEndType+instance P.Enum SmartHomeEndType where+instance BoxedEnum SmartHomeEndType where+data NewlineType+instance P.Enum NewlineType where+instance BoxedEnum NewlineType where+data GutterRendererAlignmentMode+instance P.Enum GutterRendererAlignmentMode where+instance BoxedEnum GutterRendererAlignmentMode where+data FileSaverError+instance P.Enum FileSaverError where+instance BoxedEnum FileSaverError where+data FileLoaderError+instance P.Enum FileLoaderError where+instance BoxedEnum FileLoaderError where+data CompressionType+instance P.Enum CompressionType where+instance BoxedEnum CompressionType where+data CompletionError+instance P.Enum CompletionError where+instance BoxedEnum CompletionError where+data ChangeCaseType+instance P.Enum ChangeCaseType where+instance BoxedEnum ChangeCaseType where+data BracketMatchType+instance P.Enum BracketMatchType where+instance BoxedEnum BracketMatchType where+data BackgroundPatternType+instance P.Enum BackgroundPatternType where+instance BoxedEnum BackgroundPatternType where

@@ -0,0 +1,482 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GtkSource.Flags+    ( ++ -- * Flags+-- ** CompletionActivation #flag:CompletionActivation#++    CompletionActivation(..)                ,+++-- ** DrawSpacesFlags #flag:DrawSpacesFlags#++    DrawSpacesFlags(..)                     ,+++-- ** FileSaverFlags #flag:FileSaverFlags#++    FileSaverFlags(..)                      ,+++-- ** GutterRendererState #flag:GutterRendererState#++    GutterRendererState(..)                 ,+++-- ** SortFlags #flag:SortFlags#++    SortFlags(..)                           ,+++-- ** SpaceLocationFlags #flag:SpaceLocationFlags#++    SpaceLocationFlags(..)                  ,+++-- ** SpaceTypeFlags #flag:SpaceTypeFlags#++    SpaceTypeFlags(..)                      ,+++++    ) 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+++-- Flags SpaceTypeFlags+{- |+'GI.GtkSource.Flags.SpaceTypeFlags' contains flags for white space types.++/Since: 3.24/+-}+data SpaceTypeFlags = +      SpaceTypeFlagsNone+    {- ^+    No flags.+    -}+    | SpaceTypeFlagsSpace+    {- ^+    Space character.+    -}+    | SpaceTypeFlagsTab+    {- ^+    Tab character.+    -}+    | SpaceTypeFlagsNewline+    {- ^+    Line break character. If the+      'GI.GtkSource.Objects.Buffer.Buffer':@/implicit-trailing-newline/@ property is 'True',+      'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer' also draws a line break at the end of the buffer.+    -}+    | SpaceTypeFlagsNbsp+    {- ^+    Non-breaking space character.+    -}+    | SpaceTypeFlagsAll+    {- ^+    All white spaces.+    -}+    | AnotherSpaceTypeFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum SpaceTypeFlags where+    fromEnum SpaceTypeFlagsNone = 0+    fromEnum SpaceTypeFlagsSpace = 1+    fromEnum SpaceTypeFlagsTab = 2+    fromEnum SpaceTypeFlagsNewline = 4+    fromEnum SpaceTypeFlagsNbsp = 8+    fromEnum SpaceTypeFlagsAll = 15+    fromEnum (AnotherSpaceTypeFlags k) = k++    toEnum 0 = SpaceTypeFlagsNone+    toEnum 1 = SpaceTypeFlagsSpace+    toEnum 2 = SpaceTypeFlagsTab+    toEnum 4 = SpaceTypeFlagsNewline+    toEnum 8 = SpaceTypeFlagsNbsp+    toEnum 15 = SpaceTypeFlagsAll+    toEnum k = AnotherSpaceTypeFlags k++instance P.Ord SpaceTypeFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gtk_source_space_type_flags_get_type" c_gtk_source_space_type_flags_get_type :: +    IO GType++instance BoxedFlags SpaceTypeFlags where+    boxedFlagsType _ = c_gtk_source_space_type_flags_get_type++instance IsGFlag SpaceTypeFlags++-- Flags SpaceLocationFlags+{- |+'GI.GtkSource.Flags.SpaceLocationFlags' contains flags for white space locations.++If a line contains only white spaces (no text), the white spaces match both+'GI.GtkSource.Flags.SpaceLocationFlagsLeading' and 'GI.GtkSource.Flags.SpaceLocationFlagsTrailing'.++/Since: 3.24/+-}+data SpaceLocationFlags = +      SpaceLocationFlagsNone+    {- ^+    No flags.+    -}+    | SpaceLocationFlagsLeading+    {- ^+    Leading white spaces on a line, i.e. the+      indentation.+    -}+    | SpaceLocationFlagsInsideText+    {- ^+    White spaces inside a line of text.+    -}+    | SpaceLocationFlagsTrailing+    {- ^+    Trailing white spaces on a line.+    -}+    | SpaceLocationFlagsAll+    {- ^+    White spaces anywhere.+    -}+    | AnotherSpaceLocationFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum SpaceLocationFlags where+    fromEnum SpaceLocationFlagsNone = 0+    fromEnum SpaceLocationFlagsLeading = 1+    fromEnum SpaceLocationFlagsInsideText = 2+    fromEnum SpaceLocationFlagsTrailing = 4+    fromEnum SpaceLocationFlagsAll = 7+    fromEnum (AnotherSpaceLocationFlags k) = k++    toEnum 0 = SpaceLocationFlagsNone+    toEnum 1 = SpaceLocationFlagsLeading+    toEnum 2 = SpaceLocationFlagsInsideText+    toEnum 4 = SpaceLocationFlagsTrailing+    toEnum 7 = SpaceLocationFlagsAll+    toEnum k = AnotherSpaceLocationFlags k++instance P.Ord SpaceLocationFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gtk_source_space_location_flags_get_type" c_gtk_source_space_location_flags_get_type :: +    IO GType++instance BoxedFlags SpaceLocationFlags where+    boxedFlagsType _ = c_gtk_source_space_location_flags_get_type++instance IsGFlag SpaceLocationFlags++-- Flags SortFlags+{- |+/No description available in the introspection data./++/Since: 3.18/+-}+data SortFlags = +      SortFlagsNone+    {- ^+    no flags specified+    -}+    | SortFlagsCaseSensitive+    {- ^+    case sensitive sort+    -}+    | SortFlagsReverseOrder+    {- ^+    sort in reverse order+    -}+    | SortFlagsRemoveDuplicates+    {- ^+    remove duplicates+    -}+    | AnotherSortFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum SortFlags where+    fromEnum SortFlagsNone = 0+    fromEnum SortFlagsCaseSensitive = 1+    fromEnum SortFlagsReverseOrder = 2+    fromEnum SortFlagsRemoveDuplicates = 4+    fromEnum (AnotherSortFlags k) = k++    toEnum 0 = SortFlagsNone+    toEnum 1 = SortFlagsCaseSensitive+    toEnum 2 = SortFlagsReverseOrder+    toEnum 4 = SortFlagsRemoveDuplicates+    toEnum k = AnotherSortFlags k++instance P.Ord SortFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gtk_source_sort_flags_get_type" c_gtk_source_sort_flags_get_type :: +    IO GType++instance BoxedFlags SortFlags where+    boxedFlagsType _ = c_gtk_source_sort_flags_get_type++instance IsGFlag SortFlags++-- Flags GutterRendererState+{- |+/No description available in the introspection data./+-}+data GutterRendererState = +      GutterRendererStateNormal+    {- ^+    normal state+    -}+    | GutterRendererStateCursor+    {- ^+    area in the renderer represents the+    line on which the insert cursor is currently positioned+    -}+    | GutterRendererStatePrelit+    {- ^+    the mouse pointer is currently+    over the activatable area of the renderer+    -}+    | GutterRendererStateSelected+    {- ^+    area in the renderer represents+    a line in the buffer which contains part of the selection+    -}+    | AnotherGutterRendererState Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum GutterRendererState where+    fromEnum GutterRendererStateNormal = 0+    fromEnum GutterRendererStateCursor = 1+    fromEnum GutterRendererStatePrelit = 2+    fromEnum GutterRendererStateSelected = 4+    fromEnum (AnotherGutterRendererState k) = k++    toEnum 0 = GutterRendererStateNormal+    toEnum 1 = GutterRendererStateCursor+    toEnum 2 = GutterRendererStatePrelit+    toEnum 4 = GutterRendererStateSelected+    toEnum k = AnotherGutterRendererState k++instance P.Ord GutterRendererState where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gtk_source_gutter_renderer_state_get_type" c_gtk_source_gutter_renderer_state_get_type :: +    IO GType++instance BoxedFlags GutterRendererState where+    boxedFlagsType _ = c_gtk_source_gutter_renderer_state_get_type++instance IsGFlag GutterRendererState++-- Flags FileSaverFlags+{- |+Flags to define the behavior of a 'GI.GtkSource.Objects.FileSaver.FileSaver'.++/Since: 3.14/+-}+data FileSaverFlags = +      FileSaverFlagsNone+    {- ^+    No flags.+    -}+    | FileSaverFlagsIgnoreInvalidChars+    {- ^+    Ignore invalid characters.+    -}+    | FileSaverFlagsIgnoreModificationTime+    {- ^+    Save file despite external modifications.+    -}+    | FileSaverFlagsCreateBackup+    {- ^+    Create a backup before saving the file.+    -}+    | AnotherFileSaverFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum FileSaverFlags where+    fromEnum FileSaverFlagsNone = 0+    fromEnum FileSaverFlagsIgnoreInvalidChars = 1+    fromEnum FileSaverFlagsIgnoreModificationTime = 2+    fromEnum FileSaverFlagsCreateBackup = 4+    fromEnum (AnotherFileSaverFlags k) = k++    toEnum 0 = FileSaverFlagsNone+    toEnum 1 = FileSaverFlagsIgnoreInvalidChars+    toEnum 2 = FileSaverFlagsIgnoreModificationTime+    toEnum 4 = FileSaverFlagsCreateBackup+    toEnum k = AnotherFileSaverFlags k++instance P.Ord FileSaverFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gtk_source_file_saver_flags_get_type" c_gtk_source_file_saver_flags_get_type :: +    IO GType++instance BoxedFlags FileSaverFlags where+    boxedFlagsType _ = c_gtk_source_file_saver_flags_get_type++instance IsGFlag FileSaverFlags++-- Flags DrawSpacesFlags+{-# DEPRECATED DrawSpacesFlags ["(Since version 3.24)","Use 'GI.GtkSource.Flags.SpaceTypeFlags' and","'GI.GtkSource.Flags.SpaceLocationFlags' instead."] #-}+{- |+GtkSourceDrawSpacesFlags determine what kind of spaces whould be drawn. If none+of GTK_SOURCE_DRAW_SPACES_LEADING, GTK_SOURCE_DRAW_SPACES_TEXT or+GTK_SOURCE_DRAW_SPACES_TRAILING is specified, whitespaces at any position in+the line will be drawn (i.e. it has the same effect as specifying all of them).+-}+data DrawSpacesFlags = +      DrawSpacesFlagsSpace+    {- ^+    whether the space character should be drawn.+    -}+    | DrawSpacesFlagsTab+    {- ^+    whether the tab character should be drawn.+    -}+    | DrawSpacesFlagsNewline+    {- ^+    whether the line breaks should be drawn. If+      the 'GI.GtkSource.Objects.Buffer.Buffer':@/implicit-trailing-newline/@ property is 'True', a line+      break is also drawn at the end of the buffer.+    -}+    | DrawSpacesFlagsNbsp+    {- ^+    whether the non-breaking whitespaces should be drawn.+    -}+    | DrawSpacesFlagsLeading+    {- ^+    whether leading whitespaces should be drawn.+    -}+    | DrawSpacesFlagsText+    {- ^+    whether whitespaces inside text should be drawn.+    -}+    | DrawSpacesFlagsTrailing+    {- ^+    whether trailing whitespaces should be drawn.+    -}+    | DrawSpacesFlagsAll+    {- ^+    wheter all kind of spaces should be drawn.+    -}+    | AnotherDrawSpacesFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum DrawSpacesFlags where+    fromEnum DrawSpacesFlagsSpace = 1+    fromEnum DrawSpacesFlagsTab = 2+    fromEnum DrawSpacesFlagsNewline = 4+    fromEnum DrawSpacesFlagsNbsp = 8+    fromEnum DrawSpacesFlagsLeading = 16+    fromEnum DrawSpacesFlagsText = 32+    fromEnum DrawSpacesFlagsTrailing = 64+    fromEnum DrawSpacesFlagsAll = 127+    fromEnum (AnotherDrawSpacesFlags k) = k++    toEnum 1 = DrawSpacesFlagsSpace+    toEnum 2 = DrawSpacesFlagsTab+    toEnum 4 = DrawSpacesFlagsNewline+    toEnum 8 = DrawSpacesFlagsNbsp+    toEnum 16 = DrawSpacesFlagsLeading+    toEnum 32 = DrawSpacesFlagsText+    toEnum 64 = DrawSpacesFlagsTrailing+    toEnum 127 = DrawSpacesFlagsAll+    toEnum k = AnotherDrawSpacesFlags k++instance P.Ord DrawSpacesFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gtk_source_draw_spaces_flags_get_type" c_gtk_source_draw_spaces_flags_get_type :: +    IO GType++instance BoxedFlags DrawSpacesFlags where+    boxedFlagsType _ = c_gtk_source_draw_spaces_flags_get_type++instance IsGFlag DrawSpacesFlags++-- Flags CompletionActivation+{- |+/No description available in the introspection data./+-}+data CompletionActivation = +      CompletionActivationNone+    {- ^+    None.+    -}+    | CompletionActivationInteractive+    {- ^+    Interactive activation. By+    default, it occurs on each insertion in the 'GI.Gtk.Objects.TextBuffer.TextBuffer'. This can be+    blocked temporarily with 'GI.GtkSource.Objects.Completion.completionBlockInteractive'.+    -}+    | CompletionActivationUserRequested+    {- ^+    User requested activation.+    By default, it occurs when the user presses+    \<keycombo>\<keycap>Control\<\/keycap>\<keycap>space\<\/keycap>\<\/keycombo>.+    -}+    | AnotherCompletionActivation Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum CompletionActivation where+    fromEnum CompletionActivationNone = 0+    fromEnum CompletionActivationInteractive = 1+    fromEnum CompletionActivationUserRequested = 2+    fromEnum (AnotherCompletionActivation k) = k++    toEnum 0 = CompletionActivationNone+    toEnum 1 = CompletionActivationInteractive+    toEnum 2 = CompletionActivationUserRequested+    toEnum k = AnotherCompletionActivation k++instance P.Ord CompletionActivation where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++foreign import ccall "gtk_source_completion_activation_get_type" c_gtk_source_completion_activation_get_type :: +    IO GType++instance BoxedFlags CompletionActivation where+    boxedFlagsType _ = c_gtk_source_completion_activation_get_type++instance IsGFlag CompletionActivation++

@@ -0,0 +1,52 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.GtkSource.Flags 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++data SpaceTypeFlags+instance P.Enum SpaceTypeFlags where+instance BoxedFlags SpaceTypeFlags where+instance IsGFlag SpaceTypeFlags+data SpaceLocationFlags+instance P.Enum SpaceLocationFlags where+instance BoxedFlags SpaceLocationFlags where+instance IsGFlag SpaceLocationFlags+data SortFlags+instance P.Enum SortFlags where+instance BoxedFlags SortFlags where+instance IsGFlag SortFlags+data GutterRendererState+instance P.Enum GutterRendererState where+instance BoxedFlags GutterRendererState where+instance IsGFlag GutterRendererState+data FileSaverFlags+instance P.Enum FileSaverFlags where+instance BoxedFlags FileSaverFlags where+instance IsGFlag FileSaverFlags+data DrawSpacesFlags+instance P.Enum DrawSpacesFlags where+instance BoxedFlags DrawSpacesFlags where+instance IsGFlag DrawSpacesFlags+data CompletionActivation+instance P.Enum CompletionActivation where+instance BoxedFlags CompletionActivation where+instance IsGFlag CompletionActivation

@@ -0,0 +1,137 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GtkSource.Functions+    ( ++ -- * Methods+-- ** utilsEscapeSearchText #method:utilsEscapeSearchText#++    utilsEscapeSearchText                   ,+++-- ** utilsUnescapeSearchText #method:utilsUnescapeSearchText#++    utilsUnescapeSearchText                 ,+++++    ) 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+++-- function gtk_source_utils_unescape_search_text+-- Args : [Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the text to unescape.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gtk_source_utils_unescape_search_text" gtk_source_utils_unescape_search_text :: +    CString ->                              -- text : TBasicType TUTF8+    IO CString++{- |+Use this function before 'GI.GtkSource.Objects.SearchSettings.searchSettingsSetSearchText', to+unescape the following sequences of characters: @\\n@, @\\r@, @\\t@ and @\\\\@.+The purpose is to easily write those characters in a search entry.++Note that unescaping the search text is not needed for regular expression+searches.++See also: 'GI.GtkSource.Functions.utilsEscapeSearchText'.++/Since: 3.10/+-}+utilsUnescapeSearchText ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@text@/: the text to unescape. -}+    -> m T.Text+    {- ^ __Returns:__ the unescaped /@text@/. -}+utilsUnescapeSearchText text = liftIO $ do+    text' <- textToCString text+    result <- gtk_source_utils_unescape_search_text text'+    checkUnexpectedReturnNULL "utilsUnescapeSearchText" result+    result' <- cstringToText result+    freeMem result+    freeMem text'+    return result'+++-- function gtk_source_utils_escape_search_text+-- Args : [Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the text to escape.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gtk_source_utils_escape_search_text" gtk_source_utils_escape_search_text :: +    CString ->                              -- text : TBasicType TUTF8+    IO CString++{- |+Use this function to escape the following characters: @\\n@, @\\r@, @\\t@ and @\\@.++For a regular expression search, use 'GI.GLib.Functions.regexEscapeString' instead.++One possible use case is to take the 'GI.Gtk.Objects.TextBuffer.TextBuffer'\'s selection and put it in a+search entry. The selection can contain tabulations, newlines, etc. So it\'s+better to escape those special characters to better fit in the search entry.++See also: 'GI.GtkSource.Functions.utilsUnescapeSearchText'.++\<warning>+Warning: the escape and unescape functions are not reciprocal! For example,+escape (unescape (\\)) = \\. So avoid cycles such as: search entry -> unescape+-> search settings -> escape -> search entry. The original search entry text+may be modified.+\<\/warning>++/Since: 3.10/+-}+utilsEscapeSearchText ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@text@/: the text to escape. -}+    -> m T.Text+    {- ^ __Returns:__ the escaped /@text@/. -}+utilsEscapeSearchText text = liftIO $ do+    text' <- textToCString text+    result <- gtk_source_utils_escape_search_text text'+    checkUnexpectedReturnNULL "utilsEscapeSearchText" result+    result' <- cstringToText result+    freeMem result+    freeMem text'+    return result'+++

@@ -0,0 +1,47 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GtkSource.Interfaces+    (     module GI.GtkSource.Interfaces.CompletionProposal,+    module GI.GtkSource.Interfaces.CompletionProvider,+    module GI.GtkSource.Interfaces.StyleSchemeChooser,+    module GI.GtkSource.Interfaces.UndoManager,+++    ) where++import GI.GtkSource.Interfaces.CompletionProposal+import GI.GtkSource.Interfaces.CompletionProvider+import GI.GtkSource.Interfaces.StyleSchemeChooser+import GI.GtkSource.Interfaces.UndoManager++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+++

@@ -0,0 +1,701 @@+++{- |+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.Interfaces.CompletionProposal+    ( ++-- * Exported types+    CompletionProposal(..)                  ,+    noCompletionProposal                    ,+    IsCompletionProposal                    ,+    toCompletionProposal                    ,+++ -- * Methods+-- ** changed #method:changed#++#if ENABLE_OVERLOADING+    CompletionProposalChangedMethodInfo     ,+#endif+    completionProposalChanged               ,+++-- ** equal #method:equal#++#if ENABLE_OVERLOADING+    CompletionProposalEqualMethodInfo       ,+#endif+    completionProposalEqual                 ,+++-- ** getGicon #method:getGicon#++#if ENABLE_OVERLOADING+    CompletionProposalGetGiconMethodInfo    ,+#endif+    completionProposalGetGicon              ,+++-- ** getIcon #method:getIcon#++#if ENABLE_OVERLOADING+    CompletionProposalGetIconMethodInfo     ,+#endif+    completionProposalGetIcon               ,+++-- ** getIconName #method:getIconName#++#if ENABLE_OVERLOADING+    CompletionProposalGetIconNameMethodInfo ,+#endif+    completionProposalGetIconName           ,+++-- ** getInfo #method:getInfo#++#if ENABLE_OVERLOADING+    CompletionProposalGetInfoMethodInfo     ,+#endif+    completionProposalGetInfo               ,+++-- ** getLabel #method:getLabel#++#if ENABLE_OVERLOADING+    CompletionProposalGetLabelMethodInfo    ,+#endif+    completionProposalGetLabel              ,+++-- ** getMarkup #method:getMarkup#++#if ENABLE_OVERLOADING+    CompletionProposalGetMarkupMethodInfo   ,+#endif+    completionProposalGetMarkup             ,+++-- ** getText #method:getText#++#if ENABLE_OVERLOADING+    CompletionProposalGetTextMethodInfo     ,+#endif+    completionProposalGetText               ,+++-- ** hash #method:hash#++#if ENABLE_OVERLOADING+    CompletionProposalHashMethodInfo        ,+#endif+    completionProposalHash                  ,+++++ -- * Signals+-- ** changed #signal:changed#++    C_CompletionProposalChangedCallback     ,+    CompletionProposalChangedCallback       ,+#if ENABLE_OVERLOADING+    CompletionProposalChangedSignalInfo     ,+#endif+    afterCompletionProposalChanged          ,+    genClosure_CompletionProposalChanged    ,+    mk_CompletionProposalChangedCallback    ,+    noCompletionProposalChangedCallback     ,+    onCompletionProposalChanged             ,+    wrap_CompletionProposalChangedCallback  ,+++++    ) 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.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf+import qualified GI.Gio.Interfaces.Icon as Gio.Icon++-- interface CompletionProposal +-- | Memory-managed wrapper type.+newtype CompletionProposal = CompletionProposal (ManagedPtr CompletionProposal)+-- | A convenience alias for `Nothing` :: `Maybe` `CompletionProposal`.+noCompletionProposal :: Maybe CompletionProposal+noCompletionProposal = Nothing++-- signal CompletionProposal::changed+{- |+Emitted when the proposal has changed. The completion popup+will react to this by updating the shown information.+-}+type CompletionProposalChangedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `CompletionProposalChangedCallback`@.+noCompletionProposalChangedCallback :: Maybe CompletionProposalChangedCallback+noCompletionProposalChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_CompletionProposalChangedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_CompletionProposalChangedCallback`.+foreign import ccall "wrapper"+    mk_CompletionProposalChangedCallback :: C_CompletionProposalChangedCallback -> IO (FunPtr C_CompletionProposalChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_CompletionProposalChanged :: MonadIO m => CompletionProposalChangedCallback -> m (GClosure C_CompletionProposalChangedCallback)+genClosure_CompletionProposalChanged cb = liftIO $ do+    let cb' = wrap_CompletionProposalChangedCallback cb+    mk_CompletionProposalChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `CompletionProposalChangedCallback` into a `C_CompletionProposalChangedCallback`.+wrap_CompletionProposalChangedCallback ::+    CompletionProposalChangedCallback ->+    C_CompletionProposalChangedCallback+wrap_CompletionProposalChangedCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@changed@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' completionProposal #changed callback+@+-}+onCompletionProposalChanged :: (IsCompletionProposal a, MonadIO m) => a -> CompletionProposalChangedCallback -> m SignalHandlerId+onCompletionProposalChanged obj cb = liftIO $ do+    let cb' = wrap_CompletionProposalChangedCallback cb+    cb'' <- mk_CompletionProposalChangedCallback cb'+    connectSignalFunPtr obj "changed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@changed@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' completionProposal #changed callback+@+-}+afterCompletionProposalChanged :: (IsCompletionProposal a, MonadIO m) => a -> CompletionProposalChangedCallback -> m SignalHandlerId+afterCompletionProposalChanged obj cb = liftIO $ do+    let cb' = wrap_CompletionProposalChangedCallback cb+    cb'' <- mk_CompletionProposalChangedCallback cb'+    connectSignalFunPtr obj "changed" cb'' SignalConnectAfter+++#if ENABLE_OVERLOADING+data CompletionProposalChangedSignalInfo+instance SignalInfo CompletionProposalChangedSignalInfo where+    type HaskellCallbackType CompletionProposalChangedSignalInfo = CompletionProposalChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_CompletionProposalChangedCallback cb+        cb'' <- mk_CompletionProposalChangedCallback cb'+        connectSignalFunPtr obj "changed" cb'' connectMode++type instance O.SignalList CompletionProposal = CompletionProposalSignalList+type CompletionProposalSignalList = ('[ '("changed", CompletionProposalChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])++#endif++foreign import ccall "gtk_source_completion_proposal_get_type"+    c_gtk_source_completion_proposal_get_type :: IO GType++instance GObject CompletionProposal where+    gobjectType = c_gtk_source_completion_proposal_get_type+    ++-- | Type class for types which can be safely cast to `CompletionProposal`, for instance with `toCompletionProposal`.+class (GObject o, O.IsDescendantOf CompletionProposal o) => IsCompletionProposal o+instance (GObject o, O.IsDescendantOf CompletionProposal o) => IsCompletionProposal o++instance O.HasParentTypes CompletionProposal+type instance O.ParentTypes CompletionProposal = '[GObject.Object.Object]++-- | Cast to `CompletionProposal`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toCompletionProposal :: (MonadIO m, IsCompletionProposal o) => o -> m CompletionProposal+toCompletionProposal = liftIO . unsafeCastTo CompletionProposal++#if ENABLE_OVERLOADING+instance O.HasAttributeList CompletionProposal+type instance O.AttributeList CompletionProposal = CompletionProposalAttributeList+type CompletionProposalAttributeList = ('[ ] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+#endif++#if ENABLE_OVERLOADING+type family ResolveCompletionProposalMethod (t :: Symbol) (o :: *) :: * where+    ResolveCompletionProposalMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveCompletionProposalMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveCompletionProposalMethod "changed" o = CompletionProposalChangedMethodInfo+    ResolveCompletionProposalMethod "equal" o = CompletionProposalEqualMethodInfo+    ResolveCompletionProposalMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveCompletionProposalMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveCompletionProposalMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveCompletionProposalMethod "hash" o = CompletionProposalHashMethodInfo+    ResolveCompletionProposalMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveCompletionProposalMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveCompletionProposalMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveCompletionProposalMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveCompletionProposalMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveCompletionProposalMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveCompletionProposalMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveCompletionProposalMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveCompletionProposalMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveCompletionProposalMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveCompletionProposalMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveCompletionProposalMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveCompletionProposalMethod "getGicon" o = CompletionProposalGetGiconMethodInfo+    ResolveCompletionProposalMethod "getIcon" o = CompletionProposalGetIconMethodInfo+    ResolveCompletionProposalMethod "getIconName" o = CompletionProposalGetIconNameMethodInfo+    ResolveCompletionProposalMethod "getInfo" o = CompletionProposalGetInfoMethodInfo+    ResolveCompletionProposalMethod "getLabel" o = CompletionProposalGetLabelMethodInfo+    ResolveCompletionProposalMethod "getMarkup" o = CompletionProposalGetMarkupMethodInfo+    ResolveCompletionProposalMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveCompletionProposalMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveCompletionProposalMethod "getText" o = CompletionProposalGetTextMethodInfo+    ResolveCompletionProposalMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveCompletionProposalMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveCompletionProposalMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveCompletionProposalMethod t CompletionProposal, O.MethodInfo info CompletionProposal p) => OL.IsLabel t (CompletionProposal -> 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++-- method CompletionProposal::changed+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "proposal", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionProposal.", 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_completion_proposal_changed" gtk_source_completion_proposal_changed :: +    Ptr CompletionProposal ->               -- proposal : TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"})+    IO ()++{- |+Emits the \"changed\" signal on /@proposal@/. This should be called by+implementations whenever the name, icon or info of the proposal has+changed.+-}+completionProposalChanged ::+    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProposal a) =>+    a+    {- ^ /@proposal@/: a 'GI.GtkSource.Interfaces.CompletionProposal.CompletionProposal'. -}+    -> m ()+completionProposalChanged proposal = liftIO $ do+    proposal' <- unsafeManagedPtrCastPtr proposal+    gtk_source_completion_proposal_changed proposal'+    touchManagedPtr proposal+    return ()++#if ENABLE_OVERLOADING+data CompletionProposalChangedMethodInfo+instance (signature ~ (m ()), MonadIO m, IsCompletionProposal a) => O.MethodInfo CompletionProposalChangedMethodInfo a signature where+    overloadedMethod _ = completionProposalChanged++#endif++-- method CompletionProposal::equal+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "proposal", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionProposal.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "other", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionProposal.", 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_completion_proposal_equal" gtk_source_completion_proposal_equal :: +    Ptr CompletionProposal ->               -- proposal : TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"})+    Ptr CompletionProposal ->               -- other : TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"})+    IO CInt++{- |+Get whether two proposal objects are the same.  This is used to (together+with 'GI.GtkSource.Interfaces.CompletionProposal.completionProposalHash') to match proposals in the+completion model. By default, it uses direct equality ('GI.GLib.Functions.directEqual').+-}+completionProposalEqual ::+    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProposal a, IsCompletionProposal b) =>+    a+    {- ^ /@proposal@/: a 'GI.GtkSource.Interfaces.CompletionProposal.CompletionProposal'. -}+    -> b+    {- ^ /@other@/: a 'GI.GtkSource.Interfaces.CompletionProposal.CompletionProposal'. -}+    -> m Bool+    {- ^ __Returns:__ 'True' if /@proposal@/ and /@object@/ are the same proposal -}+completionProposalEqual proposal other = liftIO $ do+    proposal' <- unsafeManagedPtrCastPtr proposal+    other' <- unsafeManagedPtrCastPtr other+    result <- gtk_source_completion_proposal_equal proposal' other'+    let result' = (/= 0) result+    touchManagedPtr proposal+    touchManagedPtr other+    return result'++#if ENABLE_OVERLOADING+data CompletionProposalEqualMethodInfo+instance (signature ~ (b -> m Bool), MonadIO m, IsCompletionProposal a, IsCompletionProposal b) => O.MethodInfo CompletionProposalEqualMethodInfo a signature where+    overloadedMethod _ = completionProposalEqual++#endif++-- method CompletionProposal::get_gicon+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "proposal", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionProposal.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Gio", name = "Icon"}))+-- throws : False+-- Skip return : False++foreign import ccall "gtk_source_completion_proposal_get_gicon" gtk_source_completion_proposal_get_gicon :: +    Ptr CompletionProposal ->               -- proposal : TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"})+    IO (Ptr Gio.Icon.Icon)++{- |+Gets the 'GI.Gio.Interfaces.Icon.Icon' for the icon of /@proposal@/.++/Since: 3.18/+-}+completionProposalGetGicon ::+    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProposal a) =>+    a+    {- ^ /@proposal@/: a 'GI.GtkSource.Interfaces.CompletionProposal.CompletionProposal'. -}+    -> m (Maybe Gio.Icon.Icon)+    {- ^ __Returns:__ A 'GI.Gio.Interfaces.Icon.Icon' with the icon of /@proposal@/. -}+completionProposalGetGicon proposal = liftIO $ do+    proposal' <- unsafeManagedPtrCastPtr proposal+    result <- gtk_source_completion_proposal_get_gicon proposal'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (newObject Gio.Icon.Icon) result'+        return result''+    touchManagedPtr proposal+    return maybeResult++#if ENABLE_OVERLOADING+data CompletionProposalGetGiconMethodInfo+instance (signature ~ (m (Maybe Gio.Icon.Icon)), MonadIO m, IsCompletionProposal a) => O.MethodInfo CompletionProposalGetGiconMethodInfo a signature where+    overloadedMethod _ = completionProposalGetGicon++#endif++-- method CompletionProposal::get_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "proposal", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionProposal.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : False+-- Skip return : False++foreign import ccall "gtk_source_completion_proposal_get_icon" gtk_source_completion_proposal_get_icon :: +    Ptr CompletionProposal ->               -- proposal : TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"})+    IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)++{- |+Gets the 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' for the icon of /@proposal@/.+-}+completionProposalGetIcon ::+    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProposal a) =>+    a+    {- ^ /@proposal@/: a 'GI.GtkSource.Interfaces.CompletionProposal.CompletionProposal'. -}+    -> m (Maybe GdkPixbuf.Pixbuf.Pixbuf)+    {- ^ __Returns:__ A 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' with the icon of /@proposal@/. -}+completionProposalGetIcon proposal = liftIO $ do+    proposal' <- unsafeManagedPtrCastPtr proposal+    result <- gtk_source_completion_proposal_get_icon proposal'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (newObject GdkPixbuf.Pixbuf.Pixbuf) result'+        return result''+    touchManagedPtr proposal+    return maybeResult++#if ENABLE_OVERLOADING+data CompletionProposalGetIconMethodInfo+instance (signature ~ (m (Maybe GdkPixbuf.Pixbuf.Pixbuf)), MonadIO m, IsCompletionProposal a) => O.MethodInfo CompletionProposalGetIconMethodInfo a signature where+    overloadedMethod _ = completionProposalGetIcon++#endif++-- method CompletionProposal::get_icon_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "proposal", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionProposal.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gtk_source_completion_proposal_get_icon_name" gtk_source_completion_proposal_get_icon_name :: +    Ptr CompletionProposal ->               -- proposal : TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"})+    IO CString++{- |+Gets the icon name of /@proposal@/.++/Since: 3.18/+-}+completionProposalGetIconName ::+    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProposal a) =>+    a+    {- ^ /@proposal@/: a 'GI.GtkSource.Interfaces.CompletionProposal.CompletionProposal'. -}+    -> m (Maybe T.Text)+    {- ^ __Returns:__ The icon name of /@proposal@/. -}+completionProposalGetIconName proposal = liftIO $ do+    proposal' <- unsafeManagedPtrCastPtr proposal+    result <- gtk_source_completion_proposal_get_icon_name proposal'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- cstringToText result'+        return result''+    touchManagedPtr proposal+    return maybeResult++#if ENABLE_OVERLOADING+data CompletionProposalGetIconNameMethodInfo+instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsCompletionProposal a) => O.MethodInfo CompletionProposalGetIconNameMethodInfo a signature where+    overloadedMethod _ = completionProposalGetIconName++#endif++-- method CompletionProposal::get_info+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "proposal", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionProposal.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gtk_source_completion_proposal_get_info" gtk_source_completion_proposal_get_info :: +    Ptr CompletionProposal ->               -- proposal : TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"})+    IO CString++{- |+Gets extra information associated to the proposal. This information will be+used to present the user with extra, detailed information about the+selected proposal. The returned string must be freed with 'GI.GLib.Functions.free'.+-}+completionProposalGetInfo ::+    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProposal a) =>+    a+    {- ^ /@proposal@/: a 'GI.GtkSource.Interfaces.CompletionProposal.CompletionProposal'. -}+    -> m (Maybe T.Text)+    {- ^ __Returns:__ a newly-allocated string containing+extra information of /@proposal@/ or 'Nothing' if no extra information is associated+to /@proposal@/. -}+completionProposalGetInfo proposal = liftIO $ do+    proposal' <- unsafeManagedPtrCastPtr proposal+    result <- gtk_source_completion_proposal_get_info proposal'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- cstringToText result'+        freeMem result'+        return result''+    touchManagedPtr proposal+    return maybeResult++#if ENABLE_OVERLOADING+data CompletionProposalGetInfoMethodInfo+instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsCompletionProposal a) => O.MethodInfo CompletionProposalGetInfoMethodInfo a signature where+    overloadedMethod _ = completionProposalGetInfo++#endif++-- method CompletionProposal::get_label+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "proposal", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionProposal.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gtk_source_completion_proposal_get_label" gtk_source_completion_proposal_get_label :: +    Ptr CompletionProposal ->               -- proposal : TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"})+    IO CString++{- |+Gets the label of /@proposal@/. The label is shown in the list of proposals as+plain text. If you need any markup (such as bold or italic text), you have+to implement 'GI.GtkSource.Interfaces.CompletionProposal.completionProposalGetMarkup'. The returned string+must be freed with 'GI.GLib.Functions.free'.+-}+completionProposalGetLabel ::+    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProposal a) =>+    a+    {- ^ /@proposal@/: a 'GI.GtkSource.Interfaces.CompletionProposal.CompletionProposal'. -}+    -> m T.Text+    {- ^ __Returns:__ a new string containing the label of /@proposal@/. -}+completionProposalGetLabel proposal = liftIO $ do+    proposal' <- unsafeManagedPtrCastPtr proposal+    result <- gtk_source_completion_proposal_get_label proposal'+    checkUnexpectedReturnNULL "completionProposalGetLabel" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr proposal+    return result'++#if ENABLE_OVERLOADING+data CompletionProposalGetLabelMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsCompletionProposal a) => O.MethodInfo CompletionProposalGetLabelMethodInfo a signature where+    overloadedMethod _ = completionProposalGetLabel++#endif++-- method CompletionProposal::get_markup+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "proposal", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionProposal.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gtk_source_completion_proposal_get_markup" gtk_source_completion_proposal_get_markup :: +    Ptr CompletionProposal ->               -- proposal : TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"})+    IO CString++{- |+Gets the label of /@proposal@/ with markup. The label is shown in the list of+proposals and may contain markup. This will be used instead of+'GI.GtkSource.Interfaces.CompletionProposal.completionProposalGetLabel' if implemented. The returned string+must be freed with 'GI.GLib.Functions.free'.+-}+completionProposalGetMarkup ::+    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProposal a) =>+    a+    {- ^ /@proposal@/: a 'GI.GtkSource.Interfaces.CompletionProposal.CompletionProposal'. -}+    -> m T.Text+    {- ^ __Returns:__ a new string containing the label of /@proposal@/ with markup. -}+completionProposalGetMarkup proposal = liftIO $ do+    proposal' <- unsafeManagedPtrCastPtr proposal+    result <- gtk_source_completion_proposal_get_markup proposal'+    checkUnexpectedReturnNULL "completionProposalGetMarkup" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr proposal+    return result'++#if ENABLE_OVERLOADING+data CompletionProposalGetMarkupMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsCompletionProposal a) => O.MethodInfo CompletionProposalGetMarkupMethodInfo a signature where+    overloadedMethod _ = completionProposalGetMarkup++#endif++-- method CompletionProposal::get_text+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "proposal", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionProposal.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gtk_source_completion_proposal_get_text" gtk_source_completion_proposal_get_text :: +    Ptr CompletionProposal ->               -- proposal : TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"})+    IO CString++{- |+Gets the text of /@proposal@/. The text that is inserted into+the text buffer when the proposal is activated by the default activation.+You are free to implement a custom activation handler in the provider and+not implement this function. For more information, see+'GI.GtkSource.Interfaces.CompletionProvider.completionProviderActivateProposal'. The returned string must+be freed with 'GI.GLib.Functions.free'.+-}+completionProposalGetText ::+    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProposal a) =>+    a+    {- ^ /@proposal@/: a 'GI.GtkSource.Interfaces.CompletionProposal.CompletionProposal'. -}+    -> m T.Text+    {- ^ __Returns:__ a new string containing the text of /@proposal@/. -}+completionProposalGetText proposal = liftIO $ do+    proposal' <- unsafeManagedPtrCastPtr proposal+    result <- gtk_source_completion_proposal_get_text proposal'+    checkUnexpectedReturnNULL "completionProposalGetText" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr proposal+    return result'++#if ENABLE_OVERLOADING+data CompletionProposalGetTextMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsCompletionProposal a) => O.MethodInfo CompletionProposalGetTextMethodInfo a signature where+    overloadedMethod _ = completionProposalGetText++#endif++-- method CompletionProposal::hash+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "proposal", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionProposal.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUInt)+-- throws : False+-- Skip return : False++foreign import ccall "gtk_source_completion_proposal_hash" gtk_source_completion_proposal_hash :: +    Ptr CompletionProposal ->               -- proposal : TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"})+    IO Word32++{- |+Get the hash value of /@proposal@/. This is used to (together with+'GI.GtkSource.Interfaces.CompletionProposal.completionProposalEqual') to match proposals in the completion+model. By default, it uses a direct hash ('GI.GLib.Functions.directHash').+-}+completionProposalHash ::+    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProposal a) =>+    a+    {- ^ /@proposal@/: a 'GI.GtkSource.Interfaces.CompletionProposal.CompletionProposal'. -}+    -> m Word32+    {- ^ __Returns:__ The hash value of /@proposal@/. -}+completionProposalHash proposal = liftIO $ do+    proposal' <- unsafeManagedPtrCastPtr proposal+    result <- gtk_source_completion_proposal_hash proposal'+    touchManagedPtr proposal+    return result++#if ENABLE_OVERLOADING+data CompletionProposalHashMethodInfo+instance (signature ~ (m Word32), MonadIO m, IsCompletionProposal a) => O.MethodInfo CompletionProposalHashMethodInfo a signature where+    overloadedMethod _ = completionProposalHash++#endif++

@@ -0,0 +1,62 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.GtkSource.Interfaces.CompletionProposal 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++newtype CompletionProposal = CompletionProposal (ManagedPtr CompletionProposal)+#if ENABLE_OVERLOADING+data CompletionProposalChangedSignalInfo+#endif+instance GObject CompletionProposal where+class (GObject o, O.IsDescendantOf CompletionProposal o) => IsCompletionProposal o+instance (GObject o, O.IsDescendantOf CompletionProposal o) => IsCompletionProposal o+instance O.HasParentTypes CompletionProposal+#if ENABLE_OVERLOADING+data CompletionProposalChangedMethodInfo+#endif+#if ENABLE_OVERLOADING+data CompletionProposalEqualMethodInfo+#endif+#if ENABLE_OVERLOADING+data CompletionProposalGetGiconMethodInfo+#endif+#if ENABLE_OVERLOADING+data CompletionProposalGetIconMethodInfo+#endif+#if ENABLE_OVERLOADING+data CompletionProposalGetIconNameMethodInfo+#endif+#if ENABLE_OVERLOADING+data CompletionProposalGetInfoMethodInfo+#endif+#if ENABLE_OVERLOADING+data CompletionProposalGetLabelMethodInfo+#endif+#if ENABLE_OVERLOADING+data CompletionProposalGetMarkupMethodInfo+#endif+#if ENABLE_OVERLOADING+data CompletionProposalGetTextMethodInfo+#endif+#if ENABLE_OVERLOADING+data CompletionProposalHashMethodInfo+#endif

@@ -0,0 +1,816 @@+++{- |+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.Interfaces.CompletionProvider+    ( ++-- * Exported types+    CompletionProvider(..)                  ,+    noCompletionProvider                    ,+    IsCompletionProvider                    ,+    toCompletionProvider                    ,+++ -- * Methods+-- ** activateProposal #method:activateProposal#++#if ENABLE_OVERLOADING+    CompletionProviderActivateProposalMethodInfo,+#endif+    completionProviderActivateProposal      ,+++-- ** getActivation #method:getActivation#++#if ENABLE_OVERLOADING+    CompletionProviderGetActivationMethodInfo,+#endif+    completionProviderGetActivation         ,+++-- ** getGicon #method:getGicon#++#if ENABLE_OVERLOADING+    CompletionProviderGetGiconMethodInfo    ,+#endif+    completionProviderGetGicon              ,+++-- ** getIcon #method:getIcon#++#if ENABLE_OVERLOADING+    CompletionProviderGetIconMethodInfo     ,+#endif+    completionProviderGetIcon               ,+++-- ** getIconName #method:getIconName#++#if ENABLE_OVERLOADING+    CompletionProviderGetIconNameMethodInfo ,+#endif+    completionProviderGetIconName           ,+++-- ** getInfoWidget #method:getInfoWidget#++#if ENABLE_OVERLOADING+    CompletionProviderGetInfoWidgetMethodInfo,+#endif+    completionProviderGetInfoWidget         ,+++-- ** getInteractiveDelay #method:getInteractiveDelay#++#if ENABLE_OVERLOADING+    CompletionProviderGetInteractiveDelayMethodInfo,+#endif+    completionProviderGetInteractiveDelay   ,+++-- ** getName #method:getName#++#if ENABLE_OVERLOADING+    CompletionProviderGetNameMethodInfo     ,+#endif+    completionProviderGetName               ,+++-- ** getPriority #method:getPriority#++#if ENABLE_OVERLOADING+    CompletionProviderGetPriorityMethodInfo ,+#endif+    completionProviderGetPriority           ,+++-- ** getStartIter #method:getStartIter#++#if ENABLE_OVERLOADING+    CompletionProviderGetStartIterMethodInfo,+#endif+    completionProviderGetStartIter          ,+++-- ** match #method:match#++#if ENABLE_OVERLOADING+    CompletionProviderMatchMethodInfo       ,+#endif+    completionProviderMatch                 ,+++-- ** populate #method:populate#++#if ENABLE_OVERLOADING+    CompletionProviderPopulateMethodInfo    ,+#endif+    completionProviderPopulate              ,+++-- ** updateInfo #method:updateInfo#++#if ENABLE_OVERLOADING+    CompletionProviderUpdateInfoMethodInfo  ,+#endif+    completionProviderUpdateInfo            ,+++++    ) 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.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf+import qualified GI.Gio.Interfaces.Icon as Gio.Icon+import qualified GI.Gtk.Objects.Widget as Gtk.Widget+import qualified GI.Gtk.Structs.TextIter as Gtk.TextIter+import {-# SOURCE #-} qualified GI.GtkSource.Flags as GtkSource.Flags+import {-# SOURCE #-} qualified GI.GtkSource.Interfaces.CompletionProposal as GtkSource.CompletionProposal+import {-# SOURCE #-} qualified GI.GtkSource.Objects.CompletionContext as GtkSource.CompletionContext+import {-# SOURCE #-} qualified GI.GtkSource.Objects.CompletionInfo as GtkSource.CompletionInfo++-- interface CompletionProvider +-- | Memory-managed wrapper type.+newtype CompletionProvider = CompletionProvider (ManagedPtr CompletionProvider)+-- | A convenience alias for `Nothing` :: `Maybe` `CompletionProvider`.+noCompletionProvider :: Maybe CompletionProvider+noCompletionProvider = Nothing++#if ENABLE_OVERLOADING+type instance O.SignalList CompletionProvider = CompletionProviderSignalList+type CompletionProviderSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])++#endif++foreign import ccall "gtk_source_completion_provider_get_type"+    c_gtk_source_completion_provider_get_type :: IO GType++instance GObject CompletionProvider where+    gobjectType = c_gtk_source_completion_provider_get_type+    ++-- | Type class for types which can be safely cast to `CompletionProvider`, for instance with `toCompletionProvider`.+class (GObject o, O.IsDescendantOf CompletionProvider o) => IsCompletionProvider o+instance (GObject o, O.IsDescendantOf CompletionProvider o) => IsCompletionProvider o++instance O.HasParentTypes CompletionProvider+type instance O.ParentTypes CompletionProvider = '[GObject.Object.Object]++-- | Cast to `CompletionProvider`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toCompletionProvider :: (MonadIO m, IsCompletionProvider o) => o -> m CompletionProvider+toCompletionProvider = liftIO . unsafeCastTo CompletionProvider++#if ENABLE_OVERLOADING+instance O.HasAttributeList CompletionProvider+type instance O.AttributeList CompletionProvider = CompletionProviderAttributeList+type CompletionProviderAttributeList = ('[ ] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+#endif++#if ENABLE_OVERLOADING+type family ResolveCompletionProviderMethod (t :: Symbol) (o :: *) :: * where+    ResolveCompletionProviderMethod "activateProposal" o = CompletionProviderActivateProposalMethodInfo+    ResolveCompletionProviderMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveCompletionProviderMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveCompletionProviderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveCompletionProviderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveCompletionProviderMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveCompletionProviderMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveCompletionProviderMethod "match" o = CompletionProviderMatchMethodInfo+    ResolveCompletionProviderMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveCompletionProviderMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveCompletionProviderMethod "populate" o = CompletionProviderPopulateMethodInfo+    ResolveCompletionProviderMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveCompletionProviderMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveCompletionProviderMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveCompletionProviderMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveCompletionProviderMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveCompletionProviderMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveCompletionProviderMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveCompletionProviderMethod "updateInfo" o = CompletionProviderUpdateInfoMethodInfo+    ResolveCompletionProviderMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveCompletionProviderMethod "getActivation" o = CompletionProviderGetActivationMethodInfo+    ResolveCompletionProviderMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveCompletionProviderMethod "getGicon" o = CompletionProviderGetGiconMethodInfo+    ResolveCompletionProviderMethod "getIcon" o = CompletionProviderGetIconMethodInfo+    ResolveCompletionProviderMethod "getIconName" o = CompletionProviderGetIconNameMethodInfo+    ResolveCompletionProviderMethod "getInfoWidget" o = CompletionProviderGetInfoWidgetMethodInfo+    ResolveCompletionProviderMethod "getInteractiveDelay" o = CompletionProviderGetInteractiveDelayMethodInfo+    ResolveCompletionProviderMethod "getName" o = CompletionProviderGetNameMethodInfo+    ResolveCompletionProviderMethod "getPriority" o = CompletionProviderGetPriorityMethodInfo+    ResolveCompletionProviderMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveCompletionProviderMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveCompletionProviderMethod "getStartIter" o = CompletionProviderGetStartIterMethodInfo+    ResolveCompletionProviderMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveCompletionProviderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveCompletionProviderMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveCompletionProviderMethod t CompletionProvider, O.MethodInfo info CompletionProvider p) => OL.IsLabel t (CompletionProvider -> 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++-- method CompletionProvider::activate_proposal+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "provider", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionProvider.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "proposal", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionProposal.", 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 (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "gtk_source_completion_provider_activate_proposal" gtk_source_completion_provider_activate_proposal :: +    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})+    Ptr GtkSource.CompletionProposal.CompletionProposal -> -- proposal : TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"})+    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})+    IO CInt++{- |+Activate /@proposal@/ at /@iter@/. When this functions returns 'False', the default+activation of /@proposal@/ will take place which replaces the word at /@iter@/+with the text of /@proposal@/ (see 'GI.GtkSource.Interfaces.CompletionProposal.completionProposalGetText').++Here is how the default activation selects the boundaries of the word to+replace. The end of the word is /@iter@/. For the start of the word, it depends+on whether a start iter is defined for /@proposal@/ (see+'GI.GtkSource.Interfaces.CompletionProvider.completionProviderGetStartIter'). If a start iter is defined,+the start of the word is the start iter. Else, the word (as long as possible)+will contain only alphanumerical and the \"_\" characters.+-}+completionProviderActivateProposal ::+    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a, GtkSource.CompletionProposal.IsCompletionProposal b) =>+    a+    {- ^ /@provider@/: a 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'. -}+    -> b+    {- ^ /@proposal@/: a 'GI.GtkSource.Interfaces.CompletionProposal.CompletionProposal'. -}+    -> Gtk.TextIter.TextIter+    {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -}+    -> m Bool+    {- ^ __Returns:__ 'True' to indicate that the proposal activation has been handled,+         'False' otherwise. -}+completionProviderActivateProposal provider proposal iter = liftIO $ do+    provider' <- unsafeManagedPtrCastPtr provider+    proposal' <- unsafeManagedPtrCastPtr proposal+    iter' <- unsafeManagedPtrGetPtr iter+    result <- gtk_source_completion_provider_activate_proposal provider' proposal' iter'+    let result' = (/= 0) result+    touchManagedPtr provider+    touchManagedPtr proposal+    touchManagedPtr iter+    return result'++#if ENABLE_OVERLOADING+data CompletionProviderActivateProposalMethodInfo+instance (signature ~ (b -> Gtk.TextIter.TextIter -> m Bool), MonadIO m, IsCompletionProvider a, GtkSource.CompletionProposal.IsCompletionProposal b) => O.MethodInfo CompletionProviderActivateProposalMethodInfo a signature where+    overloadedMethod _ = completionProviderActivateProposal++#endif++-- method CompletionProvider::get_activation+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "provider", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionProvider.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "CompletionActivation"}))+-- throws : False+-- Skip return : False++foreign import ccall "gtk_source_completion_provider_get_activation" gtk_source_completion_provider_get_activation :: +    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})+    IO CUInt++{- |+Get with what kind of activation the provider should be activated.+-}+completionProviderGetActivation ::+    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a) =>+    a+    {- ^ /@provider@/: a 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'. -}+    -> m [GtkSource.Flags.CompletionActivation]+    {- ^ __Returns:__ a combination of 'GI.GtkSource.Flags.CompletionActivation'. -}+completionProviderGetActivation provider = liftIO $ do+    provider' <- unsafeManagedPtrCastPtr provider+    result <- gtk_source_completion_provider_get_activation provider'+    let result' = wordToGFlags result+    touchManagedPtr provider+    return result'++#if ENABLE_OVERLOADING+data CompletionProviderGetActivationMethodInfo+instance (signature ~ (m [GtkSource.Flags.CompletionActivation]), MonadIO m, IsCompletionProvider a) => O.MethodInfo CompletionProviderGetActivationMethodInfo a signature where+    overloadedMethod _ = completionProviderGetActivation++#endif++-- method CompletionProvider::get_gicon+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "provider", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GtkSourceCompletionProvider", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Gio", name = "Icon"}))+-- throws : False+-- Skip return : False++foreign import ccall "gtk_source_completion_provider_get_gicon" gtk_source_completion_provider_get_gicon :: +    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})+    IO (Ptr Gio.Icon.Icon)++{- |+Gets the 'GI.Gio.Interfaces.Icon.Icon' for the icon of /@provider@/.++/Since: 3.18/+-}+completionProviderGetGicon ::+    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a) =>+    a+    {- ^ /@provider@/: The 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider' -}+    -> m (Maybe Gio.Icon.Icon)+    {- ^ __Returns:__ The icon to be used for the provider,+         or 'Nothing' if the provider does not have a special icon. -}+completionProviderGetGicon provider = liftIO $ do+    provider' <- unsafeManagedPtrCastPtr provider+    result <- gtk_source_completion_provider_get_gicon provider'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (newObject Gio.Icon.Icon) result'+        return result''+    touchManagedPtr provider+    return maybeResult++#if ENABLE_OVERLOADING+data CompletionProviderGetGiconMethodInfo+instance (signature ~ (m (Maybe Gio.Icon.Icon)), MonadIO m, IsCompletionProvider a) => O.MethodInfo CompletionProviderGetGiconMethodInfo a signature where+    overloadedMethod _ = completionProviderGetGicon++#endif++-- method CompletionProvider::get_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "provider", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GtkSourceCompletionProvider", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))+-- throws : False+-- Skip return : False++foreign import ccall "gtk_source_completion_provider_get_icon" gtk_source_completion_provider_get_icon :: +    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})+    IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)++{- |+Get the 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' for the icon of the /@provider@/.+-}+completionProviderGetIcon ::+    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a) =>+    a+    {- ^ /@provider@/: The 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider' -}+    -> m (Maybe GdkPixbuf.Pixbuf.Pixbuf)+    {- ^ __Returns:__ The icon to be used for the provider,+         or 'Nothing' if the provider does not have a special icon. -}+completionProviderGetIcon provider = liftIO $ do+    provider' <- unsafeManagedPtrCastPtr provider+    result <- gtk_source_completion_provider_get_icon provider'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (newObject GdkPixbuf.Pixbuf.Pixbuf) result'+        return result''+    touchManagedPtr provider+    return maybeResult++#if ENABLE_OVERLOADING+data CompletionProviderGetIconMethodInfo+instance (signature ~ (m (Maybe GdkPixbuf.Pixbuf.Pixbuf)), MonadIO m, IsCompletionProvider a) => O.MethodInfo CompletionProviderGetIconMethodInfo a signature where+    overloadedMethod _ = completionProviderGetIcon++#endif++-- method CompletionProvider::get_icon_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "provider", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GtkSourceCompletionProvider", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gtk_source_completion_provider_get_icon_name" gtk_source_completion_provider_get_icon_name :: +    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})+    IO CString++{- |+Gets the icon name of /@provider@/.++/Since: 3.18/+-}+completionProviderGetIconName ::+    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a) =>+    a+    {- ^ /@provider@/: The 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider' -}+    -> m (Maybe T.Text)+    {- ^ __Returns:__ The icon name to be used for the provider,+         or 'Nothing' if the provider does not have a special icon. -}+completionProviderGetIconName provider = liftIO $ do+    provider' <- unsafeManagedPtrCastPtr provider+    result <- gtk_source_completion_provider_get_icon_name provider'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- cstringToText result'+        return result''+    touchManagedPtr provider+    return maybeResult++#if ENABLE_OVERLOADING+data CompletionProviderGetIconNameMethodInfo+instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsCompletionProvider a) => O.MethodInfo CompletionProviderGetIconNameMethodInfo a signature where+    overloadedMethod _ = completionProviderGetIconName++#endif++-- method CompletionProvider::get_info_widget+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "provider", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionProvider.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "proposal", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a currently selected #GtkSourceCompletionProposal.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Widget"}))+-- throws : False+-- Skip return : False++foreign import ccall "gtk_source_completion_provider_get_info_widget" gtk_source_completion_provider_get_info_widget :: +    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})+    Ptr GtkSource.CompletionProposal.CompletionProposal -> -- proposal : TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"})+    IO (Ptr Gtk.Widget.Widget)++{- |+Get a customized info widget to show extra information of a proposal.+This allows for customized widgets on a proposal basis, although in general+providers will have the same custom widget for all their proposals and+/@proposal@/ can be ignored. The implementation of this function is optional.++If this function is not implemented, the default widget is a 'GI.Gtk.Objects.Label.Label'. The+return value of 'GI.GtkSource.Interfaces.CompletionProposal.completionProposalGetInfo' is used as the+content of the 'GI.Gtk.Objects.Label.Label'.++\<note>+  \<para>+    If implemented, 'GI.GtkSource.Interfaces.CompletionProvider.completionProviderUpdateInfo'+    \<emphasis>must\<\/emphasis> also be implemented.+  \<\/para>+\<\/note>+-}+completionProviderGetInfoWidget ::+    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a, GtkSource.CompletionProposal.IsCompletionProposal b) =>+    a+    {- ^ /@provider@/: a 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'. -}+    -> b+    {- ^ /@proposal@/: a currently selected 'GI.GtkSource.Interfaces.CompletionProposal.CompletionProposal'. -}+    -> m (Maybe Gtk.Widget.Widget)+    {- ^ __Returns:__ a custom 'GI.Gtk.Objects.Widget.Widget' to show extra+information about /@proposal@/, or 'Nothing' if the provider does not have a special+info widget. -}+completionProviderGetInfoWidget provider proposal = liftIO $ do+    provider' <- unsafeManagedPtrCastPtr provider+    proposal' <- unsafeManagedPtrCastPtr proposal+    result <- gtk_source_completion_provider_get_info_widget provider' proposal'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (newObject Gtk.Widget.Widget) result'+        return result''+    touchManagedPtr provider+    touchManagedPtr proposal+    return maybeResult++#if ENABLE_OVERLOADING+data CompletionProviderGetInfoWidgetMethodInfo+instance (signature ~ (b -> m (Maybe Gtk.Widget.Widget)), MonadIO m, IsCompletionProvider a, GtkSource.CompletionProposal.IsCompletionProposal b) => O.MethodInfo CompletionProviderGetInfoWidgetMethodInfo a signature where+    overloadedMethod _ = completionProviderGetInfoWidget++#endif++-- method CompletionProvider::get_interactive_delay+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "provider", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionProvider.", 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_completion_provider_get_interactive_delay" gtk_source_completion_provider_get_interactive_delay :: +    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})+    IO Int32++{- |+Get the delay in milliseconds before starting interactive completion for+this provider. A value of -1 indicates to use the default value as set+by the 'GI.GtkSource.Objects.Completion.Completion':@/auto-complete-delay/@ property.+-}+completionProviderGetInteractiveDelay ::+    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a) =>+    a+    {- ^ /@provider@/: a 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'. -}+    -> m Int32+    {- ^ __Returns:__ the interactive delay in milliseconds. -}+completionProviderGetInteractiveDelay provider = liftIO $ do+    provider' <- unsafeManagedPtrCastPtr provider+    result <- gtk_source_completion_provider_get_interactive_delay provider'+    touchManagedPtr provider+    return result++#if ENABLE_OVERLOADING+data CompletionProviderGetInteractiveDelayMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsCompletionProvider a) => O.MethodInfo CompletionProviderGetInteractiveDelayMethodInfo a signature where+    overloadedMethod _ = completionProviderGetInteractiveDelay++#endif++-- method CompletionProvider::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "provider", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionProvider.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gtk_source_completion_provider_get_name" gtk_source_completion_provider_get_name :: +    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})+    IO CString++{- |+Get the name of the provider. This should be a translatable name for+display to the user. For example: _(\"Document word completion provider\"). The+returned string must be freed with 'GI.GLib.Functions.free'.+-}+completionProviderGetName ::+    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a) =>+    a+    {- ^ /@provider@/: a 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'. -}+    -> m T.Text+    {- ^ __Returns:__ a new string containing the name of the provider. -}+completionProviderGetName provider = liftIO $ do+    provider' <- unsafeManagedPtrCastPtr provider+    result <- gtk_source_completion_provider_get_name provider'+    checkUnexpectedReturnNULL "completionProviderGetName" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr provider+    return result'++#if ENABLE_OVERLOADING+data CompletionProviderGetNameMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsCompletionProvider a) => O.MethodInfo CompletionProviderGetNameMethodInfo a signature where+    overloadedMethod _ = completionProviderGetName++#endif++-- method CompletionProvider::get_priority+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "provider", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionProvider.", 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_completion_provider_get_priority" gtk_source_completion_provider_get_priority :: +    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})+    IO Int32++{- |+Get the provider priority. The priority determines the order in which+proposals appear in the completion popup. Higher priorities are sorted+before lower priorities. The default priority is 0.+-}+completionProviderGetPriority ::+    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a) =>+    a+    {- ^ /@provider@/: a 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'. -}+    -> m Int32+    {- ^ __Returns:__ the provider priority. -}+completionProviderGetPriority provider = liftIO $ do+    provider' <- unsafeManagedPtrCastPtr provider+    result <- gtk_source_completion_provider_get_priority provider'+    touchManagedPtr provider+    return result++#if ENABLE_OVERLOADING+data CompletionProviderGetPriorityMethodInfo+instance (signature ~ (m Int32), MonadIO m, IsCompletionProvider a) => O.MethodInfo CompletionProviderGetPriorityMethodInfo a signature where+    overloadedMethod _ = completionProviderGetPriority++#endif++-- method CompletionProvider::get_start_iter+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "provider", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionProvider.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionContext.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "proposal", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionProposal.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "gtk_source_completion_provider_get_start_iter" gtk_source_completion_provider_get_start_iter :: +    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})+    Ptr GtkSource.CompletionContext.CompletionContext -> -- context : TInterface (Name {namespace = "GtkSource", name = "CompletionContext"})+    Ptr GtkSource.CompletionProposal.CompletionProposal -> -- proposal : TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"})+    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})+    IO CInt++{- |+Get the 'GI.Gtk.Structs.TextIter.TextIter' at which the completion for /@proposal@/ starts. When+implemented, this information is used to position the completion window+accordingly when a proposal is selected in the completion window. The+/@proposal@/ text inside the completion window is aligned on /@iter@/.++If this function is not implemented, the word boundary is taken to position+the completion window. See 'GI.GtkSource.Interfaces.CompletionProvider.completionProviderActivateProposal'+for an explanation on the word boundaries.++When the /@proposal@/ is activated, the default handler uses /@iter@/ as the start+of the word to replace. See+'GI.GtkSource.Interfaces.CompletionProvider.completionProviderActivateProposal' for more information.+-}+completionProviderGetStartIter ::+    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a, GtkSource.CompletionContext.IsCompletionContext b, GtkSource.CompletionProposal.IsCompletionProposal c) =>+    a+    {- ^ /@provider@/: a 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'. -}+    -> b+    {- ^ /@context@/: a 'GI.GtkSource.Objects.CompletionContext.CompletionContext'. -}+    -> c+    {- ^ /@proposal@/: a 'GI.GtkSource.Interfaces.CompletionProposal.CompletionProposal'. -}+    -> m ((Bool, Gtk.TextIter.TextIter))+    {- ^ __Returns:__ 'True' if /@iter@/ was set for /@proposal@/, 'False' otherwise. -}+completionProviderGetStartIter provider context proposal = liftIO $ do+    provider' <- unsafeManagedPtrCastPtr provider+    context' <- unsafeManagedPtrCastPtr context+    proposal' <- unsafeManagedPtrCastPtr proposal+    iter <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter)+    result <- gtk_source_completion_provider_get_start_iter provider' context' proposal' iter+    let result' = (/= 0) result+    iter' <- (wrapBoxed Gtk.TextIter.TextIter) iter+    touchManagedPtr provider+    touchManagedPtr context+    touchManagedPtr proposal+    return (result', iter')++#if ENABLE_OVERLOADING+data CompletionProviderGetStartIterMethodInfo+instance (signature ~ (b -> c -> m ((Bool, Gtk.TextIter.TextIter))), MonadIO m, IsCompletionProvider a, GtkSource.CompletionContext.IsCompletionContext b, GtkSource.CompletionProposal.IsCompletionProposal c) => O.MethodInfo CompletionProviderGetStartIterMethodInfo a signature where+    overloadedMethod _ = completionProviderGetStartIter++#endif++-- method CompletionProvider::match+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "provider", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionProvider.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionContext.", 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_completion_provider_match" gtk_source_completion_provider_match :: +    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})+    Ptr GtkSource.CompletionContext.CompletionContext -> -- context : TInterface (Name {namespace = "GtkSource", name = "CompletionContext"})+    IO CInt++{- |+Get whether the provider match the context of completion detailed in+/@context@/.+-}+completionProviderMatch ::+    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a, GtkSource.CompletionContext.IsCompletionContext b) =>+    a+    {- ^ /@provider@/: a 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'. -}+    -> b+    {- ^ /@context@/: a 'GI.GtkSource.Objects.CompletionContext.CompletionContext'. -}+    -> m Bool+    {- ^ __Returns:__ 'True' if /@provider@/ matches the completion context, 'False' otherwise. -}+completionProviderMatch provider context = liftIO $ do+    provider' <- unsafeManagedPtrCastPtr provider+    context' <- unsafeManagedPtrCastPtr context+    result <- gtk_source_completion_provider_match provider' context'+    let result' = (/= 0) result+    touchManagedPtr provider+    touchManagedPtr context+    return result'++#if ENABLE_OVERLOADING+data CompletionProviderMatchMethodInfo+instance (signature ~ (b -> m Bool), MonadIO m, IsCompletionProvider a, GtkSource.CompletionContext.IsCompletionContext b) => O.MethodInfo CompletionProviderMatchMethodInfo a signature where+    overloadedMethod _ = completionProviderMatch++#endif++-- method CompletionProvider::populate+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "provider", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionProvider.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionContext.", 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_completion_provider_populate" gtk_source_completion_provider_populate :: +    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})+    Ptr GtkSource.CompletionContext.CompletionContext -> -- context : TInterface (Name {namespace = "GtkSource", name = "CompletionContext"})+    IO ()++{- |+Populate /@context@/ with proposals from /@provider@/ added with the+'GI.GtkSource.Objects.CompletionContext.completionContextAddProposals' function.+-}+completionProviderPopulate ::+    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a, GtkSource.CompletionContext.IsCompletionContext b) =>+    a+    {- ^ /@provider@/: a 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'. -}+    -> b+    {- ^ /@context@/: a 'GI.GtkSource.Objects.CompletionContext.CompletionContext'. -}+    -> m ()+completionProviderPopulate provider context = liftIO $ do+    provider' <- unsafeManagedPtrCastPtr provider+    context' <- unsafeManagedPtrCastPtr context+    gtk_source_completion_provider_populate provider' context'+    touchManagedPtr provider+    touchManagedPtr context+    return ()++#if ENABLE_OVERLOADING+data CompletionProviderPopulateMethodInfo+instance (signature ~ (b -> m ()), MonadIO m, IsCompletionProvider a, GtkSource.CompletionContext.IsCompletionContext b) => O.MethodInfo CompletionProviderPopulateMethodInfo a signature where+    overloadedMethod _ = completionProviderPopulate++#endif++-- method CompletionProvider::update_info+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "provider", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionProvider.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "proposal", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionProposal.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionInfo.", 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_completion_provider_update_info" gtk_source_completion_provider_update_info :: +    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})+    Ptr GtkSource.CompletionProposal.CompletionProposal -> -- proposal : TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"})+    Ptr GtkSource.CompletionInfo.CompletionInfo -> -- info : TInterface (Name {namespace = "GtkSource", name = "CompletionInfo"})+    IO ()++{- |+Update extra information shown in /@info@/ for /@proposal@/.++\<note>+  \<para>+    This function \<emphasis>must\<\/emphasis> be implemented when+    'GI.GtkSource.Interfaces.CompletionProvider.completionProviderGetInfoWidget' is implemented.+  \<\/para>+\<\/note>+-}+completionProviderUpdateInfo ::+    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a, GtkSource.CompletionProposal.IsCompletionProposal b, GtkSource.CompletionInfo.IsCompletionInfo c) =>+    a+    {- ^ /@provider@/: a 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'. -}+    -> b+    {- ^ /@proposal@/: a 'GI.GtkSource.Interfaces.CompletionProposal.CompletionProposal'. -}+    -> c+    {- ^ /@info@/: a 'GI.GtkSource.Objects.CompletionInfo.CompletionInfo'. -}+    -> m ()+completionProviderUpdateInfo provider proposal info = liftIO $ do+    provider' <- unsafeManagedPtrCastPtr provider+    proposal' <- unsafeManagedPtrCastPtr proposal+    info' <- unsafeManagedPtrCastPtr info+    gtk_source_completion_provider_update_info provider' proposal' info'+    touchManagedPtr provider+    touchManagedPtr proposal+    touchManagedPtr info+    return ()++#if ENABLE_OVERLOADING+data CompletionProviderUpdateInfoMethodInfo+instance (signature ~ (b -> c -> m ()), MonadIO m, IsCompletionProvider a, GtkSource.CompletionProposal.IsCompletionProposal b, GtkSource.CompletionInfo.IsCompletionInfo c) => O.MethodInfo CompletionProviderUpdateInfoMethodInfo a signature where+    overloadedMethod _ = completionProviderUpdateInfo++#endif++

@@ -0,0 +1,68 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.GtkSource.Interfaces.CompletionProvider 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++newtype CompletionProvider = CompletionProvider (ManagedPtr CompletionProvider)+instance GObject CompletionProvider where+class (GObject o, O.IsDescendantOf CompletionProvider o) => IsCompletionProvider o+instance (GObject o, O.IsDescendantOf CompletionProvider o) => IsCompletionProvider o+instance O.HasParentTypes CompletionProvider+#if ENABLE_OVERLOADING+data CompletionProviderActivateProposalMethodInfo+#endif+#if ENABLE_OVERLOADING+data CompletionProviderGetActivationMethodInfo+#endif+#if ENABLE_OVERLOADING+data CompletionProviderGetGiconMethodInfo+#endif+#if ENABLE_OVERLOADING+data CompletionProviderGetIconMethodInfo+#endif+#if ENABLE_OVERLOADING+data CompletionProviderGetIconNameMethodInfo+#endif+#if ENABLE_OVERLOADING+data CompletionProviderGetInfoWidgetMethodInfo+#endif+#if ENABLE_OVERLOADING+data CompletionProviderGetInteractiveDelayMethodInfo+#endif+#if ENABLE_OVERLOADING+data CompletionProviderGetNameMethodInfo+#endif+#if ENABLE_OVERLOADING+data CompletionProviderGetPriorityMethodInfo+#endif+#if ENABLE_OVERLOADING+data CompletionProviderGetStartIterMethodInfo+#endif+#if ENABLE_OVERLOADING+data CompletionProviderMatchMethodInfo+#endif+#if ENABLE_OVERLOADING+data CompletionProviderPopulateMethodInfo+#endif+#if ENABLE_OVERLOADING+data CompletionProviderUpdateInfoMethodInfo+#endif

@@ -0,0 +1,294 @@+++{- |+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.Interfaces.StyleSchemeChooser+    ( ++-- * Exported types+    StyleSchemeChooser(..)                  ,+    noStyleSchemeChooser                    ,+    IsStyleSchemeChooser                    ,+    toStyleSchemeChooser                    ,+++ -- * Methods+-- ** getStyleScheme #method:getStyleScheme#++#if ENABLE_OVERLOADING+    StyleSchemeChooserGetStyleSchemeMethodInfo,+#endif+    styleSchemeChooserGetStyleScheme        ,+++-- ** setStyleScheme #method:setStyleScheme#++#if ENABLE_OVERLOADING+    StyleSchemeChooserSetStyleSchemeMethodInfo,+#endif+    styleSchemeChooserSetStyleScheme        ,+++++ -- * Properties+-- ** styleScheme #attr:styleScheme#+{- | The :style-scheme property contains the currently selected style+scheme. The property can be set to change+the current selection programmatically.++/Since: 3.16/+-}+#if ENABLE_OVERLOADING+    StyleSchemeChooserStyleSchemePropertyInfo,+#endif+    constructStyleSchemeChooserStyleScheme  ,+    getStyleSchemeChooserStyleScheme        ,+    setStyleSchemeChooserStyleScheme        ,+#if ENABLE_OVERLOADING+    styleSchemeChooserStyleScheme           ,+#endif+++++    ) 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 {-# SOURCE #-} qualified GI.GtkSource.Objects.StyleScheme as GtkSource.StyleScheme++-- interface StyleSchemeChooser +-- | Memory-managed wrapper type.+newtype StyleSchemeChooser = StyleSchemeChooser (ManagedPtr StyleSchemeChooser)+-- | A convenience alias for `Nothing` :: `Maybe` `StyleSchemeChooser`.+noStyleSchemeChooser :: Maybe StyleSchemeChooser+noStyleSchemeChooser = Nothing++#if ENABLE_OVERLOADING+type instance O.SignalList StyleSchemeChooser = StyleSchemeChooserSignalList+type StyleSchemeChooserSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])++#endif++foreign import ccall "gtk_source_style_scheme_chooser_get_type"+    c_gtk_source_style_scheme_chooser_get_type :: IO GType++instance GObject StyleSchemeChooser where+    gobjectType = c_gtk_source_style_scheme_chooser_get_type+    ++-- | Type class for types which can be safely cast to `StyleSchemeChooser`, for instance with `toStyleSchemeChooser`.+class (GObject o, O.IsDescendantOf StyleSchemeChooser o) => IsStyleSchemeChooser o+instance (GObject o, O.IsDescendantOf StyleSchemeChooser o) => IsStyleSchemeChooser o++instance O.HasParentTypes StyleSchemeChooser+type instance O.ParentTypes StyleSchemeChooser = '[GObject.Object.Object]++-- | Cast to `StyleSchemeChooser`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toStyleSchemeChooser :: (MonadIO m, IsStyleSchemeChooser o) => o -> m StyleSchemeChooser+toStyleSchemeChooser = liftIO . unsafeCastTo StyleSchemeChooser++-- VVV Prop "style-scheme"+   -- Type: TInterface (Name {namespace = "GtkSource", name = "StyleScheme"})+   -- Flags: [PropertyReadable,PropertyWritable]+   -- Nullable: (Just False,Just False)++{- |+Get the value of the “@style-scheme@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' styleSchemeChooser #styleScheme+@+-}+getStyleSchemeChooserStyleScheme :: (MonadIO m, IsStyleSchemeChooser o) => o -> m GtkSource.StyleScheme.StyleScheme+getStyleSchemeChooserStyleScheme obj = liftIO $ checkUnexpectedNothing "getStyleSchemeChooserStyleScheme" $ B.Properties.getObjectPropertyObject obj "style-scheme" GtkSource.StyleScheme.StyleScheme++{- |+Set the value of the “@style-scheme@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' styleSchemeChooser [ #styleScheme 'Data.GI.Base.Attributes.:=' value ]+@+-}+setStyleSchemeChooserStyleScheme :: (MonadIO m, IsStyleSchemeChooser o, GtkSource.StyleScheme.IsStyleScheme a) => o -> a -> m ()+setStyleSchemeChooserStyleScheme 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`.+-}+constructStyleSchemeChooserStyleScheme :: (IsStyleSchemeChooser o, GtkSource.StyleScheme.IsStyleScheme a) => a -> IO (GValueConstruct o)+constructStyleSchemeChooserStyleScheme val = B.Properties.constructObjectPropertyObject "style-scheme" (Just val)++#if ENABLE_OVERLOADING+data StyleSchemeChooserStyleSchemePropertyInfo+instance AttrInfo StyleSchemeChooserStyleSchemePropertyInfo where+    type AttrAllowedOps StyleSchemeChooserStyleSchemePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint StyleSchemeChooserStyleSchemePropertyInfo = GtkSource.StyleScheme.IsStyleScheme+    type AttrBaseTypeConstraint StyleSchemeChooserStyleSchemePropertyInfo = IsStyleSchemeChooser+    type AttrGetType StyleSchemeChooserStyleSchemePropertyInfo = GtkSource.StyleScheme.StyleScheme+    type AttrLabel StyleSchemeChooserStyleSchemePropertyInfo = "style-scheme"+    type AttrOrigin StyleSchemeChooserStyleSchemePropertyInfo = StyleSchemeChooser+    attrGet _ = getStyleSchemeChooserStyleScheme+    attrSet _ = setStyleSchemeChooserStyleScheme+    attrConstruct _ = constructStyleSchemeChooserStyleScheme+    attrClear _ = undefined+#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList StyleSchemeChooser+type instance O.AttributeList StyleSchemeChooser = StyleSchemeChooserAttributeList+type StyleSchemeChooserAttributeList = ('[ '("styleScheme", StyleSchemeChooserStyleSchemePropertyInfo)] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+styleSchemeChooserStyleScheme :: AttrLabelProxy "styleScheme"+styleSchemeChooserStyleScheme = AttrLabelProxy++#endif++#if ENABLE_OVERLOADING+type family ResolveStyleSchemeChooserMethod (t :: Symbol) (o :: *) :: * where+    ResolveStyleSchemeChooserMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveStyleSchemeChooserMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveStyleSchemeChooserMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveStyleSchemeChooserMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveStyleSchemeChooserMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveStyleSchemeChooserMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveStyleSchemeChooserMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveStyleSchemeChooserMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveStyleSchemeChooserMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveStyleSchemeChooserMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveStyleSchemeChooserMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveStyleSchemeChooserMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveStyleSchemeChooserMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveStyleSchemeChooserMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveStyleSchemeChooserMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveStyleSchemeChooserMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveStyleSchemeChooserMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveStyleSchemeChooserMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveStyleSchemeChooserMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveStyleSchemeChooserMethod "getStyleScheme" o = StyleSchemeChooserGetStyleSchemeMethodInfo+    ResolveStyleSchemeChooserMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveStyleSchemeChooserMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveStyleSchemeChooserMethod "setStyleScheme" o = StyleSchemeChooserSetStyleSchemeMethodInfo+    ResolveStyleSchemeChooserMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveStyleSchemeChooserMethod t StyleSchemeChooser, O.MethodInfo info StyleSchemeChooser p) => OL.IsLabel t (StyleSchemeChooser -> 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++-- method StyleSchemeChooser::get_style_scheme+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "chooser", argType = TInterface (Name {namespace = "GtkSource", name = "StyleSchemeChooser"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceStyleSchemeChooser", 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_style_scheme_chooser_get_style_scheme" gtk_source_style_scheme_chooser_get_style_scheme :: +    Ptr StyleSchemeChooser ->               -- chooser : TInterface (Name {namespace = "GtkSource", name = "StyleSchemeChooser"})+    IO (Ptr GtkSource.StyleScheme.StyleScheme)++{- |+Gets the currently-selected scheme.++/Since: 3.16/+-}+styleSchemeChooserGetStyleScheme ::+    (B.CallStack.HasCallStack, MonadIO m, IsStyleSchemeChooser a) =>+    a+    {- ^ /@chooser@/: a 'GI.GtkSource.Interfaces.StyleSchemeChooser.StyleSchemeChooser' -}+    -> m GtkSource.StyleScheme.StyleScheme+    {- ^ __Returns:__ the currently-selected scheme. -}+styleSchemeChooserGetStyleScheme chooser = liftIO $ do+    chooser' <- unsafeManagedPtrCastPtr chooser+    result <- gtk_source_style_scheme_chooser_get_style_scheme chooser'+    checkUnexpectedReturnNULL "styleSchemeChooserGetStyleScheme" result+    result' <- (newObject GtkSource.StyleScheme.StyleScheme) result+    touchManagedPtr chooser+    return result'++#if ENABLE_OVERLOADING+data StyleSchemeChooserGetStyleSchemeMethodInfo+instance (signature ~ (m GtkSource.StyleScheme.StyleScheme), MonadIO m, IsStyleSchemeChooser a) => O.MethodInfo StyleSchemeChooserGetStyleSchemeMethodInfo a signature where+    overloadedMethod _ = styleSchemeChooserGetStyleScheme++#endif++-- method StyleSchemeChooser::set_style_scheme+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "chooser", argType = TInterface (Name {namespace = "GtkSource", name = "StyleSchemeChooser"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceStyleSchemeChooser", 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 = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceStyleScheme", 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_style_scheme_chooser_set_style_scheme" gtk_source_style_scheme_chooser_set_style_scheme :: +    Ptr StyleSchemeChooser ->               -- chooser : TInterface (Name {namespace = "GtkSource", name = "StyleSchemeChooser"})+    Ptr GtkSource.StyleScheme.StyleScheme -> -- scheme : TInterface (Name {namespace = "GtkSource", name = "StyleScheme"})+    IO ()++{- |+Sets the scheme.++/Since: 3.16/+-}+styleSchemeChooserSetStyleScheme ::+    (B.CallStack.HasCallStack, MonadIO m, IsStyleSchemeChooser a, GtkSource.StyleScheme.IsStyleScheme b) =>+    a+    {- ^ /@chooser@/: a 'GI.GtkSource.Interfaces.StyleSchemeChooser.StyleSchemeChooser' -}+    -> b+    {- ^ /@scheme@/: a 'GI.GtkSource.Objects.StyleScheme.StyleScheme' -}+    -> m ()+styleSchemeChooserSetStyleScheme chooser scheme = liftIO $ do+    chooser' <- unsafeManagedPtrCastPtr chooser+    scheme' <- unsafeManagedPtrCastPtr scheme+    gtk_source_style_scheme_chooser_set_style_scheme chooser' scheme'+    touchManagedPtr chooser+    touchManagedPtr scheme+    return ()++#if ENABLE_OVERLOADING+data StyleSchemeChooserSetStyleSchemeMethodInfo+instance (signature ~ (b -> m ()), MonadIO m, IsStyleSchemeChooser a, GtkSource.StyleScheme.IsStyleScheme b) => O.MethodInfo StyleSchemeChooserSetStyleSchemeMethodInfo a signature where+    overloadedMethod _ = styleSchemeChooserSetStyleScheme++#endif++

@@ -0,0 +1,38 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.GtkSource.Interfaces.StyleSchemeChooser 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++newtype StyleSchemeChooser = StyleSchemeChooser (ManagedPtr StyleSchemeChooser)+instance GObject StyleSchemeChooser where+class (GObject o, O.IsDescendantOf StyleSchemeChooser o) => IsStyleSchemeChooser o+instance (GObject o, O.IsDescendantOf StyleSchemeChooser o) => IsStyleSchemeChooser o+instance O.HasParentTypes StyleSchemeChooser+#if ENABLE_OVERLOADING+data StyleSchemeChooserStyleSchemePropertyInfo+#endif+#if ENABLE_OVERLOADING+data StyleSchemeChooserGetStyleSchemeMethodInfo+#endif+#if ENABLE_OVERLOADING+data StyleSchemeChooserSetStyleSchemeMethodInfo+#endif

@@ -0,0 +1,670 @@+++{- |+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.Interfaces.UndoManager+    ( ++-- * Exported types+    UndoManager(..)                         ,+    noUndoManager                           ,+    IsUndoManager                           ,+    toUndoManager                           ,+++ -- * Methods+-- ** beginNotUndoableAction #method:beginNotUndoableAction#++#if ENABLE_OVERLOADING+    UndoManagerBeginNotUndoableActionMethodInfo,+#endif+    undoManagerBeginNotUndoableAction       ,+++-- ** canRedo #method:canRedo#++#if ENABLE_OVERLOADING+    UndoManagerCanRedoMethodInfo            ,+#endif+    undoManagerCanRedo                      ,+++-- ** canRedoChanged #method:canRedoChanged#++#if ENABLE_OVERLOADING+    UndoManagerCanRedoChangedMethodInfo     ,+#endif+    undoManagerCanRedoChanged               ,+++-- ** canUndo #method:canUndo#++#if ENABLE_OVERLOADING+    UndoManagerCanUndoMethodInfo            ,+#endif+    undoManagerCanUndo                      ,+++-- ** canUndoChanged #method:canUndoChanged#++#if ENABLE_OVERLOADING+    UndoManagerCanUndoChangedMethodInfo     ,+#endif+    undoManagerCanUndoChanged               ,+++-- ** endNotUndoableAction #method:endNotUndoableAction#++#if ENABLE_OVERLOADING+    UndoManagerEndNotUndoableActionMethodInfo,+#endif+    undoManagerEndNotUndoableAction         ,+++-- ** redo #method:redo#++#if ENABLE_OVERLOADING+    UndoManagerRedoMethodInfo               ,+#endif+    undoManagerRedo                         ,+++-- ** undo #method:undo#++#if ENABLE_OVERLOADING+    UndoManagerUndoMethodInfo               ,+#endif+    undoManagerUndo                         ,+++++ -- * Signals+-- ** canRedoChanged #signal:canRedoChanged#++    C_UndoManagerCanRedoChangedCallback     ,+    UndoManagerCanRedoChangedCallback       ,+#if ENABLE_OVERLOADING+    UndoManagerCanRedoChangedSignalInfo     ,+#endif+    afterUndoManagerCanRedoChanged          ,+    genClosure_UndoManagerCanRedoChanged    ,+    mk_UndoManagerCanRedoChangedCallback    ,+    noUndoManagerCanRedoChangedCallback     ,+    onUndoManagerCanRedoChanged             ,+    wrap_UndoManagerCanRedoChangedCallback  ,+++-- ** canUndoChanged #signal:canUndoChanged#++    C_UndoManagerCanUndoChangedCallback     ,+    UndoManagerCanUndoChangedCallback       ,+#if ENABLE_OVERLOADING+    UndoManagerCanUndoChangedSignalInfo     ,+#endif+    afterUndoManagerCanUndoChanged          ,+    genClosure_UndoManagerCanUndoChanged    ,+    mk_UndoManagerCanUndoChangedCallback    ,+    noUndoManagerCanUndoChangedCallback     ,+    onUndoManagerCanUndoChanged             ,+    wrap_UndoManagerCanUndoChangedCallback  ,+++++    ) 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++-- interface UndoManager +-- | Memory-managed wrapper type.+newtype UndoManager = UndoManager (ManagedPtr UndoManager)+-- | A convenience alias for `Nothing` :: `Maybe` `UndoManager`.+noUndoManager :: Maybe UndoManager+noUndoManager = Nothing++-- signal UndoManager::can-redo-changed+{- |+Emitted when the ability to redo has changed.++/Since: 2.10/+-}+type UndoManagerCanRedoChangedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `UndoManagerCanRedoChangedCallback`@.+noUndoManagerCanRedoChangedCallback :: Maybe UndoManagerCanRedoChangedCallback+noUndoManagerCanRedoChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_UndoManagerCanRedoChangedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_UndoManagerCanRedoChangedCallback`.+foreign import ccall "wrapper"+    mk_UndoManagerCanRedoChangedCallback :: C_UndoManagerCanRedoChangedCallback -> IO (FunPtr C_UndoManagerCanRedoChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_UndoManagerCanRedoChanged :: MonadIO m => UndoManagerCanRedoChangedCallback -> m (GClosure C_UndoManagerCanRedoChangedCallback)+genClosure_UndoManagerCanRedoChanged cb = liftIO $ do+    let cb' = wrap_UndoManagerCanRedoChangedCallback cb+    mk_UndoManagerCanRedoChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `UndoManagerCanRedoChangedCallback` into a `C_UndoManagerCanRedoChangedCallback`.+wrap_UndoManagerCanRedoChangedCallback ::+    UndoManagerCanRedoChangedCallback ->+    C_UndoManagerCanRedoChangedCallback+wrap_UndoManagerCanRedoChangedCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@can-redo-changed@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' undoManager #canRedoChanged callback+@+-}+onUndoManagerCanRedoChanged :: (IsUndoManager a, MonadIO m) => a -> UndoManagerCanRedoChangedCallback -> m SignalHandlerId+onUndoManagerCanRedoChanged obj cb = liftIO $ do+    let cb' = wrap_UndoManagerCanRedoChangedCallback cb+    cb'' <- mk_UndoManagerCanRedoChangedCallback cb'+    connectSignalFunPtr obj "can-redo-changed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@can-redo-changed@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' undoManager #canRedoChanged callback+@+-}+afterUndoManagerCanRedoChanged :: (IsUndoManager a, MonadIO m) => a -> UndoManagerCanRedoChangedCallback -> m SignalHandlerId+afterUndoManagerCanRedoChanged obj cb = liftIO $ do+    let cb' = wrap_UndoManagerCanRedoChangedCallback cb+    cb'' <- mk_UndoManagerCanRedoChangedCallback cb'+    connectSignalFunPtr obj "can-redo-changed" cb'' SignalConnectAfter+++-- signal UndoManager::can-undo-changed+{- |+Emitted when the ability to undo has changed.++/Since: 2.10/+-}+type UndoManagerCanUndoChangedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `UndoManagerCanUndoChangedCallback`@.+noUndoManagerCanUndoChangedCallback :: Maybe UndoManagerCanUndoChangedCallback+noUndoManagerCanUndoChangedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_UndoManagerCanUndoChangedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_UndoManagerCanUndoChangedCallback`.+foreign import ccall "wrapper"+    mk_UndoManagerCanUndoChangedCallback :: C_UndoManagerCanUndoChangedCallback -> IO (FunPtr C_UndoManagerCanUndoChangedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_UndoManagerCanUndoChanged :: MonadIO m => UndoManagerCanUndoChangedCallback -> m (GClosure C_UndoManagerCanUndoChangedCallback)+genClosure_UndoManagerCanUndoChanged cb = liftIO $ do+    let cb' = wrap_UndoManagerCanUndoChangedCallback cb+    mk_UndoManagerCanUndoChangedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `UndoManagerCanUndoChangedCallback` into a `C_UndoManagerCanUndoChangedCallback`.+wrap_UndoManagerCanUndoChangedCallback ::+    UndoManagerCanUndoChangedCallback ->+    C_UndoManagerCanUndoChangedCallback+wrap_UndoManagerCanUndoChangedCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@can-undo-changed@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' undoManager #canUndoChanged callback+@+-}+onUndoManagerCanUndoChanged :: (IsUndoManager a, MonadIO m) => a -> UndoManagerCanUndoChangedCallback -> m SignalHandlerId+onUndoManagerCanUndoChanged obj cb = liftIO $ do+    let cb' = wrap_UndoManagerCanUndoChangedCallback cb+    cb'' <- mk_UndoManagerCanUndoChangedCallback cb'+    connectSignalFunPtr obj "can-undo-changed" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@can-undo-changed@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' undoManager #canUndoChanged callback+@+-}+afterUndoManagerCanUndoChanged :: (IsUndoManager a, MonadIO m) => a -> UndoManagerCanUndoChangedCallback -> m SignalHandlerId+afterUndoManagerCanUndoChanged obj cb = liftIO $ do+    let cb' = wrap_UndoManagerCanUndoChangedCallback cb+    cb'' <- mk_UndoManagerCanUndoChangedCallback cb'+    connectSignalFunPtr obj "can-undo-changed" cb'' SignalConnectAfter+++#if ENABLE_OVERLOADING+data UndoManagerCanRedoChangedSignalInfo+instance SignalInfo UndoManagerCanRedoChangedSignalInfo where+    type HaskellCallbackType UndoManagerCanRedoChangedSignalInfo = UndoManagerCanRedoChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_UndoManagerCanRedoChangedCallback cb+        cb'' <- mk_UndoManagerCanRedoChangedCallback cb'+        connectSignalFunPtr obj "can-redo-changed" cb'' connectMode++data UndoManagerCanUndoChangedSignalInfo+instance SignalInfo UndoManagerCanUndoChangedSignalInfo where+    type HaskellCallbackType UndoManagerCanUndoChangedSignalInfo = UndoManagerCanUndoChangedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_UndoManagerCanUndoChangedCallback cb+        cb'' <- mk_UndoManagerCanUndoChangedCallback cb'+        connectSignalFunPtr obj "can-undo-changed" cb'' connectMode++type instance O.SignalList UndoManager = UndoManagerSignalList+type UndoManagerSignalList = ('[ '("canRedoChanged", UndoManagerCanRedoChangedSignalInfo), '("canUndoChanged", UndoManagerCanUndoChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])++#endif++foreign import ccall "gtk_source_undo_manager_get_type"+    c_gtk_source_undo_manager_get_type :: IO GType++instance GObject UndoManager where+    gobjectType = c_gtk_source_undo_manager_get_type+    ++-- | Type class for types which can be safely cast to `UndoManager`, for instance with `toUndoManager`.+class (GObject o, O.IsDescendantOf UndoManager o) => IsUndoManager o+instance (GObject o, O.IsDescendantOf UndoManager o) => IsUndoManager o++instance O.HasParentTypes UndoManager+type instance O.ParentTypes UndoManager = '[GObject.Object.Object]++-- | Cast to `UndoManager`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toUndoManager :: (MonadIO m, IsUndoManager o) => o -> m UndoManager+toUndoManager = liftIO . unsafeCastTo UndoManager++#if ENABLE_OVERLOADING+instance O.HasAttributeList UndoManager+type instance O.AttributeList UndoManager = UndoManagerAttributeList+type UndoManagerAttributeList = ('[ ] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+#endif++#if ENABLE_OVERLOADING+type family ResolveUndoManagerMethod (t :: Symbol) (o :: *) :: * where+    ResolveUndoManagerMethod "beginNotUndoableAction" o = UndoManagerBeginNotUndoableActionMethodInfo+    ResolveUndoManagerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveUndoManagerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveUndoManagerMethod "canRedo" o = UndoManagerCanRedoMethodInfo+    ResolveUndoManagerMethod "canRedoChanged" o = UndoManagerCanRedoChangedMethodInfo+    ResolveUndoManagerMethod "canUndo" o = UndoManagerCanUndoMethodInfo+    ResolveUndoManagerMethod "canUndoChanged" o = UndoManagerCanUndoChangedMethodInfo+    ResolveUndoManagerMethod "endNotUndoableAction" o = UndoManagerEndNotUndoableActionMethodInfo+    ResolveUndoManagerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveUndoManagerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveUndoManagerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveUndoManagerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveUndoManagerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveUndoManagerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveUndoManagerMethod "redo" o = UndoManagerRedoMethodInfo+    ResolveUndoManagerMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveUndoManagerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveUndoManagerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveUndoManagerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveUndoManagerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveUndoManagerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveUndoManagerMethod "undo" o = UndoManagerUndoMethodInfo+    ResolveUndoManagerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveUndoManagerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveUndoManagerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveUndoManagerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveUndoManagerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveUndoManagerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveUndoManagerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveUndoManagerMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveUndoManagerMethod t UndoManager, O.MethodInfo info UndoManager p) => OL.IsLabel t (UndoManager -> 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++-- method UndoManager::begin_not_undoable_action+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "UndoManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceUndoManager.", 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_undo_manager_begin_not_undoable_action" gtk_source_undo_manager_begin_not_undoable_action :: +    Ptr UndoManager ->                      -- manager : TInterface (Name {namespace = "GtkSource", name = "UndoManager"})+    IO ()++{- |+Begin a not undoable action on the buffer. All changes between this call+and the call to 'GI.GtkSource.Interfaces.UndoManager.undoManagerEndNotUndoableAction' cannot+be undone. This function should be re-entrant.++/Since: 2.10/+-}+undoManagerBeginNotUndoableAction ::+    (B.CallStack.HasCallStack, MonadIO m, IsUndoManager a) =>+    a+    {- ^ /@manager@/: a 'GI.GtkSource.Interfaces.UndoManager.UndoManager'. -}+    -> m ()+undoManagerBeginNotUndoableAction manager = liftIO $ do+    manager' <- unsafeManagedPtrCastPtr manager+    gtk_source_undo_manager_begin_not_undoable_action manager'+    touchManagedPtr manager+    return ()++#if ENABLE_OVERLOADING+data UndoManagerBeginNotUndoableActionMethodInfo+instance (signature ~ (m ()), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerBeginNotUndoableActionMethodInfo a signature where+    overloadedMethod _ = undoManagerBeginNotUndoableAction++#endif++-- method UndoManager::can_redo+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "UndoManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceUndoManager.", 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_undo_manager_can_redo" gtk_source_undo_manager_can_redo :: +    Ptr UndoManager ->                      -- manager : TInterface (Name {namespace = "GtkSource", name = "UndoManager"})+    IO CInt++{- |+Get whether there are redo operations available.++/Since: 2.10/+-}+undoManagerCanRedo ::+    (B.CallStack.HasCallStack, MonadIO m, IsUndoManager a) =>+    a+    {- ^ /@manager@/: a 'GI.GtkSource.Interfaces.UndoManager.UndoManager'. -}+    -> m Bool+    {- ^ __Returns:__ 'True' if there are redo operations available, 'False' otherwise -}+undoManagerCanRedo manager = liftIO $ do+    manager' <- unsafeManagedPtrCastPtr manager+    result <- gtk_source_undo_manager_can_redo manager'+    let result' = (/= 0) result+    touchManagedPtr manager+    return result'++#if ENABLE_OVERLOADING+data UndoManagerCanRedoMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerCanRedoMethodInfo a signature where+    overloadedMethod _ = undoManagerCanRedo++#endif++-- method UndoManager::can_redo_changed+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "UndoManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceUndoManager.", 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_undo_manager_can_redo_changed" gtk_source_undo_manager_can_redo_changed :: +    Ptr UndoManager ->                      -- manager : TInterface (Name {namespace = "GtkSource", name = "UndoManager"})+    IO ()++{- |+Emits the 'GI.GtkSource.Interfaces.UndoManager.UndoManager'::@/can-redo-changed/@ signal.++/Since: 2.10/+-}+undoManagerCanRedoChanged ::+    (B.CallStack.HasCallStack, MonadIO m, IsUndoManager a) =>+    a+    {- ^ /@manager@/: a 'GI.GtkSource.Interfaces.UndoManager.UndoManager'. -}+    -> m ()+undoManagerCanRedoChanged manager = liftIO $ do+    manager' <- unsafeManagedPtrCastPtr manager+    gtk_source_undo_manager_can_redo_changed manager'+    touchManagedPtr manager+    return ()++#if ENABLE_OVERLOADING+data UndoManagerCanRedoChangedMethodInfo+instance (signature ~ (m ()), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerCanRedoChangedMethodInfo a signature where+    overloadedMethod _ = undoManagerCanRedoChanged++#endif++-- method UndoManager::can_undo+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "UndoManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceUndoManager.", 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_undo_manager_can_undo" gtk_source_undo_manager_can_undo :: +    Ptr UndoManager ->                      -- manager : TInterface (Name {namespace = "GtkSource", name = "UndoManager"})+    IO CInt++{- |+Get whether there are undo operations available.++/Since: 2.10/+-}+undoManagerCanUndo ::+    (B.CallStack.HasCallStack, MonadIO m, IsUndoManager a) =>+    a+    {- ^ /@manager@/: a 'GI.GtkSource.Interfaces.UndoManager.UndoManager'. -}+    -> m Bool+    {- ^ __Returns:__ 'True' if there are undo operations available, 'False' otherwise -}+undoManagerCanUndo manager = liftIO $ do+    manager' <- unsafeManagedPtrCastPtr manager+    result <- gtk_source_undo_manager_can_undo manager'+    let result' = (/= 0) result+    touchManagedPtr manager+    return result'++#if ENABLE_OVERLOADING+data UndoManagerCanUndoMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerCanUndoMethodInfo a signature where+    overloadedMethod _ = undoManagerCanUndo++#endif++-- method UndoManager::can_undo_changed+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "UndoManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceUndoManager.", 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_undo_manager_can_undo_changed" gtk_source_undo_manager_can_undo_changed :: +    Ptr UndoManager ->                      -- manager : TInterface (Name {namespace = "GtkSource", name = "UndoManager"})+    IO ()++{- |+Emits the 'GI.GtkSource.Interfaces.UndoManager.UndoManager'::@/can-undo-changed/@ signal.++/Since: 2.10/+-}+undoManagerCanUndoChanged ::+    (B.CallStack.HasCallStack, MonadIO m, IsUndoManager a) =>+    a+    {- ^ /@manager@/: a 'GI.GtkSource.Interfaces.UndoManager.UndoManager'. -}+    -> m ()+undoManagerCanUndoChanged manager = liftIO $ do+    manager' <- unsafeManagedPtrCastPtr manager+    gtk_source_undo_manager_can_undo_changed manager'+    touchManagedPtr manager+    return ()++#if ENABLE_OVERLOADING+data UndoManagerCanUndoChangedMethodInfo+instance (signature ~ (m ()), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerCanUndoChangedMethodInfo a signature where+    overloadedMethod _ = undoManagerCanUndoChanged++#endif++-- method UndoManager::end_not_undoable_action+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "UndoManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceUndoManager.", 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_undo_manager_end_not_undoable_action" gtk_source_undo_manager_end_not_undoable_action :: +    Ptr UndoManager ->                      -- manager : TInterface (Name {namespace = "GtkSource", name = "UndoManager"})+    IO ()++{- |+Ends a not undoable action on the buffer.++/Since: 2.10/+-}+undoManagerEndNotUndoableAction ::+    (B.CallStack.HasCallStack, MonadIO m, IsUndoManager a) =>+    a+    {- ^ /@manager@/: a 'GI.GtkSource.Interfaces.UndoManager.UndoManager'. -}+    -> m ()+undoManagerEndNotUndoableAction manager = liftIO $ do+    manager' <- unsafeManagedPtrCastPtr manager+    gtk_source_undo_manager_end_not_undoable_action manager'+    touchManagedPtr manager+    return ()++#if ENABLE_OVERLOADING+data UndoManagerEndNotUndoableActionMethodInfo+instance (signature ~ (m ()), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerEndNotUndoableActionMethodInfo a signature where+    overloadedMethod _ = undoManagerEndNotUndoableAction++#endif++-- method UndoManager::redo+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "UndoManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceUndoManager.", 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_undo_manager_redo" gtk_source_undo_manager_redo :: +    Ptr UndoManager ->                      -- manager : TInterface (Name {namespace = "GtkSource", name = "UndoManager"})+    IO ()++{- |+Perform a single redo. Calling this function when there are no redo operations+available is an error. Use 'GI.GtkSource.Interfaces.UndoManager.undoManagerCanRedo' to find out+if there are redo operations available.++/Since: 2.10/+-}+undoManagerRedo ::+    (B.CallStack.HasCallStack, MonadIO m, IsUndoManager a) =>+    a+    {- ^ /@manager@/: a 'GI.GtkSource.Interfaces.UndoManager.UndoManager'. -}+    -> m ()+undoManagerRedo manager = liftIO $ do+    manager' <- unsafeManagedPtrCastPtr manager+    gtk_source_undo_manager_redo manager'+    touchManagedPtr manager+    return ()++#if ENABLE_OVERLOADING+data UndoManagerRedoMethodInfo+instance (signature ~ (m ()), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerRedoMethodInfo a signature where+    overloadedMethod _ = undoManagerRedo++#endif++-- method UndoManager::undo+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "UndoManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceUndoManager.", 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_undo_manager_undo" gtk_source_undo_manager_undo :: +    Ptr UndoManager ->                      -- manager : TInterface (Name {namespace = "GtkSource", name = "UndoManager"})+    IO ()++{- |+Perform a single undo. Calling this function when there are no undo operations+available is an error. Use 'GI.GtkSource.Interfaces.UndoManager.undoManagerCanUndo' to find out+if there are undo operations available.++/Since: 2.10/+-}+undoManagerUndo ::+    (B.CallStack.HasCallStack, MonadIO m, IsUndoManager a) =>+    a+    {- ^ /@manager@/: a 'GI.GtkSource.Interfaces.UndoManager.UndoManager'. -}+    -> m ()+undoManagerUndo manager = liftIO $ do+    manager' <- unsafeManagedPtrCastPtr manager+    gtk_source_undo_manager_undo manager'+    touchManagedPtr manager+    return ()++#if ENABLE_OVERLOADING+data UndoManagerUndoMethodInfo+instance (signature ~ (m ()), MonadIO m, IsUndoManager a) => O.MethodInfo UndoManagerUndoMethodInfo a signature where+    overloadedMethod _ = undoManagerUndo++#endif++

@@ -0,0 +1,59 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.GtkSource.Interfaces.UndoManager 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++newtype UndoManager = UndoManager (ManagedPtr UndoManager)+#if ENABLE_OVERLOADING+data UndoManagerCanRedoChangedSignalInfo+#endif+#if ENABLE_OVERLOADING+data UndoManagerCanUndoChangedSignalInfo+#endif+instance GObject UndoManager where+class (GObject o, O.IsDescendantOf UndoManager o) => IsUndoManager o+instance (GObject o, O.IsDescendantOf UndoManager o) => IsUndoManager o+instance O.HasParentTypes UndoManager+#if ENABLE_OVERLOADING+data UndoManagerBeginNotUndoableActionMethodInfo+#endif+#if ENABLE_OVERLOADING+data UndoManagerCanRedoMethodInfo+#endif+#if ENABLE_OVERLOADING+data UndoManagerCanRedoChangedMethodInfo+#endif+#if ENABLE_OVERLOADING+data UndoManagerCanUndoMethodInfo+#endif+#if ENABLE_OVERLOADING+data UndoManagerCanUndoChangedMethodInfo+#endif+#if ENABLE_OVERLOADING+data UndoManagerEndNotUndoableActionMethodInfo+#endif+#if ENABLE_OVERLOADING+data UndoManagerRedoMethodInfo+#endif+#if ENABLE_OVERLOADING+data UndoManagerUndoMethodInfo+#endif

@@ -0,0 +1,99 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.GtkSource.Objects+    (     module GI.GtkSource.Objects.Buffer      ,+    module GI.GtkSource.Objects.Completion  ,+    module GI.GtkSource.Objects.CompletionContext,+    module GI.GtkSource.Objects.CompletionInfo,+    module GI.GtkSource.Objects.CompletionItem,+    module GI.GtkSource.Objects.CompletionWords,+    module GI.GtkSource.Objects.File        ,+    module GI.GtkSource.Objects.FileLoader  ,+    module GI.GtkSource.Objects.FileSaver   ,+    module GI.GtkSource.Objects.Gutter      ,+    module GI.GtkSource.Objects.GutterRenderer,+    module GI.GtkSource.Objects.GutterRendererPixbuf,+    module GI.GtkSource.Objects.GutterRendererText,+    module GI.GtkSource.Objects.Language    ,+    module GI.GtkSource.Objects.LanguageManager,+    module GI.GtkSource.Objects.Map         ,+    module GI.GtkSource.Objects.Mark        ,+    module GI.GtkSource.Objects.MarkAttributes,+    module GI.GtkSource.Objects.PrintCompositor,+    module GI.GtkSource.Objects.Region      ,+    module GI.GtkSource.Objects.SearchContext,+    module GI.GtkSource.Objects.SearchSettings,+    module GI.GtkSource.Objects.SpaceDrawer ,+    module GI.GtkSource.Objects.Style       ,+    module GI.GtkSource.Objects.StyleScheme ,+    module GI.GtkSource.Objects.StyleSchemeChooserButton,+    module GI.GtkSource.Objects.StyleSchemeChooserWidget,+    module GI.GtkSource.Objects.StyleSchemeManager,+    module GI.GtkSource.Objects.Tag         ,+    module GI.GtkSource.Objects.View        ,+++    ) where++import GI.GtkSource.Objects.Buffer+import GI.GtkSource.Objects.Completion+import GI.GtkSource.Objects.CompletionContext+import GI.GtkSource.Objects.CompletionInfo+import GI.GtkSource.Objects.CompletionItem+import GI.GtkSource.Objects.CompletionWords+import GI.GtkSource.Objects.File+import GI.GtkSource.Objects.FileLoader+import GI.GtkSource.Objects.FileSaver+import GI.GtkSource.Objects.Gutter+import GI.GtkSource.Objects.GutterRenderer+import GI.GtkSource.Objects.GutterRendererPixbuf+import GI.GtkSource.Objects.GutterRendererText+import GI.GtkSource.Objects.Language+import GI.GtkSource.Objects.LanguageManager+import GI.GtkSource.Objects.Map+import GI.GtkSource.Objects.Mark+import GI.GtkSource.Objects.MarkAttributes+import GI.GtkSource.Objects.PrintCompositor+import GI.GtkSource.Objects.Region+import GI.GtkSource.Objects.SearchContext+import GI.GtkSource.Objects.SearchSettings+import GI.GtkSource.Objects.SpaceDrawer+import GI.GtkSource.Objects.Style+import GI.GtkSource.Objects.StyleScheme+import GI.GtkSource.Objects.StyleSchemeChooserButton+import GI.GtkSource.Objects.StyleSchemeChooserWidget+import GI.GtkSource.Objects.StyleSchemeManager+import GI.GtkSource.Objects.Tag+import GI.GtkSource.Objects.View++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+++

@@ -0,0 +1,3199 @@+++{- |+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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' buffer #bracketMatched callback+@+-}+onBufferBracketMatched :: (IsBuffer a, MonadIO m) => a -> BufferBracketMatchedCallback -> m SignalHandlerId+onBufferBracketMatched 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' buffer #bracketMatched callback+@+-}+afterBufferBracketMatched :: (IsBuffer a, MonadIO m) => a -> BufferBracketMatchedCallback -> m SignalHandlerId+afterBufferBracketMatched 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' buffer #highlightUpdated callback+@+-}+onBufferHighlightUpdated :: (IsBuffer a, MonadIO m) => a -> BufferHighlightUpdatedCallback -> m SignalHandlerId+onBufferHighlightUpdated 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' buffer #highlightUpdated callback+@+-}+afterBufferHighlightUpdated :: (IsBuffer a, MonadIO m) => a -> BufferHighlightUpdatedCallback -> m SignalHandlerId+afterBufferHighlightUpdated 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' buffer #redo callback+@+-}+onBufferRedo :: (IsBuffer a, MonadIO m) => a -> BufferRedoCallback -> m SignalHandlerId+onBufferRedo 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' buffer #redo callback+@+-}+afterBufferRedo :: (IsBuffer a, MonadIO m) => a -> BufferRedoCallback -> m SignalHandlerId+afterBufferRedo 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' buffer #sourceMarkUpdated callback+@+-}+onBufferSourceMarkUpdated :: (IsBuffer a, MonadIO m) => a -> BufferSourceMarkUpdatedCallback -> m SignalHandlerId+onBufferSourceMarkUpdated 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' buffer #sourceMarkUpdated callback+@+-}+afterBufferSourceMarkUpdated :: (IsBuffer a, MonadIO m) => a -> BufferSourceMarkUpdatedCallback -> m SignalHandlerId+afterBufferSourceMarkUpdated 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' buffer #undo callback+@+-}+onBufferUndo :: (IsBuffer a, MonadIO m) => a -> BufferUndoCallback -> m SignalHandlerId+onBufferUndo 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' buffer #undo callback+@+-}+afterBufferUndo :: (IsBuffer a, MonadIO m) => a -> BufferUndoCallback -> m SignalHandlerId+afterBufferUndo 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' buffer #canRedo+@+-}+getBufferCanRedo :: (MonadIO m, IsBuffer o) => o -> m Bool+getBufferCanRedo 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' buffer #canUndo+@+-}+getBufferCanUndo :: (MonadIO m, IsBuffer o) => o -> m Bool+getBufferCanUndo 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' buffer #highlightMatchingBrackets+@+-}+getBufferHighlightMatchingBrackets :: (MonadIO m, IsBuffer o) => o -> m Bool+getBufferHighlightMatchingBrackets obj = liftIO $ B.Properties.getObjectPropertyBool obj "highlight-matching-brackets"++{- |+Set the value of the “@highlight-matching-brackets@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' buffer [ #highlightMatchingBrackets 'Data.GI.Base.Attributes.:=' value ]+@+-}+setBufferHighlightMatchingBrackets :: (MonadIO m, IsBuffer o) => o -> Bool -> m ()+setBufferHighlightMatchingBrackets 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' buffer #highlightSyntax+@+-}+getBufferHighlightSyntax :: (MonadIO m, IsBuffer o) => o -> m Bool+getBufferHighlightSyntax obj = liftIO $ B.Properties.getObjectPropertyBool obj "highlight-syntax"++{- |+Set the value of the “@highlight-syntax@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' buffer [ #highlightSyntax 'Data.GI.Base.Attributes.:=' value ]+@+-}+setBufferHighlightSyntax :: (MonadIO m, IsBuffer o) => o -> Bool -> m ()+setBufferHighlightSyntax 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' buffer #implicitTrailingNewline+@+-}+getBufferImplicitTrailingNewline :: (MonadIO m, IsBuffer o) => o -> m Bool+getBufferImplicitTrailingNewline obj = liftIO $ B.Properties.getObjectPropertyBool obj "implicit-trailing-newline"++{- |+Set the value of the “@implicit-trailing-newline@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' buffer [ #implicitTrailingNewline 'Data.GI.Base.Attributes.:=' value ]+@+-}+setBufferImplicitTrailingNewline :: (MonadIO m, IsBuffer o) => o -> Bool -> m ()+setBufferImplicitTrailingNewline 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' buffer #language+@+-}+getBufferLanguage :: (MonadIO m, IsBuffer o) => o -> m (Maybe GtkSource.Language.Language)+getBufferLanguage obj = liftIO $ B.Properties.getObjectPropertyObject obj "language" GtkSource.Language.Language++{- |+Set the value of the “@language@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' buffer [ #language 'Data.GI.Base.Attributes.:=' value ]+@+-}+setBufferLanguage :: (MonadIO m, IsBuffer o, GtkSource.Language.IsLanguage a) => o -> a -> m ()+setBufferLanguage 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.clear' #language+@+-}+clearBufferLanguage :: (MonadIO m, IsBuffer o) => o -> m ()+clearBufferLanguage 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' buffer #maxUndoLevels+@+-}+getBufferMaxUndoLevels :: (MonadIO m, IsBuffer o) => o -> m Int32+getBufferMaxUndoLevels obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "max-undo-levels"++{- |+Set the value of the “@max-undo-levels@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' buffer [ #maxUndoLevels 'Data.GI.Base.Attributes.:=' value ]+@+-}+setBufferMaxUndoLevels :: (MonadIO m, IsBuffer o) => o -> Int32 -> m ()+setBufferMaxUndoLevels 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' buffer #styleScheme+@+-}+getBufferStyleScheme :: (MonadIO m, IsBuffer o) => o -> m (Maybe GtkSource.StyleScheme.StyleScheme)+getBufferStyleScheme obj = liftIO $ B.Properties.getObjectPropertyObject obj "style-scheme" GtkSource.StyleScheme.StyleScheme++{- |+Set the value of the “@style-scheme@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' buffer [ #styleScheme 'Data.GI.Base.Attributes.:=' value ]+@+-}+setBufferStyleScheme :: (MonadIO m, IsBuffer o, GtkSource.StyleScheme.IsStyleScheme a) => o -> a -> m ()+setBufferStyleScheme 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.clear' #styleScheme+@+-}+clearBufferStyleScheme :: (MonadIO m, IsBuffer o) => o -> m ()+clearBufferStyleScheme 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' buffer #undoManager+@+-}+getBufferUndoManager :: (MonadIO m, IsBuffer o) => o -> m (Maybe GtkSource.UndoManager.UndoManager)+getBufferUndoManager obj = liftIO $ B.Properties.getObjectPropertyObject obj "undo-manager" GtkSource.UndoManager.UndoManager++{- |+Set the value of the “@undo-manager@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.set' buffer [ #undoManager 'Data.GI.Base.Attributes.:=' value ]+@+-}+setBufferUndoManager :: (MonadIO m, IsBuffer o, GtkSource.UndoManager.IsUndoManager a) => o -> a -> m ()+setBufferUndoManager 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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.clear' #undoManager+@+-}+clearBufferUndoManager :: (MonadIO m, IsBuffer o) => o -> m ()+clearBufferUndoManager 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.++\<note>+  \<para>+    This is a potentially slow operation and should be used only+    when you need to make sure that some text not currently+    visible is highlighted, for instance before printing.+  \<\/para>+\<\/note>+-}+bufferEnsureHighlight ::+    (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) =>+    a+    {- ^ /@buffer@/: a '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++