diff --git a/ChangeLog.md b/ChangeLog.md --- a/ChangeLog.md +++ b/ChangeLog.md @@ -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). diff --git a/GI/GtkSource.hs b/GI/GtkSource.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource.hs @@ -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 + diff --git a/GI/GtkSource/Enums.hs b/GI/GtkSource/Enums.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Enums.hs @@ -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 + + diff --git a/GI/GtkSource/Enums.hs-boot b/GI/GtkSource/Enums.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Enums.hs-boot @@ -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 diff --git a/GI/GtkSource/Flags.hs b/GI/GtkSource/Flags.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Flags.hs @@ -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 + \\Control\<\/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 + + diff --git a/GI/GtkSource/Flags.hs-boot b/GI/GtkSource/Flags.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Flags.hs-boot @@ -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 diff --git a/GI/GtkSource/Functions.hs b/GI/GtkSource/Functions.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Functions.hs @@ -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: 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' + + + diff --git a/GI/GtkSource/Interfaces.hs b/GI/GtkSource/Interfaces.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Interfaces.hs @@ -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 + + + diff --git a/GI/GtkSource/Interfaces/CompletionProposal.hs b/GI/GtkSource/Interfaces/CompletionProposal.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Interfaces/CompletionProposal.hs @@ -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 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 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 + + diff --git a/GI/GtkSource/Interfaces/CompletionProposal.hs-boot b/GI/GtkSource/Interfaces/CompletionProposal.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Interfaces/CompletionProposal.hs-boot @@ -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 diff --git a/GI/GtkSource/Interfaces/CompletionProvider.hs b/GI/GtkSource/Interfaces/CompletionProvider.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Interfaces/CompletionProvider.hs @@ -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'. + +\ + \ + If implemented, 'GI.GtkSource.Interfaces.CompletionProvider.completionProviderUpdateInfo' + \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@/. + +\ + \ + This function \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 + + diff --git a/GI/GtkSource/Interfaces/CompletionProvider.hs-boot b/GI/GtkSource/Interfaces/CompletionProvider.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Interfaces/CompletionProvider.hs-boot @@ -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 diff --git a/GI/GtkSource/Interfaces/StyleSchemeChooser.hs b/GI/GtkSource/Interfaces/StyleSchemeChooser.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Interfaces/StyleSchemeChooser.hs @@ -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 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 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 + + diff --git a/GI/GtkSource/Interfaces/StyleSchemeChooser.hs-boot b/GI/GtkSource/Interfaces/StyleSchemeChooser.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Interfaces/StyleSchemeChooser.hs-boot @@ -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 diff --git a/GI/GtkSource/Interfaces/UndoManager.hs b/GI/GtkSource/Interfaces/UndoManager.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Interfaces/UndoManager.hs @@ -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 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 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 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 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 + + diff --git a/GI/GtkSource/Interfaces/UndoManager.hs-boot b/GI/GtkSource/Interfaces/UndoManager.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Interfaces/UndoManager.hs-boot @@ -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 diff --git a/GI/GtkSource/Objects.hs b/GI/GtkSource/Objects.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects.hs @@ -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 + + + diff --git a/GI/GtkSource/Objects/Buffer.hs b/GI/GtkSource/Objects/Buffer.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/Buffer.hs @@ -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 is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' buffer #bracketMatched callback +@ +-} +onBufferBracketMatched :: (IsBuffer a, MonadIO m) => a -> BufferBracketMatchedCallback -> m SignalHandlerId +onBufferBracketMatched obj cb = liftIO $ do + let cb' = wrap_BufferBracketMatchedCallback cb + cb'' <- mk_BufferBracketMatchedCallback cb' + connectSignalFunPtr obj "bracket-matched" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@bracket-matched@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' buffer #bracketMatched callback +@ +-} +afterBufferBracketMatched :: (IsBuffer a, MonadIO m) => a -> BufferBracketMatchedCallback -> m SignalHandlerId +afterBufferBracketMatched obj cb = liftIO $ do + let cb' = wrap_BufferBracketMatchedCallback cb + cb'' <- mk_BufferBracketMatchedCallback cb' + connectSignalFunPtr obj "bracket-matched" cb'' SignalConnectAfter + + +-- signal Buffer::highlight-updated +{- | +The ::highlight-updated signal is emitted when the syntax +highlighting and [context classes][context-classes] are updated in a +certain region of the /@buffer@/. +-} +type BufferHighlightUpdatedCallback = + Gtk.TextIter.TextIter + {- ^ /@start@/: the start of the updated region -} + -> Gtk.TextIter.TextIter + {- ^ /@end@/: the end of the updated region -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `BufferHighlightUpdatedCallback`@. +noBufferHighlightUpdatedCallback :: Maybe BufferHighlightUpdatedCallback +noBufferHighlightUpdatedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_BufferHighlightUpdatedCallback = + Ptr () -> -- object + Ptr Gtk.TextIter.TextIter -> + Ptr Gtk.TextIter.TextIter -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_BufferHighlightUpdatedCallback`. +foreign import ccall "wrapper" + mk_BufferHighlightUpdatedCallback :: C_BufferHighlightUpdatedCallback -> IO (FunPtr C_BufferHighlightUpdatedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_BufferHighlightUpdated :: MonadIO m => BufferHighlightUpdatedCallback -> m (GClosure C_BufferHighlightUpdatedCallback) +genClosure_BufferHighlightUpdated cb = liftIO $ do + let cb' = wrap_BufferHighlightUpdatedCallback cb + mk_BufferHighlightUpdatedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `BufferHighlightUpdatedCallback` into a `C_BufferHighlightUpdatedCallback`. +wrap_BufferHighlightUpdatedCallback :: + BufferHighlightUpdatedCallback -> + C_BufferHighlightUpdatedCallback +wrap_BufferHighlightUpdatedCallback _cb _ start end _ = do + B.ManagedPtr.withTransient Gtk.TextIter.TextIter start $ \start' -> do + B.ManagedPtr.withTransient Gtk.TextIter.TextIter end $ \end' -> do + _cb start' end' + + +{- | +Connect a signal handler for the “@highlight-updated@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' buffer #highlightUpdated callback +@ +-} +onBufferHighlightUpdated :: (IsBuffer a, MonadIO m) => a -> BufferHighlightUpdatedCallback -> m SignalHandlerId +onBufferHighlightUpdated obj cb = liftIO $ do + let cb' = wrap_BufferHighlightUpdatedCallback cb + cb'' <- mk_BufferHighlightUpdatedCallback cb' + connectSignalFunPtr obj "highlight-updated" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@highlight-updated@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' buffer #highlightUpdated callback +@ +-} +afterBufferHighlightUpdated :: (IsBuffer a, MonadIO m) => a -> BufferHighlightUpdatedCallback -> m SignalHandlerId +afterBufferHighlightUpdated obj cb = liftIO $ do + let cb' = wrap_BufferHighlightUpdatedCallback cb + cb'' <- mk_BufferHighlightUpdatedCallback cb' + connectSignalFunPtr obj "highlight-updated" cb'' SignalConnectAfter + + +-- signal Buffer::redo +{- | +The ::redo signal is emitted to redo the last undo operation. +-} +type BufferRedoCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `BufferRedoCallback`@. +noBufferRedoCallback :: Maybe BufferRedoCallback +noBufferRedoCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_BufferRedoCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_BufferRedoCallback`. +foreign import ccall "wrapper" + mk_BufferRedoCallback :: C_BufferRedoCallback -> IO (FunPtr C_BufferRedoCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_BufferRedo :: MonadIO m => BufferRedoCallback -> m (GClosure C_BufferRedoCallback) +genClosure_BufferRedo cb = liftIO $ do + let cb' = wrap_BufferRedoCallback cb + mk_BufferRedoCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `BufferRedoCallback` into a `C_BufferRedoCallback`. +wrap_BufferRedoCallback :: + BufferRedoCallback -> + C_BufferRedoCallback +wrap_BufferRedoCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@redo@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' buffer #redo callback +@ +-} +onBufferRedo :: (IsBuffer a, MonadIO m) => a -> BufferRedoCallback -> m SignalHandlerId +onBufferRedo obj cb = liftIO $ do + let cb' = wrap_BufferRedoCallback cb + cb'' <- mk_BufferRedoCallback cb' + connectSignalFunPtr obj "redo" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@redo@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' buffer #redo callback +@ +-} +afterBufferRedo :: (IsBuffer a, MonadIO m) => a -> BufferRedoCallback -> m SignalHandlerId +afterBufferRedo obj cb = liftIO $ do + let cb' = wrap_BufferRedoCallback cb + cb'' <- mk_BufferRedoCallback cb' + connectSignalFunPtr obj "redo" cb'' SignalConnectAfter + + +-- signal Buffer::source-mark-updated +{- | +The ::source-mark-updated signal is emitted each time +a mark is added to, moved or removed from the /@buffer@/. +-} +type BufferSourceMarkUpdatedCallback = + Gtk.TextMark.TextMark + {- ^ /@mark@/: the 'GI.GtkSource.Objects.Mark.Mark' -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `BufferSourceMarkUpdatedCallback`@. +noBufferSourceMarkUpdatedCallback :: Maybe BufferSourceMarkUpdatedCallback +noBufferSourceMarkUpdatedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_BufferSourceMarkUpdatedCallback = + Ptr () -> -- object + Ptr Gtk.TextMark.TextMark -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_BufferSourceMarkUpdatedCallback`. +foreign import ccall "wrapper" + mk_BufferSourceMarkUpdatedCallback :: C_BufferSourceMarkUpdatedCallback -> IO (FunPtr C_BufferSourceMarkUpdatedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_BufferSourceMarkUpdated :: MonadIO m => BufferSourceMarkUpdatedCallback -> m (GClosure C_BufferSourceMarkUpdatedCallback) +genClosure_BufferSourceMarkUpdated cb = liftIO $ do + let cb' = wrap_BufferSourceMarkUpdatedCallback cb + mk_BufferSourceMarkUpdatedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `BufferSourceMarkUpdatedCallback` into a `C_BufferSourceMarkUpdatedCallback`. +wrap_BufferSourceMarkUpdatedCallback :: + BufferSourceMarkUpdatedCallback -> + C_BufferSourceMarkUpdatedCallback +wrap_BufferSourceMarkUpdatedCallback _cb _ mark _ = do + mark' <- (newObject Gtk.TextMark.TextMark) mark + _cb mark' + + +{- | +Connect a signal handler for the “@source-mark-updated@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' buffer #sourceMarkUpdated callback +@ +-} +onBufferSourceMarkUpdated :: (IsBuffer a, MonadIO m) => a -> BufferSourceMarkUpdatedCallback -> m SignalHandlerId +onBufferSourceMarkUpdated obj cb = liftIO $ do + let cb' = wrap_BufferSourceMarkUpdatedCallback cb + cb'' <- mk_BufferSourceMarkUpdatedCallback cb' + connectSignalFunPtr obj "source-mark-updated" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@source-mark-updated@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' buffer #sourceMarkUpdated callback +@ +-} +afterBufferSourceMarkUpdated :: (IsBuffer a, MonadIO m) => a -> BufferSourceMarkUpdatedCallback -> m SignalHandlerId +afterBufferSourceMarkUpdated obj cb = liftIO $ do + let cb' = wrap_BufferSourceMarkUpdatedCallback cb + cb'' <- mk_BufferSourceMarkUpdatedCallback cb' + connectSignalFunPtr obj "source-mark-updated" cb'' SignalConnectAfter + + +-- signal Buffer::undo +{- | +The ::undo signal is emitted to undo the last user action which +modified the buffer. +-} +type BufferUndoCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `BufferUndoCallback`@. +noBufferUndoCallback :: Maybe BufferUndoCallback +noBufferUndoCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_BufferUndoCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_BufferUndoCallback`. +foreign import ccall "wrapper" + mk_BufferUndoCallback :: C_BufferUndoCallback -> IO (FunPtr C_BufferUndoCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_BufferUndo :: MonadIO m => BufferUndoCallback -> m (GClosure C_BufferUndoCallback) +genClosure_BufferUndo cb = liftIO $ do + let cb' = wrap_BufferUndoCallback cb + mk_BufferUndoCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `BufferUndoCallback` into a `C_BufferUndoCallback`. +wrap_BufferUndoCallback :: + BufferUndoCallback -> + C_BufferUndoCallback +wrap_BufferUndoCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@undo@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' buffer #undo callback +@ +-} +onBufferUndo :: (IsBuffer a, MonadIO m) => a -> BufferUndoCallback -> m SignalHandlerId +onBufferUndo obj cb = liftIO $ do + let cb' = wrap_BufferUndoCallback cb + cb'' <- mk_BufferUndoCallback cb' + connectSignalFunPtr obj "undo" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@undo@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' buffer #undo callback +@ +-} +afterBufferUndo :: (IsBuffer a, MonadIO m) => a -> BufferUndoCallback -> m SignalHandlerId +afterBufferUndo obj cb = liftIO $ do + let cb' = wrap_BufferUndoCallback cb + cb'' <- mk_BufferUndoCallback cb' + connectSignalFunPtr obj "undo" cb'' SignalConnectAfter + + +-- VVV Prop "can-redo" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@can-redo@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' buffer #canRedo +@ +-} +getBufferCanRedo :: (MonadIO m, IsBuffer o) => o -> m Bool +getBufferCanRedo obj = liftIO $ B.Properties.getObjectPropertyBool obj "can-redo" + +#if ENABLE_OVERLOADING +data BufferCanRedoPropertyInfo +instance AttrInfo BufferCanRedoPropertyInfo where + type AttrAllowedOps BufferCanRedoPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint BufferCanRedoPropertyInfo = (~) () + type AttrBaseTypeConstraint BufferCanRedoPropertyInfo = IsBuffer + type AttrGetType BufferCanRedoPropertyInfo = Bool + type AttrLabel BufferCanRedoPropertyInfo = "can-redo" + type AttrOrigin BufferCanRedoPropertyInfo = Buffer + attrGet _ = getBufferCanRedo + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "can-undo" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@can-undo@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' buffer #canUndo +@ +-} +getBufferCanUndo :: (MonadIO m, IsBuffer o) => o -> m Bool +getBufferCanUndo obj = liftIO $ B.Properties.getObjectPropertyBool obj "can-undo" + +#if ENABLE_OVERLOADING +data BufferCanUndoPropertyInfo +instance AttrInfo BufferCanUndoPropertyInfo where + type AttrAllowedOps BufferCanUndoPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint BufferCanUndoPropertyInfo = (~) () + type AttrBaseTypeConstraint BufferCanUndoPropertyInfo = IsBuffer + type AttrGetType BufferCanUndoPropertyInfo = Bool + type AttrLabel BufferCanUndoPropertyInfo = "can-undo" + type AttrOrigin BufferCanUndoPropertyInfo = Buffer + attrGet _ = getBufferCanUndo + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "highlight-matching-brackets" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@highlight-matching-brackets@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' buffer #highlightMatchingBrackets +@ +-} +getBufferHighlightMatchingBrackets :: (MonadIO m, IsBuffer o) => o -> m Bool +getBufferHighlightMatchingBrackets obj = liftIO $ B.Properties.getObjectPropertyBool obj "highlight-matching-brackets" + +{- | +Set the value of the “@highlight-matching-brackets@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' buffer [ #highlightMatchingBrackets 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setBufferHighlightMatchingBrackets :: (MonadIO m, IsBuffer o) => o -> Bool -> m () +setBufferHighlightMatchingBrackets obj val = liftIO $ B.Properties.setObjectPropertyBool obj "highlight-matching-brackets" val + +{- | +Construct a `GValueConstruct` with valid value for the “@highlight-matching-brackets@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructBufferHighlightMatchingBrackets :: (IsBuffer o) => Bool -> IO (GValueConstruct o) +constructBufferHighlightMatchingBrackets val = B.Properties.constructObjectPropertyBool "highlight-matching-brackets" val + +#if ENABLE_OVERLOADING +data BufferHighlightMatchingBracketsPropertyInfo +instance AttrInfo BufferHighlightMatchingBracketsPropertyInfo where + type AttrAllowedOps BufferHighlightMatchingBracketsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint BufferHighlightMatchingBracketsPropertyInfo = (~) Bool + type AttrBaseTypeConstraint BufferHighlightMatchingBracketsPropertyInfo = IsBuffer + type AttrGetType BufferHighlightMatchingBracketsPropertyInfo = Bool + type AttrLabel BufferHighlightMatchingBracketsPropertyInfo = "highlight-matching-brackets" + type AttrOrigin BufferHighlightMatchingBracketsPropertyInfo = Buffer + attrGet _ = getBufferHighlightMatchingBrackets + attrSet _ = setBufferHighlightMatchingBrackets + attrConstruct _ = constructBufferHighlightMatchingBrackets + attrClear _ = undefined +#endif + +-- VVV Prop "highlight-syntax" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@highlight-syntax@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' buffer #highlightSyntax +@ +-} +getBufferHighlightSyntax :: (MonadIO m, IsBuffer o) => o -> m Bool +getBufferHighlightSyntax obj = liftIO $ B.Properties.getObjectPropertyBool obj "highlight-syntax" + +{- | +Set the value of the “@highlight-syntax@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' buffer [ #highlightSyntax 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setBufferHighlightSyntax :: (MonadIO m, IsBuffer o) => o -> Bool -> m () +setBufferHighlightSyntax obj val = liftIO $ B.Properties.setObjectPropertyBool obj "highlight-syntax" val + +{- | +Construct a `GValueConstruct` with valid value for the “@highlight-syntax@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructBufferHighlightSyntax :: (IsBuffer o) => Bool -> IO (GValueConstruct o) +constructBufferHighlightSyntax val = B.Properties.constructObjectPropertyBool "highlight-syntax" val + +#if ENABLE_OVERLOADING +data BufferHighlightSyntaxPropertyInfo +instance AttrInfo BufferHighlightSyntaxPropertyInfo where + type AttrAllowedOps BufferHighlightSyntaxPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint BufferHighlightSyntaxPropertyInfo = (~) Bool + type AttrBaseTypeConstraint BufferHighlightSyntaxPropertyInfo = IsBuffer + type AttrGetType BufferHighlightSyntaxPropertyInfo = Bool + type AttrLabel BufferHighlightSyntaxPropertyInfo = "highlight-syntax" + type AttrOrigin BufferHighlightSyntaxPropertyInfo = Buffer + attrGet _ = getBufferHighlightSyntax + attrSet _ = setBufferHighlightSyntax + attrConstruct _ = constructBufferHighlightSyntax + attrClear _ = undefined +#endif + +-- VVV Prop "implicit-trailing-newline" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@implicit-trailing-newline@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' buffer #implicitTrailingNewline +@ +-} +getBufferImplicitTrailingNewline :: (MonadIO m, IsBuffer o) => o -> m Bool +getBufferImplicitTrailingNewline obj = liftIO $ B.Properties.getObjectPropertyBool obj "implicit-trailing-newline" + +{- | +Set the value of the “@implicit-trailing-newline@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' buffer [ #implicitTrailingNewline 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setBufferImplicitTrailingNewline :: (MonadIO m, IsBuffer o) => o -> Bool -> m () +setBufferImplicitTrailingNewline obj val = liftIO $ B.Properties.setObjectPropertyBool obj "implicit-trailing-newline" val + +{- | +Construct a `GValueConstruct` with valid value for the “@implicit-trailing-newline@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructBufferImplicitTrailingNewline :: (IsBuffer o) => Bool -> IO (GValueConstruct o) +constructBufferImplicitTrailingNewline val = B.Properties.constructObjectPropertyBool "implicit-trailing-newline" val + +#if ENABLE_OVERLOADING +data BufferImplicitTrailingNewlinePropertyInfo +instance AttrInfo BufferImplicitTrailingNewlinePropertyInfo where + type AttrAllowedOps BufferImplicitTrailingNewlinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint BufferImplicitTrailingNewlinePropertyInfo = (~) Bool + type AttrBaseTypeConstraint BufferImplicitTrailingNewlinePropertyInfo = IsBuffer + type AttrGetType BufferImplicitTrailingNewlinePropertyInfo = Bool + type AttrLabel BufferImplicitTrailingNewlinePropertyInfo = "implicit-trailing-newline" + type AttrOrigin BufferImplicitTrailingNewlinePropertyInfo = Buffer + attrGet _ = getBufferImplicitTrailingNewline + attrSet _ = setBufferImplicitTrailingNewline + attrConstruct _ = constructBufferImplicitTrailingNewline + attrClear _ = undefined +#endif + +-- VVV Prop "language" + -- Type: TInterface (Name {namespace = "GtkSource", name = "Language"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just True,Just True) + +{- | +Get the value of the “@language@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' buffer #language +@ +-} +getBufferLanguage :: (MonadIO m, IsBuffer o) => o -> m (Maybe GtkSource.Language.Language) +getBufferLanguage obj = liftIO $ B.Properties.getObjectPropertyObject obj "language" GtkSource.Language.Language + +{- | +Set the value of the “@language@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' buffer [ #language 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setBufferLanguage :: (MonadIO m, IsBuffer o, GtkSource.Language.IsLanguage a) => o -> a -> m () +setBufferLanguage obj val = liftIO $ B.Properties.setObjectPropertyObject obj "language" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@language@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructBufferLanguage :: (IsBuffer o, GtkSource.Language.IsLanguage a) => a -> IO (GValueConstruct o) +constructBufferLanguage val = B.Properties.constructObjectPropertyObject "language" (Just val) + +{- | +Set the value of the “@language@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #language +@ +-} +clearBufferLanguage :: (MonadIO m, IsBuffer o) => o -> m () +clearBufferLanguage obj = liftIO $ B.Properties.setObjectPropertyObject obj "language" (Nothing :: Maybe GtkSource.Language.Language) + +#if ENABLE_OVERLOADING +data BufferLanguagePropertyInfo +instance AttrInfo BufferLanguagePropertyInfo where + type AttrAllowedOps BufferLanguagePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint BufferLanguagePropertyInfo = GtkSource.Language.IsLanguage + type AttrBaseTypeConstraint BufferLanguagePropertyInfo = IsBuffer + type AttrGetType BufferLanguagePropertyInfo = (Maybe GtkSource.Language.Language) + type AttrLabel BufferLanguagePropertyInfo = "language" + type AttrOrigin BufferLanguagePropertyInfo = Buffer + attrGet _ = getBufferLanguage + attrSet _ = setBufferLanguage + attrConstruct _ = constructBufferLanguage + attrClear _ = clearBufferLanguage +#endif + +-- VVV Prop "max-undo-levels" + -- Type: TBasicType TInt + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@max-undo-levels@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' buffer #maxUndoLevels +@ +-} +getBufferMaxUndoLevels :: (MonadIO m, IsBuffer o) => o -> m Int32 +getBufferMaxUndoLevels obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "max-undo-levels" + +{- | +Set the value of the “@max-undo-levels@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' buffer [ #maxUndoLevels 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setBufferMaxUndoLevels :: (MonadIO m, IsBuffer o) => o -> Int32 -> m () +setBufferMaxUndoLevels obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "max-undo-levels" val + +{- | +Construct a `GValueConstruct` with valid value for the “@max-undo-levels@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructBufferMaxUndoLevels :: (IsBuffer o) => Int32 -> IO (GValueConstruct o) +constructBufferMaxUndoLevels val = B.Properties.constructObjectPropertyInt32 "max-undo-levels" val + +#if ENABLE_OVERLOADING +data BufferMaxUndoLevelsPropertyInfo +instance AttrInfo BufferMaxUndoLevelsPropertyInfo where + type AttrAllowedOps BufferMaxUndoLevelsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint BufferMaxUndoLevelsPropertyInfo = (~) Int32 + type AttrBaseTypeConstraint BufferMaxUndoLevelsPropertyInfo = IsBuffer + type AttrGetType BufferMaxUndoLevelsPropertyInfo = Int32 + type AttrLabel BufferMaxUndoLevelsPropertyInfo = "max-undo-levels" + type AttrOrigin BufferMaxUndoLevelsPropertyInfo = Buffer + attrGet _ = getBufferMaxUndoLevels + attrSet _ = setBufferMaxUndoLevels + attrConstruct _ = constructBufferMaxUndoLevels + attrClear _ = undefined +#endif + +-- VVV Prop "style-scheme" + -- Type: TInterface (Name {namespace = "GtkSource", name = "StyleScheme"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just True,Just True) + +{- | +Get the value of the “@style-scheme@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' buffer #styleScheme +@ +-} +getBufferStyleScheme :: (MonadIO m, IsBuffer o) => o -> m (Maybe GtkSource.StyleScheme.StyleScheme) +getBufferStyleScheme obj = liftIO $ B.Properties.getObjectPropertyObject obj "style-scheme" GtkSource.StyleScheme.StyleScheme + +{- | +Set the value of the “@style-scheme@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' buffer [ #styleScheme 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setBufferStyleScheme :: (MonadIO m, IsBuffer o, GtkSource.StyleScheme.IsStyleScheme a) => o -> a -> m () +setBufferStyleScheme obj val = liftIO $ B.Properties.setObjectPropertyObject obj "style-scheme" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@style-scheme@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructBufferStyleScheme :: (IsBuffer o, GtkSource.StyleScheme.IsStyleScheme a) => a -> IO (GValueConstruct o) +constructBufferStyleScheme val = B.Properties.constructObjectPropertyObject "style-scheme" (Just val) + +{- | +Set the value of the “@style-scheme@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #styleScheme +@ +-} +clearBufferStyleScheme :: (MonadIO m, IsBuffer o) => o -> m () +clearBufferStyleScheme obj = liftIO $ B.Properties.setObjectPropertyObject obj "style-scheme" (Nothing :: Maybe GtkSource.StyleScheme.StyleScheme) + +#if ENABLE_OVERLOADING +data BufferStyleSchemePropertyInfo +instance AttrInfo BufferStyleSchemePropertyInfo where + type AttrAllowedOps BufferStyleSchemePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint BufferStyleSchemePropertyInfo = GtkSource.StyleScheme.IsStyleScheme + type AttrBaseTypeConstraint BufferStyleSchemePropertyInfo = IsBuffer + type AttrGetType BufferStyleSchemePropertyInfo = (Maybe GtkSource.StyleScheme.StyleScheme) + type AttrLabel BufferStyleSchemePropertyInfo = "style-scheme" + type AttrOrigin BufferStyleSchemePropertyInfo = Buffer + attrGet _ = getBufferStyleScheme + attrSet _ = setBufferStyleScheme + attrConstruct _ = constructBufferStyleScheme + attrClear _ = clearBufferStyleScheme +#endif + +-- VVV Prop "undo-manager" + -- Type: TInterface (Name {namespace = "GtkSource", name = "UndoManager"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just True,Just True) + +{- | +Get the value of the “@undo-manager@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' buffer #undoManager +@ +-} +getBufferUndoManager :: (MonadIO m, IsBuffer o) => o -> m (Maybe GtkSource.UndoManager.UndoManager) +getBufferUndoManager obj = liftIO $ B.Properties.getObjectPropertyObject obj "undo-manager" GtkSource.UndoManager.UndoManager + +{- | +Set the value of the “@undo-manager@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' buffer [ #undoManager 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setBufferUndoManager :: (MonadIO m, IsBuffer o, GtkSource.UndoManager.IsUndoManager a) => o -> a -> m () +setBufferUndoManager obj val = liftIO $ B.Properties.setObjectPropertyObject obj "undo-manager" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@undo-manager@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructBufferUndoManager :: (IsBuffer o, GtkSource.UndoManager.IsUndoManager a) => a -> IO (GValueConstruct o) +constructBufferUndoManager val = B.Properties.constructObjectPropertyObject "undo-manager" (Just val) + +{- | +Set the value of the “@undo-manager@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #undoManager +@ +-} +clearBufferUndoManager :: (MonadIO m, IsBuffer o) => o -> m () +clearBufferUndoManager obj = liftIO $ B.Properties.setObjectPropertyObject obj "undo-manager" (Nothing :: Maybe GtkSource.UndoManager.UndoManager) + +#if ENABLE_OVERLOADING +data BufferUndoManagerPropertyInfo +instance AttrInfo BufferUndoManagerPropertyInfo where + type AttrAllowedOps BufferUndoManagerPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint BufferUndoManagerPropertyInfo = GtkSource.UndoManager.IsUndoManager + type AttrBaseTypeConstraint BufferUndoManagerPropertyInfo = IsBuffer + type AttrGetType BufferUndoManagerPropertyInfo = (Maybe GtkSource.UndoManager.UndoManager) + type AttrLabel BufferUndoManagerPropertyInfo = "undo-manager" + type AttrOrigin BufferUndoManagerPropertyInfo = Buffer + attrGet _ = getBufferUndoManager + attrSet _ = setBufferUndoManager + attrConstruct _ = constructBufferUndoManager + attrClear _ = clearBufferUndoManager +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Buffer +type instance O.AttributeList Buffer = BufferAttributeList +type BufferAttributeList = ('[ '("canRedo", BufferCanRedoPropertyInfo), '("canUndo", BufferCanUndoPropertyInfo), '("copyTargetList", Gtk.TextBuffer.TextBufferCopyTargetListPropertyInfo), '("cursorPosition", Gtk.TextBuffer.TextBufferCursorPositionPropertyInfo), '("hasSelection", Gtk.TextBuffer.TextBufferHasSelectionPropertyInfo), '("highlightMatchingBrackets", BufferHighlightMatchingBracketsPropertyInfo), '("highlightSyntax", BufferHighlightSyntaxPropertyInfo), '("implicitTrailingNewline", BufferImplicitTrailingNewlinePropertyInfo), '("language", BufferLanguagePropertyInfo), '("maxUndoLevels", BufferMaxUndoLevelsPropertyInfo), '("pasteTargetList", Gtk.TextBuffer.TextBufferPasteTargetListPropertyInfo), '("styleScheme", BufferStyleSchemePropertyInfo), '("tagTable", Gtk.TextBuffer.TextBufferTagTablePropertyInfo), '("text", Gtk.TextBuffer.TextBufferTextPropertyInfo), '("undoManager", BufferUndoManagerPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +bufferHighlightMatchingBrackets :: AttrLabelProxy "highlightMatchingBrackets" +bufferHighlightMatchingBrackets = AttrLabelProxy + +bufferHighlightSyntax :: AttrLabelProxy "highlightSyntax" +bufferHighlightSyntax = AttrLabelProxy + +bufferImplicitTrailingNewline :: AttrLabelProxy "implicitTrailingNewline" +bufferImplicitTrailingNewline = AttrLabelProxy + +bufferLanguage :: AttrLabelProxy "language" +bufferLanguage = AttrLabelProxy + +bufferMaxUndoLevels :: AttrLabelProxy "maxUndoLevels" +bufferMaxUndoLevels = AttrLabelProxy + +bufferStyleScheme :: AttrLabelProxy "styleScheme" +bufferStyleScheme = AttrLabelProxy + +bufferUndoManager :: AttrLabelProxy "undoManager" +bufferUndoManager = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +data BufferBracketMatchedSignalInfo +instance SignalInfo BufferBracketMatchedSignalInfo where + type HaskellCallbackType BufferBracketMatchedSignalInfo = BufferBracketMatchedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_BufferBracketMatchedCallback cb + cb'' <- mk_BufferBracketMatchedCallback cb' + connectSignalFunPtr obj "bracket-matched" cb'' connectMode + +data BufferHighlightUpdatedSignalInfo +instance SignalInfo BufferHighlightUpdatedSignalInfo where + type HaskellCallbackType BufferHighlightUpdatedSignalInfo = BufferHighlightUpdatedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_BufferHighlightUpdatedCallback cb + cb'' <- mk_BufferHighlightUpdatedCallback cb' + connectSignalFunPtr obj "highlight-updated" cb'' connectMode + +data BufferRedoSignalInfo +instance SignalInfo BufferRedoSignalInfo where + type HaskellCallbackType BufferRedoSignalInfo = BufferRedoCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_BufferRedoCallback cb + cb'' <- mk_BufferRedoCallback cb' + connectSignalFunPtr obj "redo" cb'' connectMode + +data BufferSourceMarkUpdatedSignalInfo +instance SignalInfo BufferSourceMarkUpdatedSignalInfo where + type HaskellCallbackType BufferSourceMarkUpdatedSignalInfo = BufferSourceMarkUpdatedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_BufferSourceMarkUpdatedCallback cb + cb'' <- mk_BufferSourceMarkUpdatedCallback cb' + connectSignalFunPtr obj "source-mark-updated" cb'' connectMode + +data BufferUndoSignalInfo +instance SignalInfo BufferUndoSignalInfo where + type HaskellCallbackType BufferUndoSignalInfo = BufferUndoCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_BufferUndoCallback cb + cb'' <- mk_BufferUndoCallback cb' + connectSignalFunPtr obj "undo" cb'' connectMode + +type instance O.SignalList Buffer = BufferSignalList +type BufferSignalList = ('[ '("applyTag", Gtk.TextBuffer.TextBufferApplyTagSignalInfo), '("beginUserAction", Gtk.TextBuffer.TextBufferBeginUserActionSignalInfo), '("bracketMatched", BufferBracketMatchedSignalInfo), '("changed", Gtk.TextBuffer.TextBufferChangedSignalInfo), '("deleteRange", Gtk.TextBuffer.TextBufferDeleteRangeSignalInfo), '("endUserAction", Gtk.TextBuffer.TextBufferEndUserActionSignalInfo), '("highlightUpdated", BufferHighlightUpdatedSignalInfo), '("insertChildAnchor", Gtk.TextBuffer.TextBufferInsertChildAnchorSignalInfo), '("insertPixbuf", Gtk.TextBuffer.TextBufferInsertPixbufSignalInfo), '("insertText", Gtk.TextBuffer.TextBufferInsertTextSignalInfo), '("markDeleted", Gtk.TextBuffer.TextBufferMarkDeletedSignalInfo), '("markSet", Gtk.TextBuffer.TextBufferMarkSetSignalInfo), '("modifiedChanged", Gtk.TextBuffer.TextBufferModifiedChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pasteDone", Gtk.TextBuffer.TextBufferPasteDoneSignalInfo), '("redo", BufferRedoSignalInfo), '("removeTag", Gtk.TextBuffer.TextBufferRemoveTagSignalInfo), '("sourceMarkUpdated", BufferSourceMarkUpdatedSignalInfo), '("undo", BufferUndoSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Buffer::new +-- method type : Constructor +-- Args : [Arg {argCName = "table", argType = TInterface (Name {namespace = "Gtk", name = "TextTagTable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkTextTagTable, or %NULL to create a new one.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Buffer"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_new" gtk_source_buffer_new :: + Ptr Gtk.TextTagTable.TextTagTable -> -- table : TInterface (Name {namespace = "Gtk", name = "TextTagTable"}) + IO (Ptr Buffer) + +{- | +Creates a new source buffer. +-} +bufferNew :: + (B.CallStack.HasCallStack, MonadIO m, Gtk.TextTagTable.IsTextTagTable a) => + Maybe (a) + {- ^ /@table@/: a 'GI.Gtk.Objects.TextTagTable.TextTagTable', or 'Nothing' to create a new one. -} + -> m Buffer + {- ^ __Returns:__ a new source buffer. -} +bufferNew table = liftIO $ do + maybeTable <- case table of + Nothing -> return nullPtr + Just jTable -> do + jTable' <- unsafeManagedPtrCastPtr jTable + return jTable' + result <- gtk_source_buffer_new maybeTable + checkUnexpectedReturnNULL "bufferNew" result + result' <- (wrapObject Buffer) result + whenJust table touchManagedPtr + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Buffer::new_with_language +-- method type : Constructor +-- Args : [Arg {argCName = "language", argType = TInterface (Name {namespace = "GtkSource", name = "Language"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceLanguage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Buffer"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_new_with_language" gtk_source_buffer_new_with_language :: + Ptr GtkSource.Language.Language -> -- language : TInterface (Name {namespace = "GtkSource", name = "Language"}) + IO (Ptr Buffer) + +{- | +Creates a new source buffer using the highlighting patterns in +/@language@/. This is equivalent to creating a new source buffer with +a new tag table and then calling 'GI.GtkSource.Objects.Buffer.bufferSetLanguage'. +-} +bufferNewWithLanguage :: + (B.CallStack.HasCallStack, MonadIO m, GtkSource.Language.IsLanguage a) => + a + {- ^ /@language@/: a 'GI.GtkSource.Objects.Language.Language'. -} + -> m Buffer + {- ^ __Returns:__ a new source buffer which will highlight text +according to the highlighting patterns in /@language@/. -} +bufferNewWithLanguage language = liftIO $ do + language' <- unsafeManagedPtrCastPtr language + result <- gtk_source_buffer_new_with_language language' + checkUnexpectedReturnNULL "bufferNewWithLanguage" result + result' <- (wrapObject Buffer) result + touchManagedPtr language + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Buffer::backward_iter_to_source_mark +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an iterator.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "category", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "category to search for, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_backward_iter_to_source_mark" gtk_source_buffer_backward_iter_to_source_mark :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + CString -> -- category : TBasicType TUTF8 + IO CInt + +{- | +Moves /@iter@/ to the position of the previous 'GI.GtkSource.Objects.Mark.Mark' of the given +category. Returns 'True' if /@iter@/ was moved. If /@category@/ is NULL, the +previous source mark can be of any category. + +/Since: 2.2/ +-} +bufferBackwardIterToSourceMark :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> Gtk.TextIter.TextIter + {- ^ /@iter@/: an iterator. -} + -> Maybe (T.Text) + {- ^ /@category@/: category to search for, or 'Nothing' -} + -> m Bool + {- ^ __Returns:__ whether /@iter@/ was moved. -} +bufferBackwardIterToSourceMark buffer iter category = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + iter' <- unsafeManagedPtrGetPtr iter + maybeCategory <- case category of + Nothing -> return nullPtr + Just jCategory -> do + jCategory' <- textToCString jCategory + return jCategory' + result <- gtk_source_buffer_backward_iter_to_source_mark buffer' iter' maybeCategory + let result' = (/= 0) result + touchManagedPtr buffer + touchManagedPtr iter + freeMem maybeCategory + return result' + +#if ENABLE_OVERLOADING +data BufferBackwardIterToSourceMarkMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> Maybe (T.Text) -> m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferBackwardIterToSourceMarkMethodInfo a signature where + overloadedMethod _ = bufferBackwardIterToSourceMark + +#endif + +-- method Buffer::begin_not_undoable_action +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_begin_not_undoable_action" gtk_source_buffer_begin_not_undoable_action :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + IO () + +{- | +Marks the beginning of a not undoable action on the buffer, +disabling the undo manager. Typically you would call this function +before initially setting the contents of the buffer (e.g. when +loading a file in a text editor). + +You may nest 'GI.GtkSource.Objects.Buffer.bufferBeginNotUndoableAction' \/ +'GI.GtkSource.Objects.Buffer.bufferEndNotUndoableAction' blocks. +-} +bufferBeginNotUndoableAction :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> m () +bufferBeginNotUndoableAction buffer = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + gtk_source_buffer_begin_not_undoable_action buffer' + touchManagedPtr buffer + return () + +#if ENABLE_OVERLOADING +data BufferBeginNotUndoableActionMethodInfo +instance (signature ~ (m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferBeginNotUndoableActionMethodInfo a signature where + overloadedMethod _ = bufferBeginNotUndoableAction + +#endif + +-- method Buffer::can_redo +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_can_redo" gtk_source_buffer_can_redo :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + IO CInt + +{- | +Determines whether a source buffer can redo the last action +(i.e. if the last operation was an undo). +-} +bufferCanRedo :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> m Bool + {- ^ __Returns:__ 'True' if a redo is possible. -} +bufferCanRedo buffer = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + result <- gtk_source_buffer_can_redo buffer' + let result' = (/= 0) result + touchManagedPtr buffer + return result' + +#if ENABLE_OVERLOADING +data BufferCanRedoMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferCanRedoMethodInfo a signature where + overloadedMethod _ = bufferCanRedo + +#endif + +-- method Buffer::can_undo +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_can_undo" gtk_source_buffer_can_undo :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + IO CInt + +{- | +Determines whether a source buffer can undo the last action. +-} +bufferCanUndo :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> m Bool + {- ^ __Returns:__ 'True' if it\'s possible to undo the last action. -} +bufferCanUndo buffer = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + result <- gtk_source_buffer_can_undo buffer' + let result' = (/= 0) result + touchManagedPtr buffer + return result' + +#if ENABLE_OVERLOADING +data BufferCanUndoMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferCanUndoMethodInfo a signature where + overloadedMethod _ = bufferCanUndo + +#endif + +-- method Buffer::change_case +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "case_type", argType = TInterface (Name {namespace = "GtkSource", name = "ChangeCaseType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "how to change the case.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_change_case" gtk_source_buffer_change_case :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + CUInt -> -- case_type : TInterface (Name {namespace = "GtkSource", name = "ChangeCaseType"}) + Ptr Gtk.TextIter.TextIter -> -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + IO () + +{- | +Changes the case of the text between the specified iterators. + +/Since: 3.12/ +-} +bufferChangeCase :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> GtkSource.Enums.ChangeCaseType + {- ^ /@caseType@/: how to change the case. -} + -> Gtk.TextIter.TextIter + {- ^ /@start@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} + -> Gtk.TextIter.TextIter + {- ^ /@end@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} + -> m () +bufferChangeCase buffer caseType start end = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + let caseType' = (fromIntegral . fromEnum) caseType + start' <- unsafeManagedPtrGetPtr start + end' <- unsafeManagedPtrGetPtr end + gtk_source_buffer_change_case buffer' caseType' start' end' + touchManagedPtr buffer + touchManagedPtr start + touchManagedPtr end + return () + +#if ENABLE_OVERLOADING +data BufferChangeCaseMethodInfo +instance (signature ~ (GtkSource.Enums.ChangeCaseType -> Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferChangeCaseMethodInfo a signature where + overloadedMethod _ = bufferChangeCase + +#endif + +-- method Buffer::create_source_mark +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the name of the mark, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "category", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a string defining the mark category.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "where", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to place the mark.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Mark"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_create_source_mark" gtk_source_buffer_create_source_mark :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + CString -> -- name : TBasicType TUTF8 + CString -> -- category : TBasicType TUTF8 + Ptr Gtk.TextIter.TextIter -> -- where : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + IO (Ptr GtkSource.Mark.Mark) + +{- | +Creates a source mark in the /@buffer@/ of category /@category@/. A source mark is +a 'GI.Gtk.Objects.TextMark.TextMark' but organised into categories. Depending on the category +a pixbuf can be specified that will be displayed along the line of the mark. + +Like a 'GI.Gtk.Objects.TextMark.TextMark', a 'GI.GtkSource.Objects.Mark.Mark' can be anonymous if the +passed /@name@/ is 'Nothing'. Also, the buffer owns the marks so you +shouldn\'t unreference it. + +Marks always have left gravity and are moved to the beginning of +the line when the user deletes the line they were in. + +Typical uses for a source mark are bookmarks, breakpoints, current +executing instruction indication in a source file, etc.. + +/Since: 2.2/ +-} +bufferCreateSourceMark :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> Maybe (T.Text) + {- ^ /@name@/: the name of the mark, or 'Nothing'. -} + -> T.Text + {- ^ /@category@/: a string defining the mark category. -} + -> Gtk.TextIter.TextIter + {- ^ /@where@/: location to place the mark. -} + -> m GtkSource.Mark.Mark + {- ^ __Returns:__ a new 'GI.GtkSource.Objects.Mark.Mark', owned by the buffer. -} +bufferCreateSourceMark buffer name category where_ = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + maybeName <- case name of + Nothing -> return nullPtr + Just jName -> do + jName' <- textToCString jName + return jName' + category' <- textToCString category + where_' <- unsafeManagedPtrGetPtr where_ + result <- gtk_source_buffer_create_source_mark buffer' maybeName category' where_' + checkUnexpectedReturnNULL "bufferCreateSourceMark" result + result' <- (newObject GtkSource.Mark.Mark) result + touchManagedPtr buffer + touchManagedPtr where_ + freeMem maybeName + freeMem category' + return result' + +#if ENABLE_OVERLOADING +data BufferCreateSourceMarkMethodInfo +instance (signature ~ (Maybe (T.Text) -> T.Text -> Gtk.TextIter.TextIter -> m GtkSource.Mark.Mark), MonadIO m, IsBuffer a) => O.MethodInfo BufferCreateSourceMarkMethodInfo a signature where + overloadedMethod _ = bufferCreateSourceMark + +#endif + +-- method Buffer::end_not_undoable_action +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_end_not_undoable_action" gtk_source_buffer_end_not_undoable_action :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + IO () + +{- | +Marks the end of a not undoable action on the buffer. When the +last not undoable block is closed through the call to this +function, the list of undo actions is cleared and the undo manager +is re-enabled. +-} +bufferEndNotUndoableAction :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> m () +bufferEndNotUndoableAction buffer = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + gtk_source_buffer_end_not_undoable_action buffer' + touchManagedPtr buffer + return () + +#if ENABLE_OVERLOADING +data BufferEndNotUndoableActionMethodInfo +instance (signature ~ (m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferEndNotUndoableActionMethodInfo a signature where + overloadedMethod _ = bufferEndNotUndoableAction + +#endif + +-- method Buffer::ensure_highlight +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "start of the area to highlight.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "end of the area to highlight.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_ensure_highlight" gtk_source_buffer_ensure_highlight :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + Ptr Gtk.TextIter.TextIter -> -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + IO () + +{- | +Forces buffer to analyze and highlight the given area synchronously. + +\ + \ + This is a potentially slow operation and should be used only + when you need to make sure that some text not currently + visible is highlighted, for instance before printing. + \<\/para> +\<\/note> +-} +bufferEnsureHighlight :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> Gtk.TextIter.TextIter + {- ^ /@start@/: start of the area to highlight. -} + -> Gtk.TextIter.TextIter + {- ^ /@end@/: end of the area to highlight. -} + -> m () +bufferEnsureHighlight buffer start end = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + start' <- unsafeManagedPtrGetPtr start + end' <- unsafeManagedPtrGetPtr end + gtk_source_buffer_ensure_highlight buffer' start' end' + touchManagedPtr buffer + touchManagedPtr start + touchManagedPtr end + return () + +#if ENABLE_OVERLOADING +data BufferEnsureHighlightMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferEnsureHighlightMethodInfo a signature where + overloadedMethod _ = bufferEnsureHighlight + +#endif + +-- method Buffer::forward_iter_to_source_mark +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an iterator.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "category", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "category to search for, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_forward_iter_to_source_mark" gtk_source_buffer_forward_iter_to_source_mark :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + CString -> -- category : TBasicType TUTF8 + IO CInt + +{- | +Moves /@iter@/ to the position of the next 'GI.GtkSource.Objects.Mark.Mark' of the given +/@category@/. Returns 'True' if /@iter@/ was moved. If /@category@/ is NULL, the +next source mark can be of any category. + +/Since: 2.2/ +-} +bufferForwardIterToSourceMark :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> Gtk.TextIter.TextIter + {- ^ /@iter@/: an iterator. -} + -> Maybe (T.Text) + {- ^ /@category@/: category to search for, or 'Nothing' -} + -> m Bool + {- ^ __Returns:__ whether /@iter@/ was moved. -} +bufferForwardIterToSourceMark buffer iter category = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + iter' <- unsafeManagedPtrGetPtr iter + maybeCategory <- case category of + Nothing -> return nullPtr + Just jCategory -> do + jCategory' <- textToCString jCategory + return jCategory' + result <- gtk_source_buffer_forward_iter_to_source_mark buffer' iter' maybeCategory + let result' = (/= 0) result + touchManagedPtr buffer + touchManagedPtr iter + freeMem maybeCategory + return result' + +#if ENABLE_OVERLOADING +data BufferForwardIterToSourceMarkMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> Maybe (T.Text) -> m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferForwardIterToSourceMarkMethodInfo a signature where + overloadedMethod _ = bufferForwardIterToSourceMark + +#endif + +-- method Buffer::get_context_classes_at_iter +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_get_context_classes_at_iter" gtk_source_buffer_get_context_classes_at_iter :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + IO (Ptr CString) + +{- | +Get all defined context classes at /@iter@/. + +See the 'GI.GtkSource.Objects.Buffer.Buffer' description for the list of default context classes. + +/Since: 2.10/ +-} +bufferGetContextClassesAtIter :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> Gtk.TextIter.TextIter + {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} + -> m [T.Text] + {- ^ __Returns:__ a new 'Nothing' +terminated array of context class names. +Use 'GI.GLib.Functions.strfreev' to free the array if it is no longer needed. -} +bufferGetContextClassesAtIter buffer iter = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + iter' <- unsafeManagedPtrGetPtr iter + result <- gtk_source_buffer_get_context_classes_at_iter buffer' iter' + checkUnexpectedReturnNULL "bufferGetContextClassesAtIter" result + result' <- unpackZeroTerminatedUTF8CArray result + mapZeroTerminatedCArray freeMem result + freeMem result + touchManagedPtr buffer + touchManagedPtr iter + return result' + +#if ENABLE_OVERLOADING +data BufferGetContextClassesAtIterMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> m [T.Text]), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetContextClassesAtIterMethodInfo a signature where + overloadedMethod _ = bufferGetContextClassesAtIter + +#endif + +-- method Buffer::get_highlight_matching_brackets +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_get_highlight_matching_brackets" gtk_source_buffer_get_highlight_matching_brackets :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + IO CInt + +{- | +Determines whether bracket match highlighting is activated for the +source buffer. +-} +bufferGetHighlightMatchingBrackets :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> m Bool + {- ^ __Returns:__ 'True' if the source buffer will highlight matching +brackets. -} +bufferGetHighlightMatchingBrackets buffer = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + result <- gtk_source_buffer_get_highlight_matching_brackets buffer' + let result' = (/= 0) result + touchManagedPtr buffer + return result' + +#if ENABLE_OVERLOADING +data BufferGetHighlightMatchingBracketsMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetHighlightMatchingBracketsMethodInfo a signature where + overloadedMethod _ = bufferGetHighlightMatchingBrackets + +#endif + +-- method Buffer::get_highlight_syntax +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_get_highlight_syntax" gtk_source_buffer_get_highlight_syntax :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + IO CInt + +{- | +Determines whether syntax highlighting is activated in the source +buffer. +-} +bufferGetHighlightSyntax :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> m Bool + {- ^ __Returns:__ 'True' if syntax highlighting is enabled, 'False' otherwise. -} +bufferGetHighlightSyntax buffer = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + result <- gtk_source_buffer_get_highlight_syntax buffer' + let result' = (/= 0) result + touchManagedPtr buffer + return result' + +#if ENABLE_OVERLOADING +data BufferGetHighlightSyntaxMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetHighlightSyntaxMethodInfo a signature where + overloadedMethod _ = bufferGetHighlightSyntax + +#endif + +-- method Buffer::get_implicit_trailing_newline +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_get_implicit_trailing_newline" gtk_source_buffer_get_implicit_trailing_newline :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + IO CInt + +{- | +/No description available in the introspection data./ + +/Since: 3.14/ +-} +bufferGetImplicitTrailingNewline :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> m Bool + {- ^ __Returns:__ whether the /@buffer@/ has an implicit trailing newline. -} +bufferGetImplicitTrailingNewline buffer = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + result <- gtk_source_buffer_get_implicit_trailing_newline buffer' + let result' = (/= 0) result + touchManagedPtr buffer + return result' + +#if ENABLE_OVERLOADING +data BufferGetImplicitTrailingNewlineMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetImplicitTrailingNewlineMethodInfo a signature where + overloadedMethod _ = bufferGetImplicitTrailingNewline + +#endif + +-- method Buffer::get_language +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Language"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_get_language" gtk_source_buffer_get_language :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + IO (Ptr GtkSource.Language.Language) + +{- | +Returns the 'GI.GtkSource.Objects.Language.Language' associated with the buffer, +see 'GI.GtkSource.Objects.Buffer.bufferSetLanguage'. The returned object should not be +unreferenced by the user. +-} +bufferGetLanguage :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> m (Maybe GtkSource.Language.Language) + {- ^ __Returns:__ the 'GI.GtkSource.Objects.Language.Language' associated +with the buffer, or 'Nothing'. -} +bufferGetLanguage buffer = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + result <- gtk_source_buffer_get_language buffer' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject GtkSource.Language.Language) result' + return result'' + touchManagedPtr buffer + return maybeResult + +#if ENABLE_OVERLOADING +data BufferGetLanguageMethodInfo +instance (signature ~ (m (Maybe GtkSource.Language.Language)), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetLanguageMethodInfo a signature where + overloadedMethod _ = bufferGetLanguage + +#endif + +-- method Buffer::get_max_undo_levels +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_get_max_undo_levels" gtk_source_buffer_get_max_undo_levels :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + IO Int32 + +{- | +Determines the number of undo levels the buffer will track for buffer edits. +-} +bufferGetMaxUndoLevels :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> m Int32 + {- ^ __Returns:__ the maximum number of possible undo levels or -1 if no limit is set. -} +bufferGetMaxUndoLevels buffer = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + result <- gtk_source_buffer_get_max_undo_levels buffer' + touchManagedPtr buffer + return result + +#if ENABLE_OVERLOADING +data BufferGetMaxUndoLevelsMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetMaxUndoLevelsMethodInfo a signature where + overloadedMethod _ = bufferGetMaxUndoLevels + +#endif + +-- method Buffer::get_source_marks_at_iter +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an iterator.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "category", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "category to search for, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGSList (TInterface (Name {namespace = "GtkSource", name = "Mark"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_get_source_marks_at_iter" gtk_source_buffer_get_source_marks_at_iter :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + CString -> -- category : TBasicType TUTF8 + IO (Ptr (GSList (Ptr GtkSource.Mark.Mark))) + +{- | +Returns the list of marks of the given category at /@iter@/. If /@category@/ +is 'Nothing' it returns all marks at /@iter@/. + +/Since: 2.2/ +-} +bufferGetSourceMarksAtIter :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> Gtk.TextIter.TextIter + {- ^ /@iter@/: an iterator. -} + -> Maybe (T.Text) + {- ^ /@category@/: category to search for, or 'Nothing' -} + -> m [GtkSource.Mark.Mark] + {- ^ __Returns:__ +a newly allocated 'GI.GLib.Structs.SList.SList'. -} +bufferGetSourceMarksAtIter buffer iter category = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + iter' <- unsafeManagedPtrGetPtr iter + maybeCategory <- case category of + Nothing -> return nullPtr + Just jCategory -> do + jCategory' <- textToCString jCategory + return jCategory' + result <- gtk_source_buffer_get_source_marks_at_iter buffer' iter' maybeCategory + result' <- unpackGSList result + result'' <- mapM (newObject GtkSource.Mark.Mark) result' + g_slist_free result + touchManagedPtr buffer + touchManagedPtr iter + freeMem maybeCategory + return result'' + +#if ENABLE_OVERLOADING +data BufferGetSourceMarksAtIterMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> Maybe (T.Text) -> m [GtkSource.Mark.Mark]), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetSourceMarksAtIterMethodInfo a signature where + overloadedMethod _ = bufferGetSourceMarksAtIter + +#endif + +-- method Buffer::get_source_marks_at_line +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a line number.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "category", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "category to search for, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGSList (TInterface (Name {namespace = "GtkSource", name = "Mark"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_get_source_marks_at_line" gtk_source_buffer_get_source_marks_at_line :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + Int32 -> -- line : TBasicType TInt + CString -> -- category : TBasicType TUTF8 + IO (Ptr (GSList (Ptr GtkSource.Mark.Mark))) + +{- | +Returns the list of marks of the given category at /@line@/. +If /@category@/ is 'Nothing', all marks at /@line@/ are returned. + +/Since: 2.2/ +-} +bufferGetSourceMarksAtLine :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> Int32 + {- ^ /@line@/: a line number. -} + -> Maybe (T.Text) + {- ^ /@category@/: category to search for, or 'Nothing' -} + -> m [GtkSource.Mark.Mark] + {- ^ __Returns:__ +a newly allocated 'GI.GLib.Structs.SList.SList'. -} +bufferGetSourceMarksAtLine buffer line category = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + maybeCategory <- case category of + Nothing -> return nullPtr + Just jCategory -> do + jCategory' <- textToCString jCategory + return jCategory' + result <- gtk_source_buffer_get_source_marks_at_line buffer' line maybeCategory + result' <- unpackGSList result + result'' <- mapM (newObject GtkSource.Mark.Mark) result' + g_slist_free result + touchManagedPtr buffer + freeMem maybeCategory + return result'' + +#if ENABLE_OVERLOADING +data BufferGetSourceMarksAtLineMethodInfo +instance (signature ~ (Int32 -> Maybe (T.Text) -> m [GtkSource.Mark.Mark]), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetSourceMarksAtLineMethodInfo a signature where + overloadedMethod _ = bufferGetSourceMarksAtLine + +#endif + +-- method Buffer::get_style_scheme +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "StyleScheme"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_get_style_scheme" gtk_source_buffer_get_style_scheme :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + IO (Ptr GtkSource.StyleScheme.StyleScheme) + +{- | +Returns the 'GI.GtkSource.Objects.StyleScheme.StyleScheme' associated with the buffer, +see 'GI.GtkSource.Objects.Buffer.bufferSetStyleScheme'. +The returned object should not be unreferenced by the user. +-} +bufferGetStyleScheme :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> m (Maybe GtkSource.StyleScheme.StyleScheme) + {- ^ __Returns:__ the 'GI.GtkSource.Objects.StyleScheme.StyleScheme' +associated with the buffer, or 'Nothing'. -} +bufferGetStyleScheme buffer = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + result <- gtk_source_buffer_get_style_scheme buffer' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject GtkSource.StyleScheme.StyleScheme) result' + return result'' + touchManagedPtr buffer + return maybeResult + +#if ENABLE_OVERLOADING +data BufferGetStyleSchemeMethodInfo +instance (signature ~ (m (Maybe GtkSource.StyleScheme.StyleScheme)), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetStyleSchemeMethodInfo a signature where + overloadedMethod _ = bufferGetStyleScheme + +#endif + +-- method Buffer::get_undo_manager +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "UndoManager"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_get_undo_manager" gtk_source_buffer_get_undo_manager :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + IO (Ptr GtkSource.UndoManager.UndoManager) + +{- | +Returns the 'GI.GtkSource.Interfaces.UndoManager.UndoManager' associated with the buffer, +see 'GI.GtkSource.Objects.Buffer.bufferSetUndoManager'. The returned object should not be +unreferenced by the user. +-} +bufferGetUndoManager :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> m (Maybe GtkSource.UndoManager.UndoManager) + {- ^ __Returns:__ the 'GI.GtkSource.Interfaces.UndoManager.UndoManager' associated +with the buffer, or 'Nothing'. -} +bufferGetUndoManager buffer = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + result <- gtk_source_buffer_get_undo_manager buffer' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject GtkSource.UndoManager.UndoManager) result' + return result'' + touchManagedPtr buffer + return maybeResult + +#if ENABLE_OVERLOADING +data BufferGetUndoManagerMethodInfo +instance (signature ~ (m (Maybe GtkSource.UndoManager.UndoManager)), MonadIO m, IsBuffer a) => O.MethodInfo BufferGetUndoManagerMethodInfo a signature where + overloadedMethod _ = bufferGetUndoManager + +#endif + +-- method Buffer::iter_backward_to_context_class_toggle +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context_class", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the context class.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_iter_backward_to_context_class_toggle" gtk_source_buffer_iter_backward_to_context_class_toggle :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + CString -> -- context_class : TBasicType TUTF8 + IO CInt + +{- | +Moves backward to the next toggle (on or off) of the context class. If no +matching context class toggles are found, returns 'False', otherwise 'True'. +Does not return toggles located at /@iter@/, only toggles after /@iter@/. Sets +/@iter@/ to the location of the toggle, or to the end of the buffer if no +toggle is found. + +See the 'GI.GtkSource.Objects.Buffer.Buffer' description for the list of default context classes. + +/Since: 2.10/ +-} +bufferIterBackwardToContextClassToggle :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> Gtk.TextIter.TextIter + {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} + -> T.Text + {- ^ /@contextClass@/: the context class. -} + -> m Bool + {- ^ __Returns:__ whether we found a context class toggle before /@iter@/ -} +bufferIterBackwardToContextClassToggle buffer iter contextClass = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + iter' <- unsafeManagedPtrGetPtr iter + contextClass' <- textToCString contextClass + result <- gtk_source_buffer_iter_backward_to_context_class_toggle buffer' iter' contextClass' + let result' = (/= 0) result + touchManagedPtr buffer + touchManagedPtr iter + freeMem contextClass' + return result' + +#if ENABLE_OVERLOADING +data BufferIterBackwardToContextClassToggleMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> T.Text -> m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferIterBackwardToContextClassToggleMethodInfo a signature where + overloadedMethod _ = bufferIterBackwardToContextClassToggle + +#endif + +-- method Buffer::iter_forward_to_context_class_toggle +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context_class", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the context class.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_iter_forward_to_context_class_toggle" gtk_source_buffer_iter_forward_to_context_class_toggle :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + CString -> -- context_class : TBasicType TUTF8 + IO CInt + +{- | +Moves forward to the next toggle (on or off) of the context class. If no +matching context class toggles are found, returns 'False', otherwise 'True'. +Does not return toggles located at /@iter@/, only toggles after /@iter@/. Sets +/@iter@/ to the location of the toggle, or to the end of the buffer if no +toggle is found. + +See the 'GI.GtkSource.Objects.Buffer.Buffer' description for the list of default context classes. + +/Since: 2.10/ +-} +bufferIterForwardToContextClassToggle :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> Gtk.TextIter.TextIter + {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} + -> T.Text + {- ^ /@contextClass@/: the context class. -} + -> m Bool + {- ^ __Returns:__ whether we found a context class toggle after /@iter@/ -} +bufferIterForwardToContextClassToggle buffer iter contextClass = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + iter' <- unsafeManagedPtrGetPtr iter + contextClass' <- textToCString contextClass + result <- gtk_source_buffer_iter_forward_to_context_class_toggle buffer' iter' contextClass' + let result' = (/= 0) result + touchManagedPtr buffer + touchManagedPtr iter + freeMem contextClass' + return result' + +#if ENABLE_OVERLOADING +data BufferIterForwardToContextClassToggleMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> T.Text -> m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferIterForwardToContextClassToggleMethodInfo a signature where + overloadedMethod _ = bufferIterForwardToContextClassToggle + +#endif + +-- method Buffer::iter_has_context_class +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context_class", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "class to search for.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_iter_has_context_class" gtk_source_buffer_iter_has_context_class :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + CString -> -- context_class : TBasicType TUTF8 + IO CInt + +{- | +Check if the class /@contextClass@/ is set on /@iter@/. + +See the 'GI.GtkSource.Objects.Buffer.Buffer' description for the list of default context classes. + +/Since: 2.10/ +-} +bufferIterHasContextClass :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> Gtk.TextIter.TextIter + {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} + -> T.Text + {- ^ /@contextClass@/: class to search for. -} + -> m Bool + {- ^ __Returns:__ whether /@iter@/ has the context class. -} +bufferIterHasContextClass buffer iter contextClass = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + iter' <- unsafeManagedPtrGetPtr iter + contextClass' <- textToCString contextClass + result <- gtk_source_buffer_iter_has_context_class buffer' iter' contextClass' + let result' = (/= 0) result + touchManagedPtr buffer + touchManagedPtr iter + freeMem contextClass' + return result' + +#if ENABLE_OVERLOADING +data BufferIterHasContextClassMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> T.Text -> m Bool), MonadIO m, IsBuffer a) => O.MethodInfo BufferIterHasContextClassMethodInfo a signature where + overloadedMethod _ = bufferIterHasContextClass + +#endif + +-- method Buffer::join_lines +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_join_lines" gtk_source_buffer_join_lines :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + Ptr Gtk.TextIter.TextIter -> -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + IO () + +{- | +Joins the lines of text between the specified iterators. + +/Since: 3.16/ +-} +bufferJoinLines :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> Gtk.TextIter.TextIter + {- ^ /@start@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} + -> Gtk.TextIter.TextIter + {- ^ /@end@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} + -> m () +bufferJoinLines buffer start end = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + start' <- unsafeManagedPtrGetPtr start + end' <- unsafeManagedPtrGetPtr end + gtk_source_buffer_join_lines buffer' start' end' + touchManagedPtr buffer + touchManagedPtr start + touchManagedPtr end + return () + +#if ENABLE_OVERLOADING +data BufferJoinLinesMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferJoinLinesMethodInfo a signature where + overloadedMethod _ = bufferJoinLines + +#endif + +-- method Buffer::redo +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_redo" gtk_source_buffer_redo :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + IO () + +{- | +Redoes the last undo operation. Use 'GI.GtkSource.Objects.Buffer.bufferCanRedo' +to check whether a call to this function will have any effect. + +This function emits the 'GI.GtkSource.Objects.Buffer.Buffer'::@/redo/@ signal. +-} +bufferRedo :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> m () +bufferRedo buffer = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + gtk_source_buffer_redo buffer' + touchManagedPtr buffer + return () + +#if ENABLE_OVERLOADING +data BufferRedoMethodInfo +instance (signature ~ (m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferRedoMethodInfo a signature where + overloadedMethod _ = bufferRedo + +#endif + +-- method Buffer::remove_source_marks +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "category", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "category to search for, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_remove_source_marks" gtk_source_buffer_remove_source_marks :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + Ptr Gtk.TextIter.TextIter -> -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + CString -> -- category : TBasicType TUTF8 + IO () + +{- | +Remove all marks of /@category@/ between /@start@/ and /@end@/ from the buffer. +If /@category@/ is NULL, all marks in the range will be removed. + +/Since: 2.2/ +-} +bufferRemoveSourceMarks :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> Gtk.TextIter.TextIter + {- ^ /@start@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} + -> Gtk.TextIter.TextIter + {- ^ /@end@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} + -> Maybe (T.Text) + {- ^ /@category@/: category to search for, or 'Nothing'. -} + -> m () +bufferRemoveSourceMarks buffer start end category = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + start' <- unsafeManagedPtrGetPtr start + end' <- unsafeManagedPtrGetPtr end + maybeCategory <- case category of + Nothing -> return nullPtr + Just jCategory -> do + jCategory' <- textToCString jCategory + return jCategory' + gtk_source_buffer_remove_source_marks buffer' start' end' maybeCategory + touchManagedPtr buffer + touchManagedPtr start + touchManagedPtr end + freeMem maybeCategory + return () + +#if ENABLE_OVERLOADING +data BufferRemoveSourceMarksMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> Maybe (T.Text) -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferRemoveSourceMarksMethodInfo a signature where + overloadedMethod _ = bufferRemoveSourceMarks + +#endif + +-- method Buffer::set_highlight_matching_brackets +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "highlight", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if you want matching brackets highlighted.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_set_highlight_matching_brackets" gtk_source_buffer_set_highlight_matching_brackets :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + CInt -> -- highlight : TBasicType TBoolean + IO () + +{- | +Controls the bracket match highlighting function in the buffer. If +activated, when you position your cursor over a bracket character +(a parenthesis, a square bracket, etc.) the matching opening or +closing bracket character will be highlighted. +-} +bufferSetHighlightMatchingBrackets :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> Bool + {- ^ /@highlight@/: 'True' if you want matching brackets highlighted. -} + -> m () +bufferSetHighlightMatchingBrackets buffer highlight = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + let highlight' = (fromIntegral . fromEnum) highlight + gtk_source_buffer_set_highlight_matching_brackets buffer' highlight' + touchManagedPtr buffer + return () + +#if ENABLE_OVERLOADING +data BufferSetHighlightMatchingBracketsMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferSetHighlightMatchingBracketsMethodInfo a signature where + overloadedMethod _ = bufferSetHighlightMatchingBrackets + +#endif + +-- method Buffer::set_highlight_syntax +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "highlight", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to enable syntax highlighting, %FALSE to disable it.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_set_highlight_syntax" gtk_source_buffer_set_highlight_syntax :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + CInt -> -- highlight : TBasicType TBoolean + IO () + +{- | +Controls whether syntax is highlighted in the buffer. + +If /@highlight@/ is 'True', the text will be highlighted according to the syntax +patterns specified in the 'GI.GtkSource.Objects.Language.Language' set with +'GI.GtkSource.Objects.Buffer.bufferSetLanguage'. + +If /@highlight@/ is 'False', syntax highlighting is disabled and all the +'GI.Gtk.Objects.TextTag.TextTag' objects that have been added by the syntax highlighting engine +are removed from the buffer. +-} +bufferSetHighlightSyntax :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> Bool + {- ^ /@highlight@/: 'True' to enable syntax highlighting, 'False' to disable it. -} + -> m () +bufferSetHighlightSyntax buffer highlight = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + let highlight' = (fromIntegral . fromEnum) highlight + gtk_source_buffer_set_highlight_syntax buffer' highlight' + touchManagedPtr buffer + return () + +#if ENABLE_OVERLOADING +data BufferSetHighlightSyntaxMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferSetHighlightSyntaxMethodInfo a signature where + overloadedMethod _ = bufferSetHighlightSyntax + +#endif + +-- method Buffer::set_implicit_trailing_newline +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "implicit_trailing_newline", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_set_implicit_trailing_newline" gtk_source_buffer_set_implicit_trailing_newline :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + CInt -> -- implicit_trailing_newline : TBasicType TBoolean + IO () + +{- | +Sets whether the /@buffer@/ has an implicit trailing newline. + +If an explicit trailing newline is present in a 'GI.Gtk.Objects.TextBuffer.TextBuffer', 'GI.Gtk.Objects.TextView.TextView' +shows it as an empty line. This is generally not what the user expects. + +If /@implicitTrailingNewline@/ is 'True' (the default value): + - when a 'GI.GtkSource.Objects.FileLoader.FileLoader' loads the content of a file into the /@buffer@/, + the trailing newline (if present in the file) is not inserted into the + /@buffer@/. + - when a 'GI.GtkSource.Objects.FileSaver.FileSaver' saves the content of the /@buffer@/ into a file, a + trailing newline is added to the file. + +On the other hand, if /@implicitTrailingNewline@/ is 'False', the file\'s +content is not modified when loaded into the /@buffer@/, and the /@buffer@/\'s +content is not modified when saved into a file. + +/Since: 3.14/ +-} +bufferSetImplicitTrailingNewline :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> Bool + {- ^ /@implicitTrailingNewline@/: the new value. -} + -> m () +bufferSetImplicitTrailingNewline buffer implicitTrailingNewline = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + let implicitTrailingNewline' = (fromIntegral . fromEnum) implicitTrailingNewline + gtk_source_buffer_set_implicit_trailing_newline buffer' implicitTrailingNewline' + touchManagedPtr buffer + return () + +#if ENABLE_OVERLOADING +data BufferSetImplicitTrailingNewlineMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferSetImplicitTrailingNewlineMethodInfo a signature where + overloadedMethod _ = bufferSetImplicitTrailingNewline + +#endif + +-- method Buffer::set_language +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "language", argType = TInterface (Name {namespace = "GtkSource", name = "Language"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkSourceLanguage to set, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_set_language" gtk_source_buffer_set_language :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + Ptr GtkSource.Language.Language -> -- language : TInterface (Name {namespace = "GtkSource", name = "Language"}) + IO () + +{- | +Associates a 'GI.GtkSource.Objects.Language.Language' with the buffer. + +Note that a 'GI.GtkSource.Objects.Language.Language' affects not only the syntax highlighting, but +also the [context classes][context-classes]. If you want to disable just the +syntax highlighting, see 'GI.GtkSource.Objects.Buffer.bufferSetHighlightSyntax'. + +The buffer holds a reference to /@language@/. +-} +bufferSetLanguage :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a, GtkSource.Language.IsLanguage b) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> Maybe (b) + {- ^ /@language@/: a 'GI.GtkSource.Objects.Language.Language' to set, or 'Nothing'. -} + -> m () +bufferSetLanguage buffer language = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + maybeLanguage <- case language of + Nothing -> return nullPtr + Just jLanguage -> do + jLanguage' <- unsafeManagedPtrCastPtr jLanguage + return jLanguage' + gtk_source_buffer_set_language buffer' maybeLanguage + touchManagedPtr buffer + whenJust language touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data BufferSetLanguageMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsBuffer a, GtkSource.Language.IsLanguage b) => O.MethodInfo BufferSetLanguageMethodInfo a signature where + overloadedMethod _ = bufferSetLanguage + +#endif + +-- method Buffer::set_max_undo_levels +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_undo_levels", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the desired maximum number of undo levels.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_set_max_undo_levels" gtk_source_buffer_set_max_undo_levels :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + Int32 -> -- max_undo_levels : TBasicType TInt + IO () + +{- | +Sets the number of undo levels for user actions the buffer will +track. If the number of user actions exceeds the limit set by this +function, older actions will be discarded. + +If /@maxUndoLevels@/ is -1, the undo\/redo is unlimited. + +If /@maxUndoLevels@/ is 0, the undo\/redo is disabled. +-} +bufferSetMaxUndoLevels :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> Int32 + {- ^ /@maxUndoLevels@/: the desired maximum number of undo levels. -} + -> m () +bufferSetMaxUndoLevels buffer maxUndoLevels = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + gtk_source_buffer_set_max_undo_levels buffer' maxUndoLevels + touchManagedPtr buffer + return () + +#if ENABLE_OVERLOADING +data BufferSetMaxUndoLevelsMethodInfo +instance (signature ~ (Int32 -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferSetMaxUndoLevelsMethodInfo a signature where + overloadedMethod _ = bufferSetMaxUndoLevels + +#endif + +-- method Buffer::set_style_scheme +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scheme", argType = TInterface (Name {namespace = "GtkSource", name = "StyleScheme"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkSourceStyleScheme or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_set_style_scheme" gtk_source_buffer_set_style_scheme :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + Ptr GtkSource.StyleScheme.StyleScheme -> -- scheme : TInterface (Name {namespace = "GtkSource", name = "StyleScheme"}) + IO () + +{- | +Sets a 'GI.GtkSource.Objects.StyleScheme.StyleScheme' to be used by the buffer and the view. + +Note that a 'GI.GtkSource.Objects.StyleScheme.StyleScheme' affects not only the syntax highlighting, +but also other 'GI.GtkSource.Objects.View.View' features such as highlighting the current line, +matching brackets, the line numbers, etc. + +Instead of setting a 'Nothing' /@scheme@/, it is better to disable syntax +highlighting with 'GI.GtkSource.Objects.Buffer.bufferSetHighlightSyntax', and setting the +'GI.GtkSource.Objects.StyleScheme.StyleScheme' with the \"classic\" or \"tango\" ID, because those two +style schemes follow more closely the GTK+ theme (for example for the +background color). + +The buffer holds a reference to /@scheme@/. +-} +bufferSetStyleScheme :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a, GtkSource.StyleScheme.IsStyleScheme b) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> Maybe (b) + {- ^ /@scheme@/: a 'GI.GtkSource.Objects.StyleScheme.StyleScheme' or 'Nothing'. -} + -> m () +bufferSetStyleScheme buffer scheme = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + maybeScheme <- case scheme of + Nothing -> return nullPtr + Just jScheme -> do + jScheme' <- unsafeManagedPtrCastPtr jScheme + return jScheme' + gtk_source_buffer_set_style_scheme buffer' maybeScheme + touchManagedPtr buffer + whenJust scheme touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data BufferSetStyleSchemeMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsBuffer a, GtkSource.StyleScheme.IsStyleScheme b) => O.MethodInfo BufferSetStyleSchemeMethodInfo a signature where + overloadedMethod _ = bufferSetStyleScheme + +#endif + +-- method Buffer::set_undo_manager +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "UndoManager"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A #GtkSourceUndoManager or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_set_undo_manager" gtk_source_buffer_set_undo_manager :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + Ptr GtkSource.UndoManager.UndoManager -> -- manager : TInterface (Name {namespace = "GtkSource", name = "UndoManager"}) + IO () + +{- | +Set the buffer undo manager. If /@manager@/ is 'Nothing' the default undo manager +will be set. +-} +bufferSetUndoManager :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a, GtkSource.UndoManager.IsUndoManager b) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> Maybe (b) + {- ^ /@manager@/: A 'GI.GtkSource.Interfaces.UndoManager.UndoManager' or 'Nothing'. -} + -> m () +bufferSetUndoManager buffer manager = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + maybeManager <- case manager of + Nothing -> return nullPtr + Just jManager -> do + jManager' <- unsafeManagedPtrCastPtr jManager + return jManager' + gtk_source_buffer_set_undo_manager buffer' maybeManager + touchManagedPtr buffer + whenJust manager touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data BufferSetUndoManagerMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsBuffer a, GtkSource.UndoManager.IsUndoManager b) => O.MethodInfo BufferSetUndoManagerMethodInfo a signature where + overloadedMethod _ = bufferSetUndoManager + +#endif + +-- method Buffer::sort_lines +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GtkSource", name = "SortFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GtkSourceSortFlags specifying how the sort should behave", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "sort considering the text starting at the given column", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_sort_lines" gtk_source_buffer_sort_lines :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + Ptr Gtk.TextIter.TextIter -> -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + CUInt -> -- flags : TInterface (Name {namespace = "GtkSource", name = "SortFlags"}) + Int32 -> -- column : TBasicType TInt + IO () + +{- | +Sort the lines of text between the specified iterators. + +/Since: 3.18/ +-} +bufferSortLines :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> Gtk.TextIter.TextIter + {- ^ /@start@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} + -> Gtk.TextIter.TextIter + {- ^ /@end@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} + -> [GtkSource.Flags.SortFlags] + {- ^ /@flags@/: 'GI.GtkSource.Flags.SortFlags' specifying how the sort should behave -} + -> Int32 + {- ^ /@column@/: sort considering the text starting at the given column -} + -> m () +bufferSortLines buffer start end flags column = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + start' <- unsafeManagedPtrGetPtr start + end' <- unsafeManagedPtrGetPtr end + let flags' = gflagsToWord flags + gtk_source_buffer_sort_lines buffer' start' end' flags' column + touchManagedPtr buffer + touchManagedPtr start + touchManagedPtr end + return () + +#if ENABLE_OVERLOADING +data BufferSortLinesMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> [GtkSource.Flags.SortFlags] -> Int32 -> m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferSortLinesMethodInfo a signature where + overloadedMethod _ = bufferSortLines + +#endif + +-- method Buffer::undo +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_buffer_undo" gtk_source_buffer_undo :: + Ptr Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + IO () + +{- | +Undoes the last user action which modified the buffer. Use +'GI.GtkSource.Objects.Buffer.bufferCanUndo' to check whether a call to this +function will have any effect. + +This function emits the 'GI.GtkSource.Objects.Buffer.Buffer'::@/undo/@ signal. +-} +bufferUndo :: + (B.CallStack.HasCallStack, MonadIO m, IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> m () +bufferUndo buffer = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + gtk_source_buffer_undo buffer' + touchManagedPtr buffer + return () + +#if ENABLE_OVERLOADING +data BufferUndoMethodInfo +instance (signature ~ (m ()), MonadIO m, IsBuffer a) => O.MethodInfo BufferUndoMethodInfo a signature where + overloadedMethod _ = bufferUndo + +#endif + + diff --git a/GI/GtkSource/Objects/Buffer.hs-boot b/GI/GtkSource/Objects/Buffer.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/Buffer.hs-boot @@ -0,0 +1,173 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.Buffer 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 Buffer = Buffer (ManagedPtr Buffer) +instance GObject Buffer where +class (GObject o, O.IsDescendantOf Buffer o) => IsBuffer o +instance (GObject o, O.IsDescendantOf Buffer o) => IsBuffer o +instance O.HasParentTypes Buffer +#if ENABLE_OVERLOADING +data BufferCanRedoPropertyInfo +#endif +#if ENABLE_OVERLOADING +data BufferCanUndoPropertyInfo +#endif +#if ENABLE_OVERLOADING +data BufferHighlightMatchingBracketsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data BufferHighlightSyntaxPropertyInfo +#endif +#if ENABLE_OVERLOADING +data BufferImplicitTrailingNewlinePropertyInfo +#endif +#if ENABLE_OVERLOADING +data BufferLanguagePropertyInfo +#endif +#if ENABLE_OVERLOADING +data BufferMaxUndoLevelsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data BufferStyleSchemePropertyInfo +#endif +#if ENABLE_OVERLOADING +data BufferUndoManagerPropertyInfo +#endif +#if ENABLE_OVERLOADING +data BufferBracketMatchedSignalInfo +#endif +#if ENABLE_OVERLOADING +data BufferHighlightUpdatedSignalInfo +#endif +#if ENABLE_OVERLOADING +data BufferRedoSignalInfo +#endif +#if ENABLE_OVERLOADING +data BufferSourceMarkUpdatedSignalInfo +#endif +#if ENABLE_OVERLOADING +data BufferUndoSignalInfo +#endif +#if ENABLE_OVERLOADING +data BufferBackwardIterToSourceMarkMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferBeginNotUndoableActionMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferCanRedoMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferCanUndoMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferChangeCaseMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferCreateSourceMarkMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferEndNotUndoableActionMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferEnsureHighlightMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferForwardIterToSourceMarkMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferGetContextClassesAtIterMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferGetHighlightMatchingBracketsMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferGetHighlightSyntaxMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferGetImplicitTrailingNewlineMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferGetLanguageMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferGetMaxUndoLevelsMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferGetSourceMarksAtIterMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferGetSourceMarksAtLineMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferGetStyleSchemeMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferGetUndoManagerMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferIterBackwardToContextClassToggleMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferIterForwardToContextClassToggleMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferIterHasContextClassMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferJoinLinesMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferRedoMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferRemoveSourceMarksMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferSetHighlightMatchingBracketsMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferSetHighlightSyntaxMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferSetImplicitTrailingNewlineMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferSetLanguageMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferSetMaxUndoLevelsMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferSetStyleSchemeMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferSetUndoManagerMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferSortLinesMethodInfo +#endif +#if ENABLE_OVERLOADING +data BufferUndoMethodInfo +#endif diff --git a/GI/GtkSource/Objects/Completion.hs b/GI/GtkSource/Objects/Completion.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/Completion.hs @@ -0,0 +1,1882 @@ + + +{- | +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.Completion + ( + +-- * Exported types + Completion(..) , + IsCompletion , + toCompletion , + noCompletion , + + + -- * Methods +-- ** addProvider #method:addProvider# + +#if ENABLE_OVERLOADING + CompletionAddProviderMethodInfo , +#endif + completionAddProvider , + + +-- ** blockInteractive #method:blockInteractive# + +#if ENABLE_OVERLOADING + CompletionBlockInteractiveMethodInfo , +#endif + completionBlockInteractive , + + +-- ** createContext #method:createContext# + +#if ENABLE_OVERLOADING + CompletionCreateContextMethodInfo , +#endif + completionCreateContext , + + +-- ** getInfoWindow #method:getInfoWindow# + +#if ENABLE_OVERLOADING + CompletionGetInfoWindowMethodInfo , +#endif + completionGetInfoWindow , + + +-- ** getProviders #method:getProviders# + +#if ENABLE_OVERLOADING + CompletionGetProvidersMethodInfo , +#endif + completionGetProviders , + + +-- ** getView #method:getView# + +#if ENABLE_OVERLOADING + CompletionGetViewMethodInfo , +#endif + completionGetView , + + +-- ** hide #method:hide# + +#if ENABLE_OVERLOADING + CompletionHideMethodInfo , +#endif + completionHide , + + +-- ** moveWindow #method:moveWindow# + +#if ENABLE_OVERLOADING + CompletionMoveWindowMethodInfo , +#endif + completionMoveWindow , + + +-- ** removeProvider #method:removeProvider# + +#if ENABLE_OVERLOADING + CompletionRemoveProviderMethodInfo , +#endif + completionRemoveProvider , + + +-- ** show #method:show# + +#if ENABLE_OVERLOADING + CompletionShowMethodInfo , +#endif + completionShow , + + +-- ** unblockInteractive #method:unblockInteractive# + +#if ENABLE_OVERLOADING + CompletionUnblockInteractiveMethodInfo , +#endif + completionUnblockInteractive , + + + + + -- * Properties +-- ** accelerators #attr:accelerators# +{- | Number of keyboard accelerators to show for the first proposals. For +example, to activate the first proposal, the user can press +\\Alt\<\/keycap>\1\<\/keycap>\<\/keycombo>. +-} +#if ENABLE_OVERLOADING + CompletionAcceleratorsPropertyInfo , +#endif +#if ENABLE_OVERLOADING + completionAccelerators , +#endif + constructCompletionAccelerators , + getCompletionAccelerators , + setCompletionAccelerators , + + +-- ** autoCompleteDelay #attr:autoCompleteDelay# +{- | Determines the popup delay (in milliseconds) at which the completion +will be shown for interactive completion. +-} +#if ENABLE_OVERLOADING + CompletionAutoCompleteDelayPropertyInfo , +#endif +#if ENABLE_OVERLOADING + completionAutoCompleteDelay , +#endif + constructCompletionAutoCompleteDelay , + getCompletionAutoCompleteDelay , + setCompletionAutoCompleteDelay , + + +-- ** proposalPageSize #attr:proposalPageSize# +{- | The scroll page size of the proposals in the completion window. In +other words, when \PageDown\<\/keycap> or +\PageUp\<\/keycap> is pressed, the selected +proposal becomes the one which is located one page size backward or +forward. + +See also the 'GI.GtkSource.Objects.Completion.Completion'::@/move-cursor/@ signal. +-} +#if ENABLE_OVERLOADING + CompletionProposalPageSizePropertyInfo , +#endif +#if ENABLE_OVERLOADING + completionProposalPageSize , +#endif + constructCompletionProposalPageSize , + getCompletionProposalPageSize , + setCompletionProposalPageSize , + + +-- ** providerPageSize #attr:providerPageSize# +{- | The scroll page size of the provider pages in the completion window. + +See the 'GI.GtkSource.Objects.Completion.Completion'::@/move-page/@ signal. +-} +#if ENABLE_OVERLOADING + CompletionProviderPageSizePropertyInfo , +#endif +#if ENABLE_OVERLOADING + completionProviderPageSize , +#endif + constructCompletionProviderPageSize , + getCompletionProviderPageSize , + setCompletionProviderPageSize , + + +-- ** rememberInfoVisibility #attr:rememberInfoVisibility# +{- | Determines whether the visibility of the info window should be +saved when the completion is hidden, and restored when the completion +is shown again. +-} +#if ENABLE_OVERLOADING + CompletionRememberInfoVisibilityPropertyInfo, +#endif +#if ENABLE_OVERLOADING + completionRememberInfoVisibility , +#endif + constructCompletionRememberInfoVisibility, + getCompletionRememberInfoVisibility , + setCompletionRememberInfoVisibility , + + +-- ** selectOnShow #attr:selectOnShow# +{- | Determines whether the first proposal should be selected when the +completion is first shown. +-} +#if ENABLE_OVERLOADING + CompletionSelectOnShowPropertyInfo , +#endif +#if ENABLE_OVERLOADING + completionSelectOnShow , +#endif + constructCompletionSelectOnShow , + getCompletionSelectOnShow , + setCompletionSelectOnShow , + + +-- ** showHeaders #attr:showHeaders# +{- | Determines whether provider headers should be shown in the proposal +list. It can be useful to disable when there is only one provider. +-} +#if ENABLE_OVERLOADING + CompletionShowHeadersPropertyInfo , +#endif +#if ENABLE_OVERLOADING + completionShowHeaders , +#endif + constructCompletionShowHeaders , + getCompletionShowHeaders , + setCompletionShowHeaders , + + +-- ** showIcons #attr:showIcons# +{- | Determines whether provider and proposal icons should be shown in +the completion popup. +-} +#if ENABLE_OVERLOADING + CompletionShowIconsPropertyInfo , +#endif +#if ENABLE_OVERLOADING + completionShowIcons , +#endif + constructCompletionShowIcons , + getCompletionShowIcons , + setCompletionShowIcons , + + +-- ** view #attr:view# +{- | The 'GI.GtkSource.Objects.View.View' bound to the completion object. +-} +#if ENABLE_OVERLOADING + CompletionViewPropertyInfo , +#endif +#if ENABLE_OVERLOADING + completionView , +#endif + constructCompletionView , + getCompletionView , + + + + + -- * Signals +-- ** activateProposal #signal:activateProposal# + + C_CompletionActivateProposalCallback , + CompletionActivateProposalCallback , +#if ENABLE_OVERLOADING + CompletionActivateProposalSignalInfo , +#endif + afterCompletionActivateProposal , + genClosure_CompletionActivateProposal , + mk_CompletionActivateProposalCallback , + noCompletionActivateProposalCallback , + onCompletionActivateProposal , + wrap_CompletionActivateProposalCallback , + + +-- ** hide #signal:hide# + + C_CompletionHideCallback , + CompletionHideCallback , +#if ENABLE_OVERLOADING + CompletionHideSignalInfo , +#endif + afterCompletionHide , + genClosure_CompletionHide , + mk_CompletionHideCallback , + noCompletionHideCallback , + onCompletionHide , + wrap_CompletionHideCallback , + + +-- ** moveCursor #signal:moveCursor# + + C_CompletionMoveCursorCallback , + CompletionMoveCursorCallback , +#if ENABLE_OVERLOADING + CompletionMoveCursorSignalInfo , +#endif + afterCompletionMoveCursor , + genClosure_CompletionMoveCursor , + mk_CompletionMoveCursorCallback , + noCompletionMoveCursorCallback , + onCompletionMoveCursor , + wrap_CompletionMoveCursorCallback , + + +-- ** movePage #signal:movePage# + + C_CompletionMovePageCallback , + CompletionMovePageCallback , +#if ENABLE_OVERLOADING + CompletionMovePageSignalInfo , +#endif + afterCompletionMovePage , + genClosure_CompletionMovePage , + mk_CompletionMovePageCallback , + noCompletionMovePageCallback , + onCompletionMovePage , + wrap_CompletionMovePageCallback , + + +-- ** populateContext #signal:populateContext# + + C_CompletionPopulateContextCallback , + CompletionPopulateContextCallback , +#if ENABLE_OVERLOADING + CompletionPopulateContextSignalInfo , +#endif + afterCompletionPopulateContext , + genClosure_CompletionPopulateContext , + mk_CompletionPopulateContextCallback , + noCompletionPopulateContextCallback , + onCompletionPopulateContext , + wrap_CompletionPopulateContextCallback , + + +-- ** show #signal:show# + + C_CompletionShowCallback , + CompletionShowCallback , +#if ENABLE_OVERLOADING + CompletionShowSignalInfo , +#endif + afterCompletionShow , + genClosure_CompletionShow , + mk_CompletionShowCallback , + noCompletionShowCallback , + onCompletionShow , + wrap_CompletionShowCallback , + + + + + ) 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.Enums as Gtk.Enums +import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable +import qualified GI.Gtk.Structs.TextIter as Gtk.TextIter +import {-# SOURCE #-} qualified GI.GtkSource.Interfaces.CompletionProvider as GtkSource.CompletionProvider +import {-# SOURCE #-} qualified GI.GtkSource.Objects.CompletionContext as GtkSource.CompletionContext +import {-# SOURCE #-} qualified GI.GtkSource.Objects.CompletionInfo as GtkSource.CompletionInfo +import {-# SOURCE #-} qualified GI.GtkSource.Objects.View as GtkSource.View + +-- | Memory-managed wrapper type. +newtype Completion = Completion (ManagedPtr Completion) +foreign import ccall "gtk_source_completion_get_type" + c_gtk_source_completion_get_type :: IO GType + +instance GObject Completion where + gobjectType = c_gtk_source_completion_get_type + + +-- | Type class for types which can be safely cast to `Completion`, for instance with `toCompletion`. +class (GObject o, O.IsDescendantOf Completion o) => IsCompletion o +instance (GObject o, O.IsDescendantOf Completion o) => IsCompletion o + +instance O.HasParentTypes Completion +type instance O.ParentTypes Completion = '[GObject.Object.Object, Gtk.Buildable.Buildable] + +-- | Cast to `Completion`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toCompletion :: (MonadIO m, IsCompletion o) => o -> m Completion +toCompletion = liftIO . unsafeCastTo Completion + +-- | A convenience alias for `Nothing` :: `Maybe` `Completion`. +noCompletion :: Maybe Completion +noCompletion = Nothing + +#if ENABLE_OVERLOADING +type family ResolveCompletionMethod (t :: Symbol) (o :: *) :: * where + ResolveCompletionMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo + ResolveCompletionMethod "addProvider" o = CompletionAddProviderMethodInfo + ResolveCompletionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveCompletionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveCompletionMethod "blockInteractive" o = CompletionBlockInteractiveMethodInfo + ResolveCompletionMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo + ResolveCompletionMethod "createContext" o = CompletionCreateContextMethodInfo + ResolveCompletionMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo + ResolveCompletionMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo + ResolveCompletionMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo + ResolveCompletionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveCompletionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveCompletionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveCompletionMethod "hide" o = CompletionHideMethodInfo + ResolveCompletionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveCompletionMethod "moveWindow" o = CompletionMoveWindowMethodInfo + ResolveCompletionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveCompletionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveCompletionMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo + ResolveCompletionMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveCompletionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveCompletionMethod "removeProvider" o = CompletionRemoveProviderMethodInfo + ResolveCompletionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveCompletionMethod "show" o = CompletionShowMethodInfo + ResolveCompletionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveCompletionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveCompletionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveCompletionMethod "unblockInteractive" o = CompletionUnblockInteractiveMethodInfo + ResolveCompletionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveCompletionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveCompletionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveCompletionMethod "getInfoWindow" o = CompletionGetInfoWindowMethodInfo + ResolveCompletionMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo + ResolveCompletionMethod "getName" o = Gtk.Buildable.BuildableGetNameMethodInfo + ResolveCompletionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveCompletionMethod "getProviders" o = CompletionGetProvidersMethodInfo + ResolveCompletionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveCompletionMethod "getView" o = CompletionGetViewMethodInfo + ResolveCompletionMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo + ResolveCompletionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveCompletionMethod "setName" o = Gtk.Buildable.BuildableSetNameMethodInfo + ResolveCompletionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveCompletionMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveCompletionMethod t Completion, O.MethodInfo info Completion p) => OL.IsLabel t (Completion -> 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 Completion::activate-proposal +{- | +The 'GI.GtkSource.Objects.Completion.Completion'::@/activate-proposal/@ signal is a +keybinding signal which gets emitted when the user initiates +a proposal activation. + +Applications should not connect to it, but may emit it with +@/g_signal_emit_by_name()/@ if they need to control the proposal +activation programmatically. +-} +type CompletionActivateProposalCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `CompletionActivateProposalCallback`@. +noCompletionActivateProposalCallback :: Maybe CompletionActivateProposalCallback +noCompletionActivateProposalCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_CompletionActivateProposalCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_CompletionActivateProposalCallback`. +foreign import ccall "wrapper" + mk_CompletionActivateProposalCallback :: C_CompletionActivateProposalCallback -> IO (FunPtr C_CompletionActivateProposalCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_CompletionActivateProposal :: MonadIO m => CompletionActivateProposalCallback -> m (GClosure C_CompletionActivateProposalCallback) +genClosure_CompletionActivateProposal cb = liftIO $ do + let cb' = wrap_CompletionActivateProposalCallback cb + mk_CompletionActivateProposalCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `CompletionActivateProposalCallback` into a `C_CompletionActivateProposalCallback`. +wrap_CompletionActivateProposalCallback :: + CompletionActivateProposalCallback -> + C_CompletionActivateProposalCallback +wrap_CompletionActivateProposalCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@activate-proposal@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' completion #activateProposal callback +@ +-} +onCompletionActivateProposal :: (IsCompletion a, MonadIO m) => a -> CompletionActivateProposalCallback -> m SignalHandlerId +onCompletionActivateProposal obj cb = liftIO $ do + let cb' = wrap_CompletionActivateProposalCallback cb + cb'' <- mk_CompletionActivateProposalCallback cb' + connectSignalFunPtr obj "activate-proposal" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@activate-proposal@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' completion #activateProposal callback +@ +-} +afterCompletionActivateProposal :: (IsCompletion a, MonadIO m) => a -> CompletionActivateProposalCallback -> m SignalHandlerId +afterCompletionActivateProposal obj cb = liftIO $ do + let cb' = wrap_CompletionActivateProposalCallback cb + cb'' <- mk_CompletionActivateProposalCallback cb' + connectSignalFunPtr obj "activate-proposal" cb'' SignalConnectAfter + + +-- signal Completion::hide +{- | +Emitted when the completion window is hidden. The default handler +will actually hide the window. +-} +type CompletionHideCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `CompletionHideCallback`@. +noCompletionHideCallback :: Maybe CompletionHideCallback +noCompletionHideCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_CompletionHideCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_CompletionHideCallback`. +foreign import ccall "wrapper" + mk_CompletionHideCallback :: C_CompletionHideCallback -> IO (FunPtr C_CompletionHideCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_CompletionHide :: MonadIO m => CompletionHideCallback -> m (GClosure C_CompletionHideCallback) +genClosure_CompletionHide cb = liftIO $ do + let cb' = wrap_CompletionHideCallback cb + mk_CompletionHideCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `CompletionHideCallback` into a `C_CompletionHideCallback`. +wrap_CompletionHideCallback :: + CompletionHideCallback -> + C_CompletionHideCallback +wrap_CompletionHideCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@hide@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' completion #hide callback +@ +-} +onCompletionHide :: (IsCompletion a, MonadIO m) => a -> CompletionHideCallback -> m SignalHandlerId +onCompletionHide obj cb = liftIO $ do + let cb' = wrap_CompletionHideCallback cb + cb'' <- mk_CompletionHideCallback cb' + connectSignalFunPtr obj "hide" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@hide@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' completion #hide callback +@ +-} +afterCompletionHide :: (IsCompletion a, MonadIO m) => a -> CompletionHideCallback -> m SignalHandlerId +afterCompletionHide obj cb = liftIO $ do + let cb' = wrap_CompletionHideCallback cb + cb'' <- mk_CompletionHideCallback cb' + connectSignalFunPtr obj "hide" cb'' SignalConnectAfter + + +-- signal Completion::move-cursor +{- | +The 'GI.GtkSource.Objects.Completion.Completion'::@/move-cursor/@ signal is a keybinding +signal which gets emitted when the user initiates a cursor +movement. + +The \Up\<\/keycap>, \Down\<\/keycap>, +\PageUp\<\/keycap>, \PageDown\<\/keycap>, +\Home\<\/keycap> and \End\<\/keycap> keys are bound to the +normal behavior expected by those keys. + +When /@step@/ is equal to 'GI.Gtk.Enums.ScrollStepPages', the page size is defined by +the 'GI.GtkSource.Objects.Completion.Completion':@/proposal-page-size/@ property. It is used for +the \PageDown\<\/keycap> and \PageUp\<\/keycap> keys. + +Applications should not connect to it, but may emit it with +@/g_signal_emit_by_name()/@ if they need to control the cursor +programmatically. +-} +type CompletionMoveCursorCallback = + Gtk.Enums.ScrollStep + {- ^ /@step@/: The 'GI.Gtk.Enums.ScrollStep' by which to move the cursor -} + -> Int32 + {- ^ /@num@/: The amount of steps to move the cursor -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `CompletionMoveCursorCallback`@. +noCompletionMoveCursorCallback :: Maybe CompletionMoveCursorCallback +noCompletionMoveCursorCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_CompletionMoveCursorCallback = + Ptr () -> -- object + CUInt -> + Int32 -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_CompletionMoveCursorCallback`. +foreign import ccall "wrapper" + mk_CompletionMoveCursorCallback :: C_CompletionMoveCursorCallback -> IO (FunPtr C_CompletionMoveCursorCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_CompletionMoveCursor :: MonadIO m => CompletionMoveCursorCallback -> m (GClosure C_CompletionMoveCursorCallback) +genClosure_CompletionMoveCursor cb = liftIO $ do + let cb' = wrap_CompletionMoveCursorCallback cb + mk_CompletionMoveCursorCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `CompletionMoveCursorCallback` into a `C_CompletionMoveCursorCallback`. +wrap_CompletionMoveCursorCallback :: + CompletionMoveCursorCallback -> + C_CompletionMoveCursorCallback +wrap_CompletionMoveCursorCallback _cb _ step num _ = do + let step' = (toEnum . fromIntegral) step + _cb step' num + + +{- | +Connect a signal handler for the “@move-cursor@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' completion #moveCursor callback +@ +-} +onCompletionMoveCursor :: (IsCompletion a, MonadIO m) => a -> CompletionMoveCursorCallback -> m SignalHandlerId +onCompletionMoveCursor obj cb = liftIO $ do + let cb' = wrap_CompletionMoveCursorCallback cb + cb'' <- mk_CompletionMoveCursorCallback cb' + connectSignalFunPtr obj "move-cursor" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@move-cursor@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' completion #moveCursor callback +@ +-} +afterCompletionMoveCursor :: (IsCompletion a, MonadIO m) => a -> CompletionMoveCursorCallback -> m SignalHandlerId +afterCompletionMoveCursor obj cb = liftIO $ do + let cb' = wrap_CompletionMoveCursorCallback cb + cb'' <- mk_CompletionMoveCursorCallback cb' + connectSignalFunPtr obj "move-cursor" cb'' SignalConnectAfter + + +-- signal Completion::move-page +{- | +The 'GI.GtkSource.Objects.Completion.Completion'::@/move-page/@ signal is a keybinding +signal which gets emitted when the user initiates a page +movement (i.e. switches between provider pages). + +\\Control\<\/keycap>\Left\<\/keycap>\<\/keycombo> +is for going to the previous provider. +\\Control\<\/keycap>\Right\<\/keycap>\<\/keycombo> +is for going to the next provider. +\\Control\<\/keycap>\Home\<\/keycap>\<\/keycombo> +is for displaying all the providers. +\\Control\<\/keycap>\End\<\/keycap>\<\/keycombo> +is for going to the last provider. + +When /@step@/ is equal to @/GTK_SCROLL_PAGES/@, the page size is defined by +the 'GI.GtkSource.Objects.Completion.Completion':@/provider-page-size/@ property. + +Applications should not connect to it, but may emit it with +@/g_signal_emit_by_name()/@ if they need to control the page selection +programmatically. +-} +type CompletionMovePageCallback = + Gtk.Enums.ScrollStep + {- ^ /@step@/: The 'GI.Gtk.Enums.ScrollStep' by which to move the page -} + -> Int32 + {- ^ /@num@/: The amount of steps to move the page -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `CompletionMovePageCallback`@. +noCompletionMovePageCallback :: Maybe CompletionMovePageCallback +noCompletionMovePageCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_CompletionMovePageCallback = + Ptr () -> -- object + CUInt -> + Int32 -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_CompletionMovePageCallback`. +foreign import ccall "wrapper" + mk_CompletionMovePageCallback :: C_CompletionMovePageCallback -> IO (FunPtr C_CompletionMovePageCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_CompletionMovePage :: MonadIO m => CompletionMovePageCallback -> m (GClosure C_CompletionMovePageCallback) +genClosure_CompletionMovePage cb = liftIO $ do + let cb' = wrap_CompletionMovePageCallback cb + mk_CompletionMovePageCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `CompletionMovePageCallback` into a `C_CompletionMovePageCallback`. +wrap_CompletionMovePageCallback :: + CompletionMovePageCallback -> + C_CompletionMovePageCallback +wrap_CompletionMovePageCallback _cb _ step num _ = do + let step' = (toEnum . fromIntegral) step + _cb step' num + + +{- | +Connect a signal handler for the “@move-page@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' completion #movePage callback +@ +-} +onCompletionMovePage :: (IsCompletion a, MonadIO m) => a -> CompletionMovePageCallback -> m SignalHandlerId +onCompletionMovePage obj cb = liftIO $ do + let cb' = wrap_CompletionMovePageCallback cb + cb'' <- mk_CompletionMovePageCallback cb' + connectSignalFunPtr obj "move-page" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@move-page@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' completion #movePage callback +@ +-} +afterCompletionMovePage :: (IsCompletion a, MonadIO m) => a -> CompletionMovePageCallback -> m SignalHandlerId +afterCompletionMovePage obj cb = liftIO $ do + let cb' = wrap_CompletionMovePageCallback cb + cb'' <- mk_CompletionMovePageCallback cb' + connectSignalFunPtr obj "move-page" cb'' SignalConnectAfter + + +-- signal Completion::populate-context +{- | +Emitted just before starting to populate the completion with providers. +You can use this signal to add additional attributes in the context. +-} +type CompletionPopulateContextCallback = + GtkSource.CompletionContext.CompletionContext + {- ^ /@context@/: The 'GI.GtkSource.Objects.CompletionContext.CompletionContext' for the current completion -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `CompletionPopulateContextCallback`@. +noCompletionPopulateContextCallback :: Maybe CompletionPopulateContextCallback +noCompletionPopulateContextCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_CompletionPopulateContextCallback = + Ptr () -> -- object + Ptr GtkSource.CompletionContext.CompletionContext -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_CompletionPopulateContextCallback`. +foreign import ccall "wrapper" + mk_CompletionPopulateContextCallback :: C_CompletionPopulateContextCallback -> IO (FunPtr C_CompletionPopulateContextCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_CompletionPopulateContext :: MonadIO m => CompletionPopulateContextCallback -> m (GClosure C_CompletionPopulateContextCallback) +genClosure_CompletionPopulateContext cb = liftIO $ do + let cb' = wrap_CompletionPopulateContextCallback cb + mk_CompletionPopulateContextCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `CompletionPopulateContextCallback` into a `C_CompletionPopulateContextCallback`. +wrap_CompletionPopulateContextCallback :: + CompletionPopulateContextCallback -> + C_CompletionPopulateContextCallback +wrap_CompletionPopulateContextCallback _cb _ context _ = do + context' <- (newObject GtkSource.CompletionContext.CompletionContext) context + _cb context' + + +{- | +Connect a signal handler for the “@populate-context@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' completion #populateContext callback +@ +-} +onCompletionPopulateContext :: (IsCompletion a, MonadIO m) => a -> CompletionPopulateContextCallback -> m SignalHandlerId +onCompletionPopulateContext obj cb = liftIO $ do + let cb' = wrap_CompletionPopulateContextCallback cb + cb'' <- mk_CompletionPopulateContextCallback cb' + connectSignalFunPtr obj "populate-context" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@populate-context@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' completion #populateContext callback +@ +-} +afterCompletionPopulateContext :: (IsCompletion a, MonadIO m) => a -> CompletionPopulateContextCallback -> m SignalHandlerId +afterCompletionPopulateContext obj cb = liftIO $ do + let cb' = wrap_CompletionPopulateContextCallback cb + cb'' <- mk_CompletionPopulateContextCallback cb' + connectSignalFunPtr obj "populate-context" cb'' SignalConnectAfter + + +-- signal Completion::show +{- | +Emitted when the completion window is shown. The default handler +will actually show the window. +-} +type CompletionShowCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `CompletionShowCallback`@. +noCompletionShowCallback :: Maybe CompletionShowCallback +noCompletionShowCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_CompletionShowCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_CompletionShowCallback`. +foreign import ccall "wrapper" + mk_CompletionShowCallback :: C_CompletionShowCallback -> IO (FunPtr C_CompletionShowCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_CompletionShow :: MonadIO m => CompletionShowCallback -> m (GClosure C_CompletionShowCallback) +genClosure_CompletionShow cb = liftIO $ do + let cb' = wrap_CompletionShowCallback cb + mk_CompletionShowCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `CompletionShowCallback` into a `C_CompletionShowCallback`. +wrap_CompletionShowCallback :: + CompletionShowCallback -> + C_CompletionShowCallback +wrap_CompletionShowCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@show@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' completion #show callback +@ +-} +onCompletionShow :: (IsCompletion a, MonadIO m) => a -> CompletionShowCallback -> m SignalHandlerId +onCompletionShow obj cb = liftIO $ do + let cb' = wrap_CompletionShowCallback cb + cb'' <- mk_CompletionShowCallback cb' + connectSignalFunPtr obj "show" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@show@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' completion #show callback +@ +-} +afterCompletionShow :: (IsCompletion a, MonadIO m) => a -> CompletionShowCallback -> m SignalHandlerId +afterCompletionShow obj cb = liftIO $ do + let cb' = wrap_CompletionShowCallback cb + cb'' <- mk_CompletionShowCallback cb' + connectSignalFunPtr obj "show" cb'' SignalConnectAfter + + +-- VVV Prop "accelerators" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@accelerators@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completion #accelerators +@ +-} +getCompletionAccelerators :: (MonadIO m, IsCompletion o) => o -> m Word32 +getCompletionAccelerators obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "accelerators" + +{- | +Set the value of the “@accelerators@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completion [ #accelerators 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionAccelerators :: (MonadIO m, IsCompletion o) => o -> Word32 -> m () +setCompletionAccelerators obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "accelerators" val + +{- | +Construct a `GValueConstruct` with valid value for the “@accelerators@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionAccelerators :: (IsCompletion o) => Word32 -> IO (GValueConstruct o) +constructCompletionAccelerators val = B.Properties.constructObjectPropertyUInt32 "accelerators" val + +#if ENABLE_OVERLOADING +data CompletionAcceleratorsPropertyInfo +instance AttrInfo CompletionAcceleratorsPropertyInfo where + type AttrAllowedOps CompletionAcceleratorsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint CompletionAcceleratorsPropertyInfo = (~) Word32 + type AttrBaseTypeConstraint CompletionAcceleratorsPropertyInfo = IsCompletion + type AttrGetType CompletionAcceleratorsPropertyInfo = Word32 + type AttrLabel CompletionAcceleratorsPropertyInfo = "accelerators" + type AttrOrigin CompletionAcceleratorsPropertyInfo = Completion + attrGet _ = getCompletionAccelerators + attrSet _ = setCompletionAccelerators + attrConstruct _ = constructCompletionAccelerators + attrClear _ = undefined +#endif + +-- VVV Prop "auto-complete-delay" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@auto-complete-delay@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completion #autoCompleteDelay +@ +-} +getCompletionAutoCompleteDelay :: (MonadIO m, IsCompletion o) => o -> m Word32 +getCompletionAutoCompleteDelay obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "auto-complete-delay" + +{- | +Set the value of the “@auto-complete-delay@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completion [ #autoCompleteDelay 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionAutoCompleteDelay :: (MonadIO m, IsCompletion o) => o -> Word32 -> m () +setCompletionAutoCompleteDelay obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "auto-complete-delay" val + +{- | +Construct a `GValueConstruct` with valid value for the “@auto-complete-delay@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionAutoCompleteDelay :: (IsCompletion o) => Word32 -> IO (GValueConstruct o) +constructCompletionAutoCompleteDelay val = B.Properties.constructObjectPropertyUInt32 "auto-complete-delay" val + +#if ENABLE_OVERLOADING +data CompletionAutoCompleteDelayPropertyInfo +instance AttrInfo CompletionAutoCompleteDelayPropertyInfo where + type AttrAllowedOps CompletionAutoCompleteDelayPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint CompletionAutoCompleteDelayPropertyInfo = (~) Word32 + type AttrBaseTypeConstraint CompletionAutoCompleteDelayPropertyInfo = IsCompletion + type AttrGetType CompletionAutoCompleteDelayPropertyInfo = Word32 + type AttrLabel CompletionAutoCompleteDelayPropertyInfo = "auto-complete-delay" + type AttrOrigin CompletionAutoCompleteDelayPropertyInfo = Completion + attrGet _ = getCompletionAutoCompleteDelay + attrSet _ = setCompletionAutoCompleteDelay + attrConstruct _ = constructCompletionAutoCompleteDelay + attrClear _ = undefined +#endif + +-- VVV Prop "proposal-page-size" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@proposal-page-size@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completion #proposalPageSize +@ +-} +getCompletionProposalPageSize :: (MonadIO m, IsCompletion o) => o -> m Word32 +getCompletionProposalPageSize obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "proposal-page-size" + +{- | +Set the value of the “@proposal-page-size@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completion [ #proposalPageSize 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionProposalPageSize :: (MonadIO m, IsCompletion o) => o -> Word32 -> m () +setCompletionProposalPageSize obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "proposal-page-size" val + +{- | +Construct a `GValueConstruct` with valid value for the “@proposal-page-size@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionProposalPageSize :: (IsCompletion o) => Word32 -> IO (GValueConstruct o) +constructCompletionProposalPageSize val = B.Properties.constructObjectPropertyUInt32 "proposal-page-size" val + +#if ENABLE_OVERLOADING +data CompletionProposalPageSizePropertyInfo +instance AttrInfo CompletionProposalPageSizePropertyInfo where + type AttrAllowedOps CompletionProposalPageSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint CompletionProposalPageSizePropertyInfo = (~) Word32 + type AttrBaseTypeConstraint CompletionProposalPageSizePropertyInfo = IsCompletion + type AttrGetType CompletionProposalPageSizePropertyInfo = Word32 + type AttrLabel CompletionProposalPageSizePropertyInfo = "proposal-page-size" + type AttrOrigin CompletionProposalPageSizePropertyInfo = Completion + attrGet _ = getCompletionProposalPageSize + attrSet _ = setCompletionProposalPageSize + attrConstruct _ = constructCompletionProposalPageSize + attrClear _ = undefined +#endif + +-- VVV Prop "provider-page-size" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@provider-page-size@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completion #providerPageSize +@ +-} +getCompletionProviderPageSize :: (MonadIO m, IsCompletion o) => o -> m Word32 +getCompletionProviderPageSize obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "provider-page-size" + +{- | +Set the value of the “@provider-page-size@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completion [ #providerPageSize 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionProviderPageSize :: (MonadIO m, IsCompletion o) => o -> Word32 -> m () +setCompletionProviderPageSize obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "provider-page-size" val + +{- | +Construct a `GValueConstruct` with valid value for the “@provider-page-size@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionProviderPageSize :: (IsCompletion o) => Word32 -> IO (GValueConstruct o) +constructCompletionProviderPageSize val = B.Properties.constructObjectPropertyUInt32 "provider-page-size" val + +#if ENABLE_OVERLOADING +data CompletionProviderPageSizePropertyInfo +instance AttrInfo CompletionProviderPageSizePropertyInfo where + type AttrAllowedOps CompletionProviderPageSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint CompletionProviderPageSizePropertyInfo = (~) Word32 + type AttrBaseTypeConstraint CompletionProviderPageSizePropertyInfo = IsCompletion + type AttrGetType CompletionProviderPageSizePropertyInfo = Word32 + type AttrLabel CompletionProviderPageSizePropertyInfo = "provider-page-size" + type AttrOrigin CompletionProviderPageSizePropertyInfo = Completion + attrGet _ = getCompletionProviderPageSize + attrSet _ = setCompletionProviderPageSize + attrConstruct _ = constructCompletionProviderPageSize + attrClear _ = undefined +#endif + +-- VVV Prop "remember-info-visibility" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@remember-info-visibility@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completion #rememberInfoVisibility +@ +-} +getCompletionRememberInfoVisibility :: (MonadIO m, IsCompletion o) => o -> m Bool +getCompletionRememberInfoVisibility obj = liftIO $ B.Properties.getObjectPropertyBool obj "remember-info-visibility" + +{- | +Set the value of the “@remember-info-visibility@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completion [ #rememberInfoVisibility 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionRememberInfoVisibility :: (MonadIO m, IsCompletion o) => o -> Bool -> m () +setCompletionRememberInfoVisibility obj val = liftIO $ B.Properties.setObjectPropertyBool obj "remember-info-visibility" val + +{- | +Construct a `GValueConstruct` with valid value for the “@remember-info-visibility@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionRememberInfoVisibility :: (IsCompletion o) => Bool -> IO (GValueConstruct o) +constructCompletionRememberInfoVisibility val = B.Properties.constructObjectPropertyBool "remember-info-visibility" val + +#if ENABLE_OVERLOADING +data CompletionRememberInfoVisibilityPropertyInfo +instance AttrInfo CompletionRememberInfoVisibilityPropertyInfo where + type AttrAllowedOps CompletionRememberInfoVisibilityPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint CompletionRememberInfoVisibilityPropertyInfo = (~) Bool + type AttrBaseTypeConstraint CompletionRememberInfoVisibilityPropertyInfo = IsCompletion + type AttrGetType CompletionRememberInfoVisibilityPropertyInfo = Bool + type AttrLabel CompletionRememberInfoVisibilityPropertyInfo = "remember-info-visibility" + type AttrOrigin CompletionRememberInfoVisibilityPropertyInfo = Completion + attrGet _ = getCompletionRememberInfoVisibility + attrSet _ = setCompletionRememberInfoVisibility + attrConstruct _ = constructCompletionRememberInfoVisibility + attrClear _ = undefined +#endif + +-- VVV Prop "select-on-show" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@select-on-show@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completion #selectOnShow +@ +-} +getCompletionSelectOnShow :: (MonadIO m, IsCompletion o) => o -> m Bool +getCompletionSelectOnShow obj = liftIO $ B.Properties.getObjectPropertyBool obj "select-on-show" + +{- | +Set the value of the “@select-on-show@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completion [ #selectOnShow 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionSelectOnShow :: (MonadIO m, IsCompletion o) => o -> Bool -> m () +setCompletionSelectOnShow obj val = liftIO $ B.Properties.setObjectPropertyBool obj "select-on-show" val + +{- | +Construct a `GValueConstruct` with valid value for the “@select-on-show@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionSelectOnShow :: (IsCompletion o) => Bool -> IO (GValueConstruct o) +constructCompletionSelectOnShow val = B.Properties.constructObjectPropertyBool "select-on-show" val + +#if ENABLE_OVERLOADING +data CompletionSelectOnShowPropertyInfo +instance AttrInfo CompletionSelectOnShowPropertyInfo where + type AttrAllowedOps CompletionSelectOnShowPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint CompletionSelectOnShowPropertyInfo = (~) Bool + type AttrBaseTypeConstraint CompletionSelectOnShowPropertyInfo = IsCompletion + type AttrGetType CompletionSelectOnShowPropertyInfo = Bool + type AttrLabel CompletionSelectOnShowPropertyInfo = "select-on-show" + type AttrOrigin CompletionSelectOnShowPropertyInfo = Completion + attrGet _ = getCompletionSelectOnShow + attrSet _ = setCompletionSelectOnShow + attrConstruct _ = constructCompletionSelectOnShow + attrClear _ = undefined +#endif + +-- VVV Prop "show-headers" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@show-headers@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completion #showHeaders +@ +-} +getCompletionShowHeaders :: (MonadIO m, IsCompletion o) => o -> m Bool +getCompletionShowHeaders obj = liftIO $ B.Properties.getObjectPropertyBool obj "show-headers" + +{- | +Set the value of the “@show-headers@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completion [ #showHeaders 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionShowHeaders :: (MonadIO m, IsCompletion o) => o -> Bool -> m () +setCompletionShowHeaders obj val = liftIO $ B.Properties.setObjectPropertyBool obj "show-headers" val + +{- | +Construct a `GValueConstruct` with valid value for the “@show-headers@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionShowHeaders :: (IsCompletion o) => Bool -> IO (GValueConstruct o) +constructCompletionShowHeaders val = B.Properties.constructObjectPropertyBool "show-headers" val + +#if ENABLE_OVERLOADING +data CompletionShowHeadersPropertyInfo +instance AttrInfo CompletionShowHeadersPropertyInfo where + type AttrAllowedOps CompletionShowHeadersPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint CompletionShowHeadersPropertyInfo = (~) Bool + type AttrBaseTypeConstraint CompletionShowHeadersPropertyInfo = IsCompletion + type AttrGetType CompletionShowHeadersPropertyInfo = Bool + type AttrLabel CompletionShowHeadersPropertyInfo = "show-headers" + type AttrOrigin CompletionShowHeadersPropertyInfo = Completion + attrGet _ = getCompletionShowHeaders + attrSet _ = setCompletionShowHeaders + attrConstruct _ = constructCompletionShowHeaders + attrClear _ = undefined +#endif + +-- VVV Prop "show-icons" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@show-icons@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completion #showIcons +@ +-} +getCompletionShowIcons :: (MonadIO m, IsCompletion o) => o -> m Bool +getCompletionShowIcons obj = liftIO $ B.Properties.getObjectPropertyBool obj "show-icons" + +{- | +Set the value of the “@show-icons@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completion [ #showIcons 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionShowIcons :: (MonadIO m, IsCompletion o) => o -> Bool -> m () +setCompletionShowIcons obj val = liftIO $ B.Properties.setObjectPropertyBool obj "show-icons" val + +{- | +Construct a `GValueConstruct` with valid value for the “@show-icons@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionShowIcons :: (IsCompletion o) => Bool -> IO (GValueConstruct o) +constructCompletionShowIcons val = B.Properties.constructObjectPropertyBool "show-icons" val + +#if ENABLE_OVERLOADING +data CompletionShowIconsPropertyInfo +instance AttrInfo CompletionShowIconsPropertyInfo where + type AttrAllowedOps CompletionShowIconsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint CompletionShowIconsPropertyInfo = (~) Bool + type AttrBaseTypeConstraint CompletionShowIconsPropertyInfo = IsCompletion + type AttrGetType CompletionShowIconsPropertyInfo = Bool + type AttrLabel CompletionShowIconsPropertyInfo = "show-icons" + type AttrOrigin CompletionShowIconsPropertyInfo = Completion + attrGet _ = getCompletionShowIcons + attrSet _ = setCompletionShowIcons + attrConstruct _ = constructCompletionShowIcons + attrClear _ = undefined +#endif + +-- VVV Prop "view" + -- Type: TInterface (Name {namespace = "GtkSource", name = "View"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@view@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completion #view +@ +-} +getCompletionView :: (MonadIO m, IsCompletion o) => o -> m (Maybe GtkSource.View.View) +getCompletionView obj = liftIO $ B.Properties.getObjectPropertyObject obj "view" GtkSource.View.View + +{- | +Construct a `GValueConstruct` with valid value for the “@view@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionView :: (IsCompletion o, GtkSource.View.IsView a) => a -> IO (GValueConstruct o) +constructCompletionView val = B.Properties.constructObjectPropertyObject "view" (Just val) + +#if ENABLE_OVERLOADING +data CompletionViewPropertyInfo +instance AttrInfo CompletionViewPropertyInfo where + type AttrAllowedOps CompletionViewPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CompletionViewPropertyInfo = GtkSource.View.IsView + type AttrBaseTypeConstraint CompletionViewPropertyInfo = IsCompletion + type AttrGetType CompletionViewPropertyInfo = (Maybe GtkSource.View.View) + type AttrLabel CompletionViewPropertyInfo = "view" + type AttrOrigin CompletionViewPropertyInfo = Completion + attrGet _ = getCompletionView + attrSet _ = undefined + attrConstruct _ = constructCompletionView + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Completion +type instance O.AttributeList Completion = CompletionAttributeList +type CompletionAttributeList = ('[ '("accelerators", CompletionAcceleratorsPropertyInfo), '("autoCompleteDelay", CompletionAutoCompleteDelayPropertyInfo), '("proposalPageSize", CompletionProposalPageSizePropertyInfo), '("providerPageSize", CompletionProviderPageSizePropertyInfo), '("rememberInfoVisibility", CompletionRememberInfoVisibilityPropertyInfo), '("selectOnShow", CompletionSelectOnShowPropertyInfo), '("showHeaders", CompletionShowHeadersPropertyInfo), '("showIcons", CompletionShowIconsPropertyInfo), '("view", CompletionViewPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +completionAccelerators :: AttrLabelProxy "accelerators" +completionAccelerators = AttrLabelProxy + +completionAutoCompleteDelay :: AttrLabelProxy "autoCompleteDelay" +completionAutoCompleteDelay = AttrLabelProxy + +completionProposalPageSize :: AttrLabelProxy "proposalPageSize" +completionProposalPageSize = AttrLabelProxy + +completionProviderPageSize :: AttrLabelProxy "providerPageSize" +completionProviderPageSize = AttrLabelProxy + +completionRememberInfoVisibility :: AttrLabelProxy "rememberInfoVisibility" +completionRememberInfoVisibility = AttrLabelProxy + +completionSelectOnShow :: AttrLabelProxy "selectOnShow" +completionSelectOnShow = AttrLabelProxy + +completionShowHeaders :: AttrLabelProxy "showHeaders" +completionShowHeaders = AttrLabelProxy + +completionShowIcons :: AttrLabelProxy "showIcons" +completionShowIcons = AttrLabelProxy + +completionView :: AttrLabelProxy "view" +completionView = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +data CompletionActivateProposalSignalInfo +instance SignalInfo CompletionActivateProposalSignalInfo where + type HaskellCallbackType CompletionActivateProposalSignalInfo = CompletionActivateProposalCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_CompletionActivateProposalCallback cb + cb'' <- mk_CompletionActivateProposalCallback cb' + connectSignalFunPtr obj "activate-proposal" cb'' connectMode + +data CompletionHideSignalInfo +instance SignalInfo CompletionHideSignalInfo where + type HaskellCallbackType CompletionHideSignalInfo = CompletionHideCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_CompletionHideCallback cb + cb'' <- mk_CompletionHideCallback cb' + connectSignalFunPtr obj "hide" cb'' connectMode + +data CompletionMoveCursorSignalInfo +instance SignalInfo CompletionMoveCursorSignalInfo where + type HaskellCallbackType CompletionMoveCursorSignalInfo = CompletionMoveCursorCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_CompletionMoveCursorCallback cb + cb'' <- mk_CompletionMoveCursorCallback cb' + connectSignalFunPtr obj "move-cursor" cb'' connectMode + +data CompletionMovePageSignalInfo +instance SignalInfo CompletionMovePageSignalInfo where + type HaskellCallbackType CompletionMovePageSignalInfo = CompletionMovePageCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_CompletionMovePageCallback cb + cb'' <- mk_CompletionMovePageCallback cb' + connectSignalFunPtr obj "move-page" cb'' connectMode + +data CompletionPopulateContextSignalInfo +instance SignalInfo CompletionPopulateContextSignalInfo where + type HaskellCallbackType CompletionPopulateContextSignalInfo = CompletionPopulateContextCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_CompletionPopulateContextCallback cb + cb'' <- mk_CompletionPopulateContextCallback cb' + connectSignalFunPtr obj "populate-context" cb'' connectMode + +data CompletionShowSignalInfo +instance SignalInfo CompletionShowSignalInfo where + type HaskellCallbackType CompletionShowSignalInfo = CompletionShowCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_CompletionShowCallback cb + cb'' <- mk_CompletionShowCallback cb' + connectSignalFunPtr obj "show" cb'' connectMode + +type instance O.SignalList Completion = CompletionSignalList +type CompletionSignalList = ('[ '("activateProposal", CompletionActivateProposalSignalInfo), '("hide", CompletionHideSignalInfo), '("moveCursor", CompletionMoveCursorSignalInfo), '("movePage", CompletionMovePageSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("populateContext", CompletionPopulateContextSignalInfo), '("show", CompletionShowSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Completion::add_provider +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "completion", argType = TInterface (Name {namespace = "GtkSource", name = "Completion"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletion.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},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 TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "gtk_source_completion_add_provider" gtk_source_completion_add_provider :: + Ptr Completion -> -- completion : TInterface (Name {namespace = "GtkSource", name = "Completion"}) + Ptr GtkSource.CompletionProvider.CompletionProvider -> -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Add a new 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider' to the completion object. This will +add a reference /@provider@/, so make sure to unref your own copy when you +no longer need it. +-} +completionAddProvider :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletion a, GtkSource.CompletionProvider.IsCompletionProvider b) => + a + {- ^ /@completion@/: a 'GI.GtkSource.Objects.Completion.Completion'. -} + -> b + {- ^ /@provider@/: a 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +completionAddProvider completion provider = liftIO $ do + completion' <- unsafeManagedPtrCastPtr completion + provider' <- unsafeManagedPtrCastPtr provider + onException (do + _ <- propagateGError $ gtk_source_completion_add_provider completion' provider' + touchManagedPtr completion + touchManagedPtr provider + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data CompletionAddProviderMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsCompletion a, GtkSource.CompletionProvider.IsCompletionProvider b) => O.MethodInfo CompletionAddProviderMethodInfo a signature where + overloadedMethod _ = completionAddProvider + +#endif + +-- method Completion::block_interactive +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "completion", argType = TInterface (Name {namespace = "GtkSource", name = "Completion"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletion.", 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_block_interactive" gtk_source_completion_block_interactive :: + Ptr Completion -> -- completion : TInterface (Name {namespace = "GtkSource", name = "Completion"}) + IO () + +{- | +Block interactive completion. This can be used to disable interactive +completion when inserting or deleting text from the buffer associated with +the completion. Use 'GI.GtkSource.Objects.Completion.completionUnblockInteractive' to enable +interactive completion again. + +This function may be called multiple times. It will continue to block +interactive completion until 'GI.GtkSource.Objects.Completion.completionUnblockInteractive' +has been called the same number of times. +-} +completionBlockInteractive :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletion a) => + a + {- ^ /@completion@/: a 'GI.GtkSource.Objects.Completion.Completion'. -} + -> m () +completionBlockInteractive completion = liftIO $ do + completion' <- unsafeManagedPtrCastPtr completion + gtk_source_completion_block_interactive completion' + touchManagedPtr completion + return () + +#if ENABLE_OVERLOADING +data CompletionBlockInteractiveMethodInfo +instance (signature ~ (m ()), MonadIO m, IsCompletion a) => O.MethodInfo CompletionBlockInteractiveMethodInfo a signature where + overloadedMethod _ = completionBlockInteractive + +#endif + +-- method Completion::create_context +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "completion", argType = TInterface (Name {namespace = "GtkSource", name = "Completion"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletion.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkTextIter, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "CompletionContext"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_completion_create_context" gtk_source_completion_create_context :: + Ptr Completion -> -- completion : TInterface (Name {namespace = "GtkSource", name = "Completion"}) + Ptr Gtk.TextIter.TextIter -> -- position : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + IO (Ptr GtkSource.CompletionContext.CompletionContext) + +{- | +Create a new 'GI.GtkSource.Objects.CompletionContext.CompletionContext' for /@completion@/. The position where +the completion occurs can be specified by /@position@/. If /@position@/ is 'Nothing', +the current cursor position will be used. +-} +completionCreateContext :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletion a) => + a + {- ^ /@completion@/: a 'GI.GtkSource.Objects.Completion.Completion'. -} + -> Maybe (Gtk.TextIter.TextIter) + {- ^ /@position@/: a 'GI.Gtk.Structs.TextIter.TextIter', or 'Nothing'. -} + -> m GtkSource.CompletionContext.CompletionContext + {- ^ __Returns:__ a new 'GI.GtkSource.Objects.CompletionContext.CompletionContext'. +The reference being returned is a \'floating\' reference, +so if you invoke 'GI.GtkSource.Objects.Completion.completionShow' with this context +you don\'t need to unref it. -} +completionCreateContext completion position = liftIO $ do + completion' <- unsafeManagedPtrCastPtr completion + maybePosition <- case position of + Nothing -> return nullPtr + Just jPosition -> do + jPosition' <- unsafeManagedPtrGetPtr jPosition + return jPosition' + result <- gtk_source_completion_create_context completion' maybePosition + checkUnexpectedReturnNULL "completionCreateContext" result + result' <- (newObject GtkSource.CompletionContext.CompletionContext) result + touchManagedPtr completion + whenJust position touchManagedPtr + return result' + +#if ENABLE_OVERLOADING +data CompletionCreateContextMethodInfo +instance (signature ~ (Maybe (Gtk.TextIter.TextIter) -> m GtkSource.CompletionContext.CompletionContext), MonadIO m, IsCompletion a) => O.MethodInfo CompletionCreateContextMethodInfo a signature where + overloadedMethod _ = completionCreateContext + +#endif + +-- method Completion::get_info_window +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "completion", argType = TInterface (Name {namespace = "GtkSource", name = "Completion"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletion.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "CompletionInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_completion_get_info_window" gtk_source_completion_get_info_window :: + Ptr Completion -> -- completion : TInterface (Name {namespace = "GtkSource", name = "Completion"}) + IO (Ptr GtkSource.CompletionInfo.CompletionInfo) + +{- | +The info widget is the window where the completion displays optional extra +information of the proposal. +-} +completionGetInfoWindow :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletion a) => + a + {- ^ /@completion@/: a 'GI.GtkSource.Objects.Completion.Completion'. -} + -> m GtkSource.CompletionInfo.CompletionInfo + {- ^ __Returns:__ The 'GI.GtkSource.Objects.CompletionInfo.CompletionInfo' window + associated with /@completion@/. -} +completionGetInfoWindow completion = liftIO $ do + completion' <- unsafeManagedPtrCastPtr completion + result <- gtk_source_completion_get_info_window completion' + checkUnexpectedReturnNULL "completionGetInfoWindow" result + result' <- (newObject GtkSource.CompletionInfo.CompletionInfo) result + touchManagedPtr completion + return result' + +#if ENABLE_OVERLOADING +data CompletionGetInfoWindowMethodInfo +instance (signature ~ (m GtkSource.CompletionInfo.CompletionInfo), MonadIO m, IsCompletion a) => O.MethodInfo CompletionGetInfoWindowMethodInfo a signature where + overloadedMethod _ = completionGetInfoWindow + +#endif + +-- method Completion::get_providers +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "completion", argType = TInterface (Name {namespace = "GtkSource", name = "Completion"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletion.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGList (TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_completion_get_providers" gtk_source_completion_get_providers :: + Ptr Completion -> -- completion : TInterface (Name {namespace = "GtkSource", name = "Completion"}) + IO (Ptr (GList (Ptr GtkSource.CompletionProvider.CompletionProvider))) + +{- | +Get list of providers registered on /@completion@/. The returned list is owned +by the completion and should not be freed. +-} +completionGetProviders :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletion a) => + a + {- ^ /@completion@/: a 'GI.GtkSource.Objects.Completion.Completion'. -} + -> m [GtkSource.CompletionProvider.CompletionProvider] + {- ^ __Returns:__ +list of 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'. -} +completionGetProviders completion = liftIO $ do + completion' <- unsafeManagedPtrCastPtr completion + result <- gtk_source_completion_get_providers completion' + result' <- unpackGList result + result'' <- mapM (newObject GtkSource.CompletionProvider.CompletionProvider) result' + touchManagedPtr completion + return result'' + +#if ENABLE_OVERLOADING +data CompletionGetProvidersMethodInfo +instance (signature ~ (m [GtkSource.CompletionProvider.CompletionProvider]), MonadIO m, IsCompletion a) => O.MethodInfo CompletionGetProvidersMethodInfo a signature where + overloadedMethod _ = completionGetProviders + +#endif + +-- method Completion::get_view +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "completion", argType = TInterface (Name {namespace = "GtkSource", name = "Completion"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletion.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "View"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_completion_get_view" gtk_source_completion_get_view :: + Ptr Completion -> -- completion : TInterface (Name {namespace = "GtkSource", name = "Completion"}) + IO (Ptr GtkSource.View.View) + +{- | +The 'GI.GtkSource.Objects.View.View' associated with /@completion@/, or 'Nothing' if the view has been +destroyed. +-} +completionGetView :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletion a) => + a + {- ^ /@completion@/: a 'GI.GtkSource.Objects.Completion.Completion'. -} + -> m (Maybe GtkSource.View.View) + {- ^ __Returns:__ The 'GI.GtkSource.Objects.View.View' associated with +/@completion@/, or 'Nothing'. -} +completionGetView completion = liftIO $ do + completion' <- unsafeManagedPtrCastPtr completion + result <- gtk_source_completion_get_view completion' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject GtkSource.View.View) result' + return result'' + touchManagedPtr completion + return maybeResult + +#if ENABLE_OVERLOADING +data CompletionGetViewMethodInfo +instance (signature ~ (m (Maybe GtkSource.View.View)), MonadIO m, IsCompletion a) => O.MethodInfo CompletionGetViewMethodInfo a signature where + overloadedMethod _ = completionGetView + +#endif + +-- method Completion::hide +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "completion", argType = TInterface (Name {namespace = "GtkSource", name = "Completion"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletion.", 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_hide" gtk_source_completion_hide :: + Ptr Completion -> -- completion : TInterface (Name {namespace = "GtkSource", name = "Completion"}) + IO () + +{- | +Hides the completion if it is active (visible). +-} +completionHide :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletion a) => + a + {- ^ /@completion@/: a 'GI.GtkSource.Objects.Completion.Completion'. -} + -> m () +completionHide completion = liftIO $ do + completion' <- unsafeManagedPtrCastPtr completion + gtk_source_completion_hide completion' + touchManagedPtr completion + return () + +#if ENABLE_OVERLOADING +data CompletionHideMethodInfo +instance (signature ~ (m ()), MonadIO m, IsCompletion a) => O.MethodInfo CompletionHideMethodInfo a signature where + overloadedMethod _ = completionHide + +#endif + +-- method Completion::move_window +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "completion", argType = TInterface (Name {namespace = "GtkSource", name = "Completion"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletion.", 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 : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_completion_move_window" gtk_source_completion_move_window :: + Ptr Completion -> -- completion : TInterface (Name {namespace = "GtkSource", name = "Completion"}) + Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + IO () + +{-# DEPRECATED completionMoveWindow ["(Since version 3.8)","Use 'GI.GtkSource.Interfaces.CompletionProvider.completionProviderGetStartIter' instead."] #-} +{- | +Move the completion window to a specific iter. +-} +completionMoveWindow :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletion a) => + a + {- ^ /@completion@/: a 'GI.GtkSource.Objects.Completion.Completion'. -} + -> Gtk.TextIter.TextIter + {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} + -> m () +completionMoveWindow completion iter = liftIO $ do + completion' <- unsafeManagedPtrCastPtr completion + iter' <- unsafeManagedPtrGetPtr iter + gtk_source_completion_move_window completion' iter' + touchManagedPtr completion + touchManagedPtr iter + return () + +#if ENABLE_OVERLOADING +data CompletionMoveWindowMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> m ()), MonadIO m, IsCompletion a) => O.MethodInfo CompletionMoveWindowMethodInfo a signature where + overloadedMethod _ = completionMoveWindow + +#endif + +-- method Completion::remove_provider +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "completion", argType = TInterface (Name {namespace = "GtkSource", name = "Completion"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletion.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},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 TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "gtk_source_completion_remove_provider" gtk_source_completion_remove_provider :: + Ptr Completion -> -- completion : TInterface (Name {namespace = "GtkSource", name = "Completion"}) + Ptr GtkSource.CompletionProvider.CompletionProvider -> -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Remove /@provider@/ from the completion. +-} +completionRemoveProvider :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletion a, GtkSource.CompletionProvider.IsCompletionProvider b) => + a + {- ^ /@completion@/: a 'GI.GtkSource.Objects.Completion.Completion'. -} + -> b + {- ^ /@provider@/: a 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +completionRemoveProvider completion provider = liftIO $ do + completion' <- unsafeManagedPtrCastPtr completion + provider' <- unsafeManagedPtrCastPtr provider + onException (do + _ <- propagateGError $ gtk_source_completion_remove_provider completion' provider' + touchManagedPtr completion + touchManagedPtr provider + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data CompletionRemoveProviderMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsCompletion a, GtkSource.CompletionProvider.IsCompletionProvider b) => O.MethodInfo CompletionRemoveProviderMethodInfo a signature where + overloadedMethod _ = completionRemoveProvider + +#endif + +-- method Completion::show +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "completion", argType = TInterface (Name {namespace = "GtkSource", name = "Completion"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletion.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "providers", argType = TGList (TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "\na list of #GtkSourceCompletionProvider, or %NULL.", 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 "The #GtkSourceCompletionContext\nwith which to start the completion.", 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_show" gtk_source_completion_show :: + Ptr Completion -> -- completion : TInterface (Name {namespace = "GtkSource", name = "Completion"}) + Ptr (GList (Ptr GtkSource.CompletionProvider.CompletionProvider)) -> -- providers : TGList (TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})) + Ptr GtkSource.CompletionContext.CompletionContext -> -- context : TInterface (Name {namespace = "GtkSource", name = "CompletionContext"}) + IO CInt + +{- | +Starts a new completion with the specified 'GI.GtkSource.Objects.CompletionContext.CompletionContext' and +a list of potential candidate providers for completion. + +It can be convenient for showing a completion on-the-fly, without the need to +add or remove providers to the 'GI.GtkSource.Objects.Completion.Completion'. + +Another solution is to add providers with +'GI.GtkSource.Objects.Completion.completionAddProvider', and implement +'GI.GtkSource.Interfaces.CompletionProvider.completionProviderMatch' for each provider. +-} +completionShow :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletion a, GtkSource.CompletionProvider.IsCompletionProvider b, GtkSource.CompletionContext.IsCompletionContext c) => + a + {- ^ /@completion@/: a 'GI.GtkSource.Objects.Completion.Completion'. -} + -> [b] + {- ^ /@providers@/: +a list of 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider', or 'Nothing'. -} + -> c + {- ^ /@context@/: The 'GI.GtkSource.Objects.CompletionContext.CompletionContext' +with which to start the completion. -} + -> m Bool + {- ^ __Returns:__ 'True' if it was possible to the show completion window. -} +completionShow completion providers context = liftIO $ do + completion' <- unsafeManagedPtrCastPtr completion + providers' <- mapM unsafeManagedPtrCastPtr providers + providers'' <- packGList providers' + context' <- unsafeManagedPtrCastPtr context + result <- gtk_source_completion_show completion' providers'' context' + let result' = (/= 0) result + touchManagedPtr completion + mapM_ touchManagedPtr providers + touchManagedPtr context + g_list_free providers'' + return result' + +#if ENABLE_OVERLOADING +data CompletionShowMethodInfo +instance (signature ~ ([b] -> c -> m Bool), MonadIO m, IsCompletion a, GtkSource.CompletionProvider.IsCompletionProvider b, GtkSource.CompletionContext.IsCompletionContext c) => O.MethodInfo CompletionShowMethodInfo a signature where + overloadedMethod _ = completionShow + +#endif + +-- method Completion::unblock_interactive +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "completion", argType = TInterface (Name {namespace = "GtkSource", name = "Completion"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletion.", 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_unblock_interactive" gtk_source_completion_unblock_interactive :: + Ptr Completion -> -- completion : TInterface (Name {namespace = "GtkSource", name = "Completion"}) + IO () + +{- | +Unblock interactive completion. This can be used after using +'GI.GtkSource.Objects.Completion.completionBlockInteractive' to enable interactive completion +again. +-} +completionUnblockInteractive :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletion a) => + a + {- ^ /@completion@/: a 'GI.GtkSource.Objects.Completion.Completion'. -} + -> m () +completionUnblockInteractive completion = liftIO $ do + completion' <- unsafeManagedPtrCastPtr completion + gtk_source_completion_unblock_interactive completion' + touchManagedPtr completion + return () + +#if ENABLE_OVERLOADING +data CompletionUnblockInteractiveMethodInfo +instance (signature ~ (m ()), MonadIO m, IsCompletion a) => O.MethodInfo CompletionUnblockInteractiveMethodInfo a signature where + overloadedMethod _ = completionUnblockInteractive + +#endif + + diff --git a/GI/GtkSource/Objects/Completion.hs-boot b/GI/GtkSource/Objects/Completion.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/Completion.hs-boot @@ -0,0 +1,107 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.Completion 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 Completion = Completion (ManagedPtr Completion) +instance GObject Completion where +class (GObject o, O.IsDescendantOf Completion o) => IsCompletion o +instance (GObject o, O.IsDescendantOf Completion o) => IsCompletion o +instance O.HasParentTypes Completion +#if ENABLE_OVERLOADING +data CompletionAcceleratorsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionAutoCompleteDelayPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionProposalPageSizePropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionProviderPageSizePropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionRememberInfoVisibilityPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionSelectOnShowPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionShowHeadersPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionShowIconsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionViewPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionActivateProposalSignalInfo +#endif +#if ENABLE_OVERLOADING +data CompletionHideSignalInfo +#endif +#if ENABLE_OVERLOADING +data CompletionMoveCursorSignalInfo +#endif +#if ENABLE_OVERLOADING +data CompletionMovePageSignalInfo +#endif +#if ENABLE_OVERLOADING +data CompletionPopulateContextSignalInfo +#endif +#if ENABLE_OVERLOADING +data CompletionShowSignalInfo +#endif +#if ENABLE_OVERLOADING +data CompletionAddProviderMethodInfo +#endif +#if ENABLE_OVERLOADING +data CompletionBlockInteractiveMethodInfo +#endif +#if ENABLE_OVERLOADING +data CompletionCreateContextMethodInfo +#endif +#if ENABLE_OVERLOADING +data CompletionGetInfoWindowMethodInfo +#endif +#if ENABLE_OVERLOADING +data CompletionGetProvidersMethodInfo +#endif +#if ENABLE_OVERLOADING +data CompletionGetViewMethodInfo +#endif +#if ENABLE_OVERLOADING +data CompletionHideMethodInfo +#endif +#if ENABLE_OVERLOADING +data CompletionMoveWindowMethodInfo +#endif +#if ENABLE_OVERLOADING +data CompletionRemoveProviderMethodInfo +#endif +#if ENABLE_OVERLOADING +data CompletionShowMethodInfo +#endif +#if ENABLE_OVERLOADING +data CompletionUnblockInteractiveMethodInfo +#endif diff --git a/GI/GtkSource/Objects/CompletionContext.hs b/GI/GtkSource/Objects/CompletionContext.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/CompletionContext.hs @@ -0,0 +1,575 @@ + + +{- | +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.CompletionContext + ( + +-- * Exported types + CompletionContext(..) , + IsCompletionContext , + toCompletionContext , + noCompletionContext , + + + -- * Methods +-- ** addProposals #method:addProposals# + +#if ENABLE_OVERLOADING + CompletionContextAddProposalsMethodInfo , +#endif + completionContextAddProposals , + + +-- ** getActivation #method:getActivation# + +#if ENABLE_OVERLOADING + CompletionContextGetActivationMethodInfo, +#endif + completionContextGetActivation , + + +-- ** getIter #method:getIter# + +#if ENABLE_OVERLOADING + CompletionContextGetIterMethodInfo , +#endif + completionContextGetIter , + + + + + -- * Properties +-- ** activation #attr:activation# +{- | The completion activation +-} +#if ENABLE_OVERLOADING + CompletionContextActivationPropertyInfo , +#endif +#if ENABLE_OVERLOADING + completionContextActivation , +#endif + constructCompletionContextActivation , + getCompletionContextActivation , + setCompletionContextActivation , + + +-- ** completion #attr:completion# +{- | The 'GI.GtkSource.Objects.Completion.Completion' associated with the context. +-} +#if ENABLE_OVERLOADING + CompletionContextCompletionPropertyInfo , +#endif +#if ENABLE_OVERLOADING + completionContextCompletion , +#endif + constructCompletionContextCompletion , + getCompletionContextCompletion , + + +-- ** iter #attr:iter# +{- | The 'GI.Gtk.Structs.TextIter.TextIter' at which the completion is invoked. +-} +#if ENABLE_OVERLOADING + CompletionContextIterPropertyInfo , +#endif + clearCompletionContextIter , +#if ENABLE_OVERLOADING + completionContextIter , +#endif + constructCompletionContextIter , + getCompletionContextIter , + setCompletionContextIter , + + + + + -- * Signals +-- ** cancelled #signal:cancelled# + + C_CompletionContextCancelledCallback , + CompletionContextCancelledCallback , +#if ENABLE_OVERLOADING + CompletionContextCancelledSignalInfo , +#endif + afterCompletionContextCancelled , + genClosure_CompletionContextCancelled , + mk_CompletionContextCancelledCallback , + noCompletionContextCancelledCallback , + onCompletionContextCancelled , + wrap_CompletionContextCancelledCallback , + + + + + ) 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.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.Interfaces.CompletionProvider as GtkSource.CompletionProvider +import {-# SOURCE #-} qualified GI.GtkSource.Objects.Completion as GtkSource.Completion + +-- | Memory-managed wrapper type. +newtype CompletionContext = CompletionContext (ManagedPtr CompletionContext) +foreign import ccall "gtk_source_completion_context_get_type" + c_gtk_source_completion_context_get_type :: IO GType + +instance GObject CompletionContext where + gobjectType = c_gtk_source_completion_context_get_type + + +-- | Type class for types which can be safely cast to `CompletionContext`, for instance with `toCompletionContext`. +class (GObject o, O.IsDescendantOf CompletionContext o) => IsCompletionContext o +instance (GObject o, O.IsDescendantOf CompletionContext o) => IsCompletionContext o + +instance O.HasParentTypes CompletionContext +type instance O.ParentTypes CompletionContext = '[GObject.Object.Object] + +-- | Cast to `CompletionContext`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toCompletionContext :: (MonadIO m, IsCompletionContext o) => o -> m CompletionContext +toCompletionContext = liftIO . unsafeCastTo CompletionContext + +-- | A convenience alias for `Nothing` :: `Maybe` `CompletionContext`. +noCompletionContext :: Maybe CompletionContext +noCompletionContext = Nothing + +#if ENABLE_OVERLOADING +type family ResolveCompletionContextMethod (t :: Symbol) (o :: *) :: * where + ResolveCompletionContextMethod "addProposals" o = CompletionContextAddProposalsMethodInfo + ResolveCompletionContextMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveCompletionContextMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveCompletionContextMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveCompletionContextMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveCompletionContextMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveCompletionContextMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveCompletionContextMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveCompletionContextMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveCompletionContextMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveCompletionContextMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveCompletionContextMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveCompletionContextMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveCompletionContextMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveCompletionContextMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveCompletionContextMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveCompletionContextMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveCompletionContextMethod "getActivation" o = CompletionContextGetActivationMethodInfo + ResolveCompletionContextMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveCompletionContextMethod "getIter" o = CompletionContextGetIterMethodInfo + ResolveCompletionContextMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveCompletionContextMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveCompletionContextMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveCompletionContextMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveCompletionContextMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveCompletionContextMethod t CompletionContext, O.MethodInfo info CompletionContext p) => OL.IsLabel t (CompletionContext -> 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 CompletionContext::cancelled +{- | +Emitted when the current population of proposals has been cancelled. +Providers adding proposals asynchronously should connect to this signal +to know when to cancel running proposal queries. +-} +type CompletionContextCancelledCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `CompletionContextCancelledCallback`@. +noCompletionContextCancelledCallback :: Maybe CompletionContextCancelledCallback +noCompletionContextCancelledCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_CompletionContextCancelledCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_CompletionContextCancelledCallback`. +foreign import ccall "wrapper" + mk_CompletionContextCancelledCallback :: C_CompletionContextCancelledCallback -> IO (FunPtr C_CompletionContextCancelledCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_CompletionContextCancelled :: MonadIO m => CompletionContextCancelledCallback -> m (GClosure C_CompletionContextCancelledCallback) +genClosure_CompletionContextCancelled cb = liftIO $ do + let cb' = wrap_CompletionContextCancelledCallback cb + mk_CompletionContextCancelledCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `CompletionContextCancelledCallback` into a `C_CompletionContextCancelledCallback`. +wrap_CompletionContextCancelledCallback :: + CompletionContextCancelledCallback -> + C_CompletionContextCancelledCallback +wrap_CompletionContextCancelledCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@cancelled@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' completionContext #cancelled callback +@ +-} +onCompletionContextCancelled :: (IsCompletionContext a, MonadIO m) => a -> CompletionContextCancelledCallback -> m SignalHandlerId +onCompletionContextCancelled obj cb = liftIO $ do + let cb' = wrap_CompletionContextCancelledCallback cb + cb'' <- mk_CompletionContextCancelledCallback cb' + connectSignalFunPtr obj "cancelled" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@cancelled@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' completionContext #cancelled callback +@ +-} +afterCompletionContextCancelled :: (IsCompletionContext a, MonadIO m) => a -> CompletionContextCancelledCallback -> m SignalHandlerId +afterCompletionContextCancelled obj cb = liftIO $ do + let cb' = wrap_CompletionContextCancelledCallback cb + cb'' <- mk_CompletionContextCancelledCallback cb' + connectSignalFunPtr obj "cancelled" cb'' SignalConnectAfter + + +-- VVV Prop "activation" + -- Type: TInterface (Name {namespace = "GtkSource", name = "CompletionActivation"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@activation@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completionContext #activation +@ +-} +getCompletionContextActivation :: (MonadIO m, IsCompletionContext o) => o -> m [GtkSource.Flags.CompletionActivation] +getCompletionContextActivation obj = liftIO $ B.Properties.getObjectPropertyFlags obj "activation" + +{- | +Set the value of the “@activation@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completionContext [ #activation 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionContextActivation :: (MonadIO m, IsCompletionContext o) => o -> [GtkSource.Flags.CompletionActivation] -> m () +setCompletionContextActivation obj val = liftIO $ B.Properties.setObjectPropertyFlags obj "activation" val + +{- | +Construct a `GValueConstruct` with valid value for the “@activation@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionContextActivation :: (IsCompletionContext o) => [GtkSource.Flags.CompletionActivation] -> IO (GValueConstruct o) +constructCompletionContextActivation val = B.Properties.constructObjectPropertyFlags "activation" val + +#if ENABLE_OVERLOADING +data CompletionContextActivationPropertyInfo +instance AttrInfo CompletionContextActivationPropertyInfo where + type AttrAllowedOps CompletionContextActivationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint CompletionContextActivationPropertyInfo = (~) [GtkSource.Flags.CompletionActivation] + type AttrBaseTypeConstraint CompletionContextActivationPropertyInfo = IsCompletionContext + type AttrGetType CompletionContextActivationPropertyInfo = [GtkSource.Flags.CompletionActivation] + type AttrLabel CompletionContextActivationPropertyInfo = "activation" + type AttrOrigin CompletionContextActivationPropertyInfo = CompletionContext + attrGet _ = getCompletionContextActivation + attrSet _ = setCompletionContextActivation + attrConstruct _ = constructCompletionContextActivation + attrClear _ = undefined +#endif + +-- VVV Prop "completion" + -- Type: TInterface (Name {namespace = "GtkSource", name = "Completion"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@completion@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completionContext #completion +@ +-} +getCompletionContextCompletion :: (MonadIO m, IsCompletionContext o) => o -> m (Maybe GtkSource.Completion.Completion) +getCompletionContextCompletion obj = liftIO $ B.Properties.getObjectPropertyObject obj "completion" GtkSource.Completion.Completion + +{- | +Construct a `GValueConstruct` with valid value for the “@completion@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionContextCompletion :: (IsCompletionContext o, GtkSource.Completion.IsCompletion a) => a -> IO (GValueConstruct o) +constructCompletionContextCompletion val = B.Properties.constructObjectPropertyObject "completion" (Just val) + +#if ENABLE_OVERLOADING +data CompletionContextCompletionPropertyInfo +instance AttrInfo CompletionContextCompletionPropertyInfo where + type AttrAllowedOps CompletionContextCompletionPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CompletionContextCompletionPropertyInfo = GtkSource.Completion.IsCompletion + type AttrBaseTypeConstraint CompletionContextCompletionPropertyInfo = IsCompletionContext + type AttrGetType CompletionContextCompletionPropertyInfo = (Maybe GtkSource.Completion.Completion) + type AttrLabel CompletionContextCompletionPropertyInfo = "completion" + type AttrOrigin CompletionContextCompletionPropertyInfo = CompletionContext + attrGet _ = getCompletionContextCompletion + attrSet _ = undefined + attrConstruct _ = constructCompletionContextCompletion + attrClear _ = undefined +#endif + +-- VVV Prop "iter" + -- Type: TInterface (Name {namespace = "Gtk", name = "TextIter"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@iter@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completionContext #iter +@ +-} +getCompletionContextIter :: (MonadIO m, IsCompletionContext o) => o -> m (Maybe Gtk.TextIter.TextIter) +getCompletionContextIter obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "iter" Gtk.TextIter.TextIter + +{- | +Set the value of the “@iter@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completionContext [ #iter 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionContextIter :: (MonadIO m, IsCompletionContext o) => o -> Gtk.TextIter.TextIter -> m () +setCompletionContextIter obj val = liftIO $ B.Properties.setObjectPropertyBoxed obj "iter" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@iter@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionContextIter :: (IsCompletionContext o) => Gtk.TextIter.TextIter -> IO (GValueConstruct o) +constructCompletionContextIter val = B.Properties.constructObjectPropertyBoxed "iter" (Just val) + +{- | +Set the value of the “@iter@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #iter +@ +-} +clearCompletionContextIter :: (MonadIO m, IsCompletionContext o) => o -> m () +clearCompletionContextIter obj = liftIO $ B.Properties.setObjectPropertyBoxed obj "iter" (Nothing :: Maybe Gtk.TextIter.TextIter) + +#if ENABLE_OVERLOADING +data CompletionContextIterPropertyInfo +instance AttrInfo CompletionContextIterPropertyInfo where + type AttrAllowedOps CompletionContextIterPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CompletionContextIterPropertyInfo = (~) Gtk.TextIter.TextIter + type AttrBaseTypeConstraint CompletionContextIterPropertyInfo = IsCompletionContext + type AttrGetType CompletionContextIterPropertyInfo = (Maybe Gtk.TextIter.TextIter) + type AttrLabel CompletionContextIterPropertyInfo = "iter" + type AttrOrigin CompletionContextIterPropertyInfo = CompletionContext + attrGet _ = getCompletionContextIter + attrSet _ = setCompletionContextIter + attrConstruct _ = constructCompletionContextIter + attrClear _ = clearCompletionContextIter +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList CompletionContext +type instance O.AttributeList CompletionContext = CompletionContextAttributeList +type CompletionContextAttributeList = ('[ '("activation", CompletionContextActivationPropertyInfo), '("completion", CompletionContextCompletionPropertyInfo), '("iter", CompletionContextIterPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +completionContextActivation :: AttrLabelProxy "activation" +completionContextActivation = AttrLabelProxy + +completionContextCompletion :: AttrLabelProxy "completion" +completionContextCompletion = AttrLabelProxy + +completionContextIter :: AttrLabelProxy "iter" +completionContextIter = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +data CompletionContextCancelledSignalInfo +instance SignalInfo CompletionContextCancelledSignalInfo where + type HaskellCallbackType CompletionContextCancelledSignalInfo = CompletionContextCancelledCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_CompletionContextCancelledCallback cb + cb'' <- mk_CompletionContextCancelledCallback cb' + connectSignalFunPtr obj "cancelled" cb'' connectMode + +type instance O.SignalList CompletionContext = CompletionContextSignalList +type CompletionContextSignalList = ('[ '("cancelled", CompletionContextCancelledSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method CompletionContext::add_proposals +-- method type : OrdinaryMethod +-- Args : [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 = "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 = "proposals", argType = TGList (TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"})), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The list of proposals to add.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "finished", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether the provider is finished adding proposals.", 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_context_add_proposals" gtk_source_completion_context_add_proposals :: + Ptr CompletionContext -> -- context : TInterface (Name {namespace = "GtkSource", name = "CompletionContext"}) + Ptr GtkSource.CompletionProvider.CompletionProvider -> -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"}) + Ptr (GList (Ptr GtkSource.CompletionProposal.CompletionProposal)) -> -- proposals : TGList (TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"})) + CInt -> -- finished : TBasicType TBoolean + IO () + +{- | +Providers can use this function to add proposals to the completion. They +can do so asynchronously by means of the /@finished@/ argument. Providers must +ensure that they always call this function with /@finished@/ set to 'True' +once each population (even if no proposals need to be added). +Population occurs when the 'GI.GtkSource.Interfaces.CompletionProvider.completionProviderPopulate' +function is called. +-} +completionContextAddProposals :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletionContext a, GtkSource.CompletionProvider.IsCompletionProvider b, GtkSource.CompletionProposal.IsCompletionProposal c) => + a + {- ^ /@context@/: a 'GI.GtkSource.Objects.CompletionContext.CompletionContext'. -} + -> b + {- ^ /@provider@/: a 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'. -} + -> [c] + {- ^ /@proposals@/: The list of proposals to add. -} + -> Bool + {- ^ /@finished@/: Whether the provider is finished adding proposals. -} + -> m () +completionContextAddProposals context provider proposals finished = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + provider' <- unsafeManagedPtrCastPtr provider + proposals' <- mapM unsafeManagedPtrCastPtr proposals + proposals'' <- packGList proposals' + let finished' = (fromIntegral . fromEnum) finished + gtk_source_completion_context_add_proposals context' provider' proposals'' finished' + touchManagedPtr context + touchManagedPtr provider + mapM_ touchManagedPtr proposals + g_list_free proposals'' + return () + +#if ENABLE_OVERLOADING +data CompletionContextAddProposalsMethodInfo +instance (signature ~ (b -> [c] -> Bool -> m ()), MonadIO m, IsCompletionContext a, GtkSource.CompletionProvider.IsCompletionProvider b, GtkSource.CompletionProposal.IsCompletionProposal c) => O.MethodInfo CompletionContextAddProposalsMethodInfo a signature where + overloadedMethod _ = completionContextAddProposals + +#endif + +-- method CompletionContext::get_activation +-- method type : OrdinaryMethod +-- Args : [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 (TInterface (Name {namespace = "GtkSource", name = "CompletionActivation"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_completion_context_get_activation" gtk_source_completion_context_get_activation :: + Ptr CompletionContext -> -- context : TInterface (Name {namespace = "GtkSource", name = "CompletionContext"}) + IO CUInt + +{- | +Get the context activation. +-} +completionContextGetActivation :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletionContext a) => + a + {- ^ /@context@/: a 'GI.GtkSource.Objects.CompletionContext.CompletionContext'. -} + -> m [GtkSource.Flags.CompletionActivation] + {- ^ __Returns:__ The context activation. -} +completionContextGetActivation context = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + result <- gtk_source_completion_context_get_activation context' + let result' = wordToGFlags result + touchManagedPtr context + return result' + +#if ENABLE_OVERLOADING +data CompletionContextGetActivationMethodInfo +instance (signature ~ (m [GtkSource.Flags.CompletionActivation]), MonadIO m, IsCompletionContext a) => O.MethodInfo CompletionContextGetActivationMethodInfo a signature where + overloadedMethod _ = completionContextGetActivation + +#endif + +-- method CompletionContext::get_iter +-- method type : OrdinaryMethod +-- Args : [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 = "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_context_get_iter" gtk_source_completion_context_get_iter :: + Ptr CompletionContext -> -- context : TInterface (Name {namespace = "GtkSource", name = "CompletionContext"}) + Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + IO CInt + +{- | +Get the iter at which the completion was invoked. Providers can use this +to determine how and if to match proposals. +-} +completionContextGetIter :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletionContext a) => + a + {- ^ /@context@/: a 'GI.GtkSource.Objects.CompletionContext.CompletionContext'. -} + -> m ((Bool, Gtk.TextIter.TextIter)) + {- ^ __Returns:__ 'True' if /@iter@/ is correctly set, 'False' otherwise. -} +completionContextGetIter context = liftIO $ do + context' <- unsafeManagedPtrCastPtr context + iter <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter) + result <- gtk_source_completion_context_get_iter context' iter + let result' = (/= 0) result + iter' <- (wrapBoxed Gtk.TextIter.TextIter) iter + touchManagedPtr context + return (result', iter') + +#if ENABLE_OVERLOADING +data CompletionContextGetIterMethodInfo +instance (signature ~ (m ((Bool, Gtk.TextIter.TextIter))), MonadIO m, IsCompletionContext a) => O.MethodInfo CompletionContextGetIterMethodInfo a signature where + overloadedMethod _ = completionContextGetIter + +#endif + + diff --git a/GI/GtkSource/Objects/CompletionContext.hs-boot b/GI/GtkSource/Objects/CompletionContext.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/CompletionContext.hs-boot @@ -0,0 +1,50 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.CompletionContext 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 CompletionContext = CompletionContext (ManagedPtr CompletionContext) +instance GObject CompletionContext where +class (GObject o, O.IsDescendantOf CompletionContext o) => IsCompletionContext o +instance (GObject o, O.IsDescendantOf CompletionContext o) => IsCompletionContext o +instance O.HasParentTypes CompletionContext +#if ENABLE_OVERLOADING +data CompletionContextActivationPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionContextCompletionPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionContextIterPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionContextCancelledSignalInfo +#endif +#if ENABLE_OVERLOADING +data CompletionContextAddProposalsMethodInfo +#endif +#if ENABLE_OVERLOADING +data CompletionContextGetActivationMethodInfo +#endif +#if ENABLE_OVERLOADING +data CompletionContextGetIterMethodInfo +#endif diff --git a/GI/GtkSource/Objects/CompletionInfo.hs b/GI/GtkSource/Objects/CompletionInfo.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/CompletionInfo.hs @@ -0,0 +1,819 @@ + + +{- | +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.CompletionInfo + ( + +-- * Exported types + CompletionInfo(..) , + IsCompletionInfo , + toCompletionInfo , + noCompletionInfo , + + + -- * Methods +-- ** getWidget #method:getWidget# + +#if ENABLE_OVERLOADING + CompletionInfoGetWidgetMethodInfo , +#endif + completionInfoGetWidget , + + +-- ** moveToIter #method:moveToIter# + +#if ENABLE_OVERLOADING + CompletionInfoMoveToIterMethodInfo , +#endif + completionInfoMoveToIter , + + +-- ** new #method:new# + + completionInfoNew , + + +-- ** setWidget #method:setWidget# + +#if ENABLE_OVERLOADING + CompletionInfoSetWidgetMethodInfo , +#endif + completionInfoSetWidget , + + + + + -- * Signals +-- ** beforeShow #signal:beforeShow# + + C_CompletionInfoBeforeShowCallback , + CompletionInfoBeforeShowCallback , +#if ENABLE_OVERLOADING + CompletionInfoBeforeShowSignalInfo , +#endif + afterCompletionInfoBeforeShow , + genClosure_CompletionInfoBeforeShow , + mk_CompletionInfoBeforeShowCallback , + noCompletionInfoBeforeShowCallback , + onCompletionInfoBeforeShow , + wrap_CompletionInfoBeforeShowCallback , + + + + + ) 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.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable +import qualified GI.Gtk.Objects.Bin as Gtk.Bin +import qualified GI.Gtk.Objects.Container as Gtk.Container +import qualified GI.Gtk.Objects.TextView as Gtk.TextView +import qualified GI.Gtk.Objects.Widget as Gtk.Widget +import qualified GI.Gtk.Objects.Window as Gtk.Window +import qualified GI.Gtk.Structs.TextIter as Gtk.TextIter + +-- | Memory-managed wrapper type. +newtype CompletionInfo = CompletionInfo (ManagedPtr CompletionInfo) +foreign import ccall "gtk_source_completion_info_get_type" + c_gtk_source_completion_info_get_type :: IO GType + +instance GObject CompletionInfo where + gobjectType = c_gtk_source_completion_info_get_type + + +-- | Type class for types which can be safely cast to `CompletionInfo`, for instance with `toCompletionInfo`. +class (GObject o, O.IsDescendantOf CompletionInfo o) => IsCompletionInfo o +instance (GObject o, O.IsDescendantOf CompletionInfo o) => IsCompletionInfo o + +instance O.HasParentTypes CompletionInfo +type instance O.ParentTypes CompletionInfo = '[Gtk.Window.Window, Gtk.Bin.Bin, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable] + +-- | Cast to `CompletionInfo`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toCompletionInfo :: (MonadIO m, IsCompletionInfo o) => o -> m CompletionInfo +toCompletionInfo = liftIO . unsafeCastTo CompletionInfo + +-- | A convenience alias for `Nothing` :: `Maybe` `CompletionInfo`. +noCompletionInfo :: Maybe CompletionInfo +noCompletionInfo = Nothing + +#if ENABLE_OVERLOADING +type family ResolveCompletionInfoMethod (t :: Symbol) (o :: *) :: * where + ResolveCompletionInfoMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo + ResolveCompletionInfoMethod "activateDefault" o = Gtk.Window.WindowActivateDefaultMethodInfo + ResolveCompletionInfoMethod "activateFocus" o = Gtk.Window.WindowActivateFocusMethodInfo + ResolveCompletionInfoMethod "activateKey" o = Gtk.Window.WindowActivateKeyMethodInfo + ResolveCompletionInfoMethod "add" o = Gtk.Container.ContainerAddMethodInfo + ResolveCompletionInfoMethod "addAccelGroup" o = Gtk.Window.WindowAddAccelGroupMethodInfo + ResolveCompletionInfoMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo + ResolveCompletionInfoMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo + ResolveCompletionInfoMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo + ResolveCompletionInfoMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo + ResolveCompletionInfoMethod "addMnemonic" o = Gtk.Window.WindowAddMnemonicMethodInfo + ResolveCompletionInfoMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo + ResolveCompletionInfoMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo + ResolveCompletionInfoMethod "beginMoveDrag" o = Gtk.Window.WindowBeginMoveDragMethodInfo + ResolveCompletionInfoMethod "beginResizeDrag" o = Gtk.Window.WindowBeginResizeDragMethodInfo + ResolveCompletionInfoMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveCompletionInfoMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveCompletionInfoMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo + ResolveCompletionInfoMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo + ResolveCompletionInfoMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo + ResolveCompletionInfoMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo + ResolveCompletionInfoMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo + ResolveCompletionInfoMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo + ResolveCompletionInfoMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo + ResolveCompletionInfoMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo + ResolveCompletionInfoMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo + ResolveCompletionInfoMethod "close" o = Gtk.Window.WindowCloseMethodInfo + ResolveCompletionInfoMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo + ResolveCompletionInfoMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo + ResolveCompletionInfoMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo + ResolveCompletionInfoMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo + ResolveCompletionInfoMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo + ResolveCompletionInfoMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo + ResolveCompletionInfoMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo + ResolveCompletionInfoMethod "deiconify" o = Gtk.Window.WindowDeiconifyMethodInfo + ResolveCompletionInfoMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo + ResolveCompletionInfoMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo + ResolveCompletionInfoMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo + ResolveCompletionInfoMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo + ResolveCompletionInfoMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo + ResolveCompletionInfoMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo + ResolveCompletionInfoMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo + ResolveCompletionInfoMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo + ResolveCompletionInfoMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo + ResolveCompletionInfoMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo + ResolveCompletionInfoMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo + ResolveCompletionInfoMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo + ResolveCompletionInfoMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo + ResolveCompletionInfoMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo + ResolveCompletionInfoMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo + ResolveCompletionInfoMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo + ResolveCompletionInfoMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo + ResolveCompletionInfoMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo + ResolveCompletionInfoMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo + ResolveCompletionInfoMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo + ResolveCompletionInfoMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo + ResolveCompletionInfoMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo + ResolveCompletionInfoMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo + ResolveCompletionInfoMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo + ResolveCompletionInfoMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo + ResolveCompletionInfoMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo + ResolveCompletionInfoMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo + ResolveCompletionInfoMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo + ResolveCompletionInfoMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo + ResolveCompletionInfoMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo + ResolveCompletionInfoMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo + ResolveCompletionInfoMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo + ResolveCompletionInfoMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo + ResolveCompletionInfoMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo + ResolveCompletionInfoMethod "event" o = Gtk.Widget.WidgetEventMethodInfo + ResolveCompletionInfoMethod "forall" o = Gtk.Container.ContainerForallMethodInfo + ResolveCompletionInfoMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveCompletionInfoMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo + ResolveCompletionInfoMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo + ResolveCompletionInfoMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveCompletionInfoMethod "fullscreen" o = Gtk.Window.WindowFullscreenMethodInfo + ResolveCompletionInfoMethod "fullscreenOnMonitor" o = Gtk.Window.WindowFullscreenOnMonitorMethodInfo + ResolveCompletionInfoMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveCompletionInfoMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo + ResolveCompletionInfoMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo + ResolveCompletionInfoMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo + ResolveCompletionInfoMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo + ResolveCompletionInfoMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo + ResolveCompletionInfoMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo + ResolveCompletionInfoMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo + ResolveCompletionInfoMethod "hasGroup" o = Gtk.Window.WindowHasGroupMethodInfo + ResolveCompletionInfoMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo + ResolveCompletionInfoMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo + ResolveCompletionInfoMethod "hasToplevelFocus" o = Gtk.Window.WindowHasToplevelFocusMethodInfo + ResolveCompletionInfoMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo + ResolveCompletionInfoMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo + ResolveCompletionInfoMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo + ResolveCompletionInfoMethod "iconify" o = Gtk.Window.WindowIconifyMethodInfo + ResolveCompletionInfoMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo + ResolveCompletionInfoMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo + ResolveCompletionInfoMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo + ResolveCompletionInfoMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo + ResolveCompletionInfoMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo + ResolveCompletionInfoMethod "isActive" o = Gtk.Window.WindowIsActiveMethodInfo + ResolveCompletionInfoMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo + ResolveCompletionInfoMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo + ResolveCompletionInfoMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo + ResolveCompletionInfoMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveCompletionInfoMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo + ResolveCompletionInfoMethod "isMaximized" o = Gtk.Window.WindowIsMaximizedMethodInfo + ResolveCompletionInfoMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo + ResolveCompletionInfoMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo + ResolveCompletionInfoMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo + ResolveCompletionInfoMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo + ResolveCompletionInfoMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo + ResolveCompletionInfoMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo + ResolveCompletionInfoMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo + ResolveCompletionInfoMethod "map" o = Gtk.Widget.WidgetMapMethodInfo + ResolveCompletionInfoMethod "maximize" o = Gtk.Window.WindowMaximizeMethodInfo + ResolveCompletionInfoMethod "mnemonicActivate" o = Gtk.Window.WindowMnemonicActivateMethodInfo + ResolveCompletionInfoMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo + ResolveCompletionInfoMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo + ResolveCompletionInfoMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo + ResolveCompletionInfoMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo + ResolveCompletionInfoMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo + ResolveCompletionInfoMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo + ResolveCompletionInfoMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo + ResolveCompletionInfoMethod "move" o = Gtk.Window.WindowMoveMethodInfo + ResolveCompletionInfoMethod "moveToIter" o = CompletionInfoMoveToIterMethodInfo + ResolveCompletionInfoMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveCompletionInfoMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveCompletionInfoMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo + ResolveCompletionInfoMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo + ResolveCompletionInfoMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo + ResolveCompletionInfoMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo + ResolveCompletionInfoMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo + ResolveCompletionInfoMethod "parseGeometry" o = Gtk.Window.WindowParseGeometryMethodInfo + ResolveCompletionInfoMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo + ResolveCompletionInfoMethod "path" o = Gtk.Widget.WidgetPathMethodInfo + ResolveCompletionInfoMethod "present" o = Gtk.Window.WindowPresentMethodInfo + ResolveCompletionInfoMethod "presentWithTime" o = Gtk.Window.WindowPresentWithTimeMethodInfo + ResolveCompletionInfoMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo + ResolveCompletionInfoMethod "propagateKeyEvent" o = Gtk.Window.WindowPropagateKeyEventMethodInfo + ResolveCompletionInfoMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo + ResolveCompletionInfoMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo + ResolveCompletionInfoMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo + ResolveCompletionInfoMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo + ResolveCompletionInfoMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo + ResolveCompletionInfoMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo + ResolveCompletionInfoMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo + ResolveCompletionInfoMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo + ResolveCompletionInfoMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveCompletionInfoMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveCompletionInfoMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo + ResolveCompletionInfoMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo + ResolveCompletionInfoMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo + ResolveCompletionInfoMethod "removeAccelGroup" o = Gtk.Window.WindowRemoveAccelGroupMethodInfo + ResolveCompletionInfoMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo + ResolveCompletionInfoMethod "removeMnemonic" o = Gtk.Window.WindowRemoveMnemonicMethodInfo + ResolveCompletionInfoMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo + ResolveCompletionInfoMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo + ResolveCompletionInfoMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo + ResolveCompletionInfoMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo + ResolveCompletionInfoMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo + ResolveCompletionInfoMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo + ResolveCompletionInfoMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo + ResolveCompletionInfoMethod "reshowWithInitialSize" o = Gtk.Window.WindowReshowWithInitialSizeMethodInfo + ResolveCompletionInfoMethod "resize" o = Gtk.Window.WindowResizeMethodInfo + ResolveCompletionInfoMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo + ResolveCompletionInfoMethod "resizeGripIsVisible" o = Gtk.Window.WindowResizeGripIsVisibleMethodInfo + ResolveCompletionInfoMethod "resizeToGeometry" o = Gtk.Window.WindowResizeToGeometryMethodInfo + ResolveCompletionInfoMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveCompletionInfoMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo + ResolveCompletionInfoMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo + ResolveCompletionInfoMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo + ResolveCompletionInfoMethod "show" o = Gtk.Widget.WidgetShowMethodInfo + ResolveCompletionInfoMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo + ResolveCompletionInfoMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo + ResolveCompletionInfoMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo + ResolveCompletionInfoMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo + ResolveCompletionInfoMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo + ResolveCompletionInfoMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveCompletionInfoMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveCompletionInfoMethod "stick" o = Gtk.Window.WindowStickMethodInfo + ResolveCompletionInfoMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo + ResolveCompletionInfoMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo + ResolveCompletionInfoMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo + ResolveCompletionInfoMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveCompletionInfoMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo + ResolveCompletionInfoMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo + ResolveCompletionInfoMethod "unfullscreen" o = Gtk.Window.WindowUnfullscreenMethodInfo + ResolveCompletionInfoMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo + ResolveCompletionInfoMethod "unmaximize" o = Gtk.Window.WindowUnmaximizeMethodInfo + ResolveCompletionInfoMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo + ResolveCompletionInfoMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo + ResolveCompletionInfoMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveCompletionInfoMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo + ResolveCompletionInfoMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo + ResolveCompletionInfoMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo + ResolveCompletionInfoMethod "unstick" o = Gtk.Window.WindowUnstickMethodInfo + ResolveCompletionInfoMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveCompletionInfoMethod "getAcceptFocus" o = Gtk.Window.WindowGetAcceptFocusMethodInfo + ResolveCompletionInfoMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo + ResolveCompletionInfoMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo + ResolveCompletionInfoMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo + ResolveCompletionInfoMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo + ResolveCompletionInfoMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo + ResolveCompletionInfoMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo + ResolveCompletionInfoMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo + ResolveCompletionInfoMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo + ResolveCompletionInfoMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo + ResolveCompletionInfoMethod "getApplication" o = Gtk.Window.WindowGetApplicationMethodInfo + ResolveCompletionInfoMethod "getAttachedTo" o = Gtk.Window.WindowGetAttachedToMethodInfo + ResolveCompletionInfoMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo + ResolveCompletionInfoMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo + ResolveCompletionInfoMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo + ResolveCompletionInfoMethod "getChild" o = Gtk.Bin.BinGetChildMethodInfo + ResolveCompletionInfoMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo + ResolveCompletionInfoMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo + ResolveCompletionInfoMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo + ResolveCompletionInfoMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo + ResolveCompletionInfoMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo + ResolveCompletionInfoMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo + ResolveCompletionInfoMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveCompletionInfoMethod "getDecorated" o = Gtk.Window.WindowGetDecoratedMethodInfo + ResolveCompletionInfoMethod "getDefaultSize" o = Gtk.Window.WindowGetDefaultSizeMethodInfo + ResolveCompletionInfoMethod "getDefaultWidget" o = Gtk.Window.WindowGetDefaultWidgetMethodInfo + ResolveCompletionInfoMethod "getDeletable" o = Gtk.Window.WindowGetDeletableMethodInfo + ResolveCompletionInfoMethod "getDestroyWithParent" o = Gtk.Window.WindowGetDestroyWithParentMethodInfo + ResolveCompletionInfoMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo + ResolveCompletionInfoMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo + ResolveCompletionInfoMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo + ResolveCompletionInfoMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo + ResolveCompletionInfoMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo + ResolveCompletionInfoMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo + ResolveCompletionInfoMethod "getFocus" o = Gtk.Window.WindowGetFocusMethodInfo + ResolveCompletionInfoMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo + ResolveCompletionInfoMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo + ResolveCompletionInfoMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo + ResolveCompletionInfoMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo + ResolveCompletionInfoMethod "getFocusOnMap" o = Gtk.Window.WindowGetFocusOnMapMethodInfo + ResolveCompletionInfoMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo + ResolveCompletionInfoMethod "getFocusVisible" o = Gtk.Window.WindowGetFocusVisibleMethodInfo + ResolveCompletionInfoMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo + ResolveCompletionInfoMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo + ResolveCompletionInfoMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo + ResolveCompletionInfoMethod "getGravity" o = Gtk.Window.WindowGetGravityMethodInfo + ResolveCompletionInfoMethod "getGroup" o = Gtk.Window.WindowGetGroupMethodInfo + ResolveCompletionInfoMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo + ResolveCompletionInfoMethod "getHasResizeGrip" o = Gtk.Window.WindowGetHasResizeGripMethodInfo + ResolveCompletionInfoMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo + ResolveCompletionInfoMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo + ResolveCompletionInfoMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo + ResolveCompletionInfoMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo + ResolveCompletionInfoMethod "getHideTitlebarWhenMaximized" o = Gtk.Window.WindowGetHideTitlebarWhenMaximizedMethodInfo + ResolveCompletionInfoMethod "getIcon" o = Gtk.Window.WindowGetIconMethodInfo + ResolveCompletionInfoMethod "getIconList" o = Gtk.Window.WindowGetIconListMethodInfo + ResolveCompletionInfoMethod "getIconName" o = Gtk.Window.WindowGetIconNameMethodInfo + ResolveCompletionInfoMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo + ResolveCompletionInfoMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo + ResolveCompletionInfoMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo + ResolveCompletionInfoMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo + ResolveCompletionInfoMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo + ResolveCompletionInfoMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo + ResolveCompletionInfoMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo + ResolveCompletionInfoMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo + ResolveCompletionInfoMethod "getMnemonicModifier" o = Gtk.Window.WindowGetMnemonicModifierMethodInfo + ResolveCompletionInfoMethod "getMnemonicsVisible" o = Gtk.Window.WindowGetMnemonicsVisibleMethodInfo + ResolveCompletionInfoMethod "getModal" o = Gtk.Window.WindowGetModalMethodInfo + ResolveCompletionInfoMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo + ResolveCompletionInfoMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo + ResolveCompletionInfoMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo + ResolveCompletionInfoMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo + ResolveCompletionInfoMethod "getOpacity" o = Gtk.Window.WindowGetOpacityMethodInfo + ResolveCompletionInfoMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo + ResolveCompletionInfoMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo + ResolveCompletionInfoMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo + ResolveCompletionInfoMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo + ResolveCompletionInfoMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo + ResolveCompletionInfoMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo + ResolveCompletionInfoMethod "getPosition" o = Gtk.Window.WindowGetPositionMethodInfo + ResolveCompletionInfoMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo + ResolveCompletionInfoMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo + ResolveCompletionInfoMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo + ResolveCompletionInfoMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo + ResolveCompletionInfoMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo + ResolveCompletionInfoMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo + ResolveCompletionInfoMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveCompletionInfoMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveCompletionInfoMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo + ResolveCompletionInfoMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo + ResolveCompletionInfoMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo + ResolveCompletionInfoMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo + ResolveCompletionInfoMethod "getResizable" o = Gtk.Window.WindowGetResizableMethodInfo + ResolveCompletionInfoMethod "getResizeGripArea" o = Gtk.Window.WindowGetResizeGripAreaMethodInfo + ResolveCompletionInfoMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo + ResolveCompletionInfoMethod "getRole" o = Gtk.Window.WindowGetRoleMethodInfo + ResolveCompletionInfoMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo + ResolveCompletionInfoMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo + ResolveCompletionInfoMethod "getScreen" o = Gtk.Window.WindowGetScreenMethodInfo + ResolveCompletionInfoMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo + ResolveCompletionInfoMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo + ResolveCompletionInfoMethod "getSize" o = Gtk.Window.WindowGetSizeMethodInfo + ResolveCompletionInfoMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo + ResolveCompletionInfoMethod "getSkipPagerHint" o = Gtk.Window.WindowGetSkipPagerHintMethodInfo + ResolveCompletionInfoMethod "getSkipTaskbarHint" o = Gtk.Window.WindowGetSkipTaskbarHintMethodInfo + ResolveCompletionInfoMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo + ResolveCompletionInfoMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo + ResolveCompletionInfoMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo + ResolveCompletionInfoMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo + ResolveCompletionInfoMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo + ResolveCompletionInfoMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo + ResolveCompletionInfoMethod "getTitle" o = Gtk.Window.WindowGetTitleMethodInfo + ResolveCompletionInfoMethod "getTitlebar" o = Gtk.Window.WindowGetTitlebarMethodInfo + ResolveCompletionInfoMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo + ResolveCompletionInfoMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo + ResolveCompletionInfoMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo + ResolveCompletionInfoMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo + ResolveCompletionInfoMethod "getTransientFor" o = Gtk.Window.WindowGetTransientForMethodInfo + ResolveCompletionInfoMethod "getTypeHint" o = Gtk.Window.WindowGetTypeHintMethodInfo + ResolveCompletionInfoMethod "getUrgencyHint" o = Gtk.Window.WindowGetUrgencyHintMethodInfo + ResolveCompletionInfoMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo + ResolveCompletionInfoMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo + ResolveCompletionInfoMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo + ResolveCompletionInfoMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo + ResolveCompletionInfoMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo + ResolveCompletionInfoMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo + ResolveCompletionInfoMethod "getWidget" o = CompletionInfoGetWidgetMethodInfo + ResolveCompletionInfoMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo + ResolveCompletionInfoMethod "getWindowType" o = Gtk.Window.WindowGetWindowTypeMethodInfo + ResolveCompletionInfoMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo + ResolveCompletionInfoMethod "setAcceptFocus" o = Gtk.Window.WindowSetAcceptFocusMethodInfo + ResolveCompletionInfoMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo + ResolveCompletionInfoMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo + ResolveCompletionInfoMethod "setApplication" o = Gtk.Window.WindowSetApplicationMethodInfo + ResolveCompletionInfoMethod "setAttachedTo" o = Gtk.Window.WindowSetAttachedToMethodInfo + ResolveCompletionInfoMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo + ResolveCompletionInfoMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo + ResolveCompletionInfoMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo + ResolveCompletionInfoMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo + ResolveCompletionInfoMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo + ResolveCompletionInfoMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo + ResolveCompletionInfoMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo + ResolveCompletionInfoMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveCompletionInfoMethod "setDecorated" o = Gtk.Window.WindowSetDecoratedMethodInfo + ResolveCompletionInfoMethod "setDefault" o = Gtk.Window.WindowSetDefaultMethodInfo + ResolveCompletionInfoMethod "setDefaultGeometry" o = Gtk.Window.WindowSetDefaultGeometryMethodInfo + ResolveCompletionInfoMethod "setDefaultSize" o = Gtk.Window.WindowSetDefaultSizeMethodInfo + ResolveCompletionInfoMethod "setDeletable" o = Gtk.Window.WindowSetDeletableMethodInfo + ResolveCompletionInfoMethod "setDestroyWithParent" o = Gtk.Window.WindowSetDestroyWithParentMethodInfo + ResolveCompletionInfoMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo + ResolveCompletionInfoMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo + ResolveCompletionInfoMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo + ResolveCompletionInfoMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo + ResolveCompletionInfoMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo + ResolveCompletionInfoMethod "setFocus" o = Gtk.Window.WindowSetFocusMethodInfo + ResolveCompletionInfoMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo + ResolveCompletionInfoMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo + ResolveCompletionInfoMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo + ResolveCompletionInfoMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo + ResolveCompletionInfoMethod "setFocusOnMap" o = Gtk.Window.WindowSetFocusOnMapMethodInfo + ResolveCompletionInfoMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo + ResolveCompletionInfoMethod "setFocusVisible" o = Gtk.Window.WindowSetFocusVisibleMethodInfo + ResolveCompletionInfoMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo + ResolveCompletionInfoMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo + ResolveCompletionInfoMethod "setGeometryHints" o = Gtk.Window.WindowSetGeometryHintsMethodInfo + ResolveCompletionInfoMethod "setGravity" o = Gtk.Window.WindowSetGravityMethodInfo + ResolveCompletionInfoMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo + ResolveCompletionInfoMethod "setHasResizeGrip" o = Gtk.Window.WindowSetHasResizeGripMethodInfo + ResolveCompletionInfoMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo + ResolveCompletionInfoMethod "setHasUserRefCount" o = Gtk.Window.WindowSetHasUserRefCountMethodInfo + ResolveCompletionInfoMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo + ResolveCompletionInfoMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo + ResolveCompletionInfoMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo + ResolveCompletionInfoMethod "setHideTitlebarWhenMaximized" o = Gtk.Window.WindowSetHideTitlebarWhenMaximizedMethodInfo + ResolveCompletionInfoMethod "setIcon" o = Gtk.Window.WindowSetIconMethodInfo + ResolveCompletionInfoMethod "setIconFromFile" o = Gtk.Window.WindowSetIconFromFileMethodInfo + ResolveCompletionInfoMethod "setIconList" o = Gtk.Window.WindowSetIconListMethodInfo + ResolveCompletionInfoMethod "setIconName" o = Gtk.Window.WindowSetIconNameMethodInfo + ResolveCompletionInfoMethod "setKeepAbove" o = Gtk.Window.WindowSetKeepAboveMethodInfo + ResolveCompletionInfoMethod "setKeepBelow" o = Gtk.Window.WindowSetKeepBelowMethodInfo + ResolveCompletionInfoMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo + ResolveCompletionInfoMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo + ResolveCompletionInfoMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo + ResolveCompletionInfoMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo + ResolveCompletionInfoMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo + ResolveCompletionInfoMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo + ResolveCompletionInfoMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo + ResolveCompletionInfoMethod "setMnemonicModifier" o = Gtk.Window.WindowSetMnemonicModifierMethodInfo + ResolveCompletionInfoMethod "setMnemonicsVisible" o = Gtk.Window.WindowSetMnemonicsVisibleMethodInfo + ResolveCompletionInfoMethod "setModal" o = Gtk.Window.WindowSetModalMethodInfo + ResolveCompletionInfoMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo + ResolveCompletionInfoMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo + ResolveCompletionInfoMethod "setOpacity" o = Gtk.Window.WindowSetOpacityMethodInfo + ResolveCompletionInfoMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo + ResolveCompletionInfoMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo + ResolveCompletionInfoMethod "setPosition" o = Gtk.Window.WindowSetPositionMethodInfo + ResolveCompletionInfoMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveCompletionInfoMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo + ResolveCompletionInfoMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo + ResolveCompletionInfoMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo + ResolveCompletionInfoMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo + ResolveCompletionInfoMethod "setResizable" o = Gtk.Window.WindowSetResizableMethodInfo + ResolveCompletionInfoMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo + ResolveCompletionInfoMethod "setRole" o = Gtk.Window.WindowSetRoleMethodInfo + ResolveCompletionInfoMethod "setScreen" o = Gtk.Window.WindowSetScreenMethodInfo + ResolveCompletionInfoMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo + ResolveCompletionInfoMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo + ResolveCompletionInfoMethod "setSkipPagerHint" o = Gtk.Window.WindowSetSkipPagerHintMethodInfo + ResolveCompletionInfoMethod "setSkipTaskbarHint" o = Gtk.Window.WindowSetSkipTaskbarHintMethodInfo + ResolveCompletionInfoMethod "setStartupId" o = Gtk.Window.WindowSetStartupIdMethodInfo + ResolveCompletionInfoMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo + ResolveCompletionInfoMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo + ResolveCompletionInfoMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo + ResolveCompletionInfoMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo + ResolveCompletionInfoMethod "setTitle" o = Gtk.Window.WindowSetTitleMethodInfo + ResolveCompletionInfoMethod "setTitlebar" o = Gtk.Window.WindowSetTitlebarMethodInfo + ResolveCompletionInfoMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo + ResolveCompletionInfoMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo + ResolveCompletionInfoMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo + ResolveCompletionInfoMethod "setTransientFor" o = Gtk.Window.WindowSetTransientForMethodInfo + ResolveCompletionInfoMethod "setTypeHint" o = Gtk.Window.WindowSetTypeHintMethodInfo + ResolveCompletionInfoMethod "setUrgencyHint" o = Gtk.Window.WindowSetUrgencyHintMethodInfo + ResolveCompletionInfoMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo + ResolveCompletionInfoMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo + ResolveCompletionInfoMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo + ResolveCompletionInfoMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo + ResolveCompletionInfoMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo + ResolveCompletionInfoMethod "setWidget" o = CompletionInfoSetWidgetMethodInfo + ResolveCompletionInfoMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo + ResolveCompletionInfoMethod "setWmclass" o = Gtk.Window.WindowSetWmclassMethodInfo + ResolveCompletionInfoMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveCompletionInfoMethod t CompletionInfo, O.MethodInfo info CompletionInfo p) => OL.IsLabel t (CompletionInfo -> 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 CompletionInfo::before-show +{-# DEPRECATED CompletionInfoBeforeShowCallback ["(Since version 3.10)","This signal should not be used."] #-} +{- | +This signal is emitted before any \"show\" management. You can connect +to this signal if you want to change some properties or position +before the real \"show\". +-} +type CompletionInfoBeforeShowCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `CompletionInfoBeforeShowCallback`@. +noCompletionInfoBeforeShowCallback :: Maybe CompletionInfoBeforeShowCallback +noCompletionInfoBeforeShowCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_CompletionInfoBeforeShowCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_CompletionInfoBeforeShowCallback`. +foreign import ccall "wrapper" + mk_CompletionInfoBeforeShowCallback :: C_CompletionInfoBeforeShowCallback -> IO (FunPtr C_CompletionInfoBeforeShowCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_CompletionInfoBeforeShow :: MonadIO m => CompletionInfoBeforeShowCallback -> m (GClosure C_CompletionInfoBeforeShowCallback) +genClosure_CompletionInfoBeforeShow cb = liftIO $ do + let cb' = wrap_CompletionInfoBeforeShowCallback cb + mk_CompletionInfoBeforeShowCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `CompletionInfoBeforeShowCallback` into a `C_CompletionInfoBeforeShowCallback`. +wrap_CompletionInfoBeforeShowCallback :: + CompletionInfoBeforeShowCallback -> + C_CompletionInfoBeforeShowCallback +wrap_CompletionInfoBeforeShowCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@before-show@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' completionInfo #beforeShow callback +@ +-} +onCompletionInfoBeforeShow :: (IsCompletionInfo a, MonadIO m) => a -> CompletionInfoBeforeShowCallback -> m SignalHandlerId +onCompletionInfoBeforeShow obj cb = liftIO $ do + let cb' = wrap_CompletionInfoBeforeShowCallback cb + cb'' <- mk_CompletionInfoBeforeShowCallback cb' + connectSignalFunPtr obj "before-show" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@before-show@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' completionInfo #beforeShow callback +@ +-} +afterCompletionInfoBeforeShow :: (IsCompletionInfo a, MonadIO m) => a -> CompletionInfoBeforeShowCallback -> m SignalHandlerId +afterCompletionInfoBeforeShow obj cb = liftIO $ do + let cb' = wrap_CompletionInfoBeforeShowCallback cb + cb'' <- mk_CompletionInfoBeforeShowCallback cb' + connectSignalFunPtr obj "before-show" cb'' SignalConnectAfter + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList CompletionInfo +type instance O.AttributeList CompletionInfo = CompletionInfoAttributeList +type CompletionInfoAttributeList = ('[ '("acceptFocus", Gtk.Window.WindowAcceptFocusPropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("application", Gtk.Window.WindowApplicationPropertyInfo), '("attachedTo", Gtk.Window.WindowAttachedToPropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("decorated", Gtk.Window.WindowDecoratedPropertyInfo), '("defaultHeight", Gtk.Window.WindowDefaultHeightPropertyInfo), '("defaultWidth", Gtk.Window.WindowDefaultWidthPropertyInfo), '("deletable", Gtk.Window.WindowDeletablePropertyInfo), '("destroyWithParent", Gtk.Window.WindowDestroyWithParentPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusOnMap", Gtk.Window.WindowFocusOnMapPropertyInfo), '("focusVisible", Gtk.Window.WindowFocusVisiblePropertyInfo), '("gravity", Gtk.Window.WindowGravityPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasResizeGrip", Gtk.Window.WindowHasResizeGripPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("hasToplevelFocus", Gtk.Window.WindowHasToplevelFocusPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("hideTitlebarWhenMaximized", Gtk.Window.WindowHideTitlebarWhenMaximizedPropertyInfo), '("icon", Gtk.Window.WindowIconPropertyInfo), '("iconName", Gtk.Window.WindowIconNamePropertyInfo), '("isActive", Gtk.Window.WindowIsActivePropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("isMaximized", Gtk.Window.WindowIsMaximizedPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("mnemonicsVisible", Gtk.Window.WindowMnemonicsVisiblePropertyInfo), '("modal", Gtk.Window.WindowModalPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizable", Gtk.Window.WindowResizablePropertyInfo), '("resizeGripVisible", Gtk.Window.WindowResizeGripVisiblePropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("role", Gtk.Window.WindowRolePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("screen", Gtk.Window.WindowScreenPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("skipPagerHint", Gtk.Window.WindowSkipPagerHintPropertyInfo), '("skipTaskbarHint", Gtk.Window.WindowSkipTaskbarHintPropertyInfo), '("startupId", Gtk.Window.WindowStartupIdPropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("title", Gtk.Window.WindowTitlePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("transientFor", Gtk.Window.WindowTransientForPropertyInfo), '("type", Gtk.Window.WindowTypePropertyInfo), '("typeHint", Gtk.Window.WindowTypeHintPropertyInfo), '("urgencyHint", Gtk.Window.WindowUrgencyHintPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo), '("windowPosition", Gtk.Window.WindowWindowPositionPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +data CompletionInfoBeforeShowSignalInfo +instance SignalInfo CompletionInfoBeforeShowSignalInfo where + type HaskellCallbackType CompletionInfoBeforeShowSignalInfo = CompletionInfoBeforeShowCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_CompletionInfoBeforeShowCallback cb + cb'' <- mk_CompletionInfoBeforeShowCallback cb' + connectSignalFunPtr obj "before-show" cb'' connectMode + +type instance O.SignalList CompletionInfo = CompletionInfoSignalList +type CompletionInfoSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("activateDefault", Gtk.Window.WindowActivateDefaultSignalInfo), '("activateFocus", Gtk.Window.WindowActivateFocusSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("beforeShow", CompletionInfoBeforeShowSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("enableDebugging", Gtk.Window.WindowEnableDebuggingSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("keysChanged", Gtk.Window.WindowKeysChangedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("remove", Gtk.Container.ContainerRemoveSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("setFocus", Gtk.Window.WindowSetFocusSignalInfo), '("setFocusChild", Gtk.Container.ContainerSetFocusChildSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method CompletionInfo::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "CompletionInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_completion_info_new" gtk_source_completion_info_new :: + IO (Ptr CompletionInfo) + +{- | +/No description available in the introspection data./ +-} +completionInfoNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m CompletionInfo + {- ^ __Returns:__ a new GtkSourceCompletionInfo. -} +completionInfoNew = liftIO $ do + result <- gtk_source_completion_info_new + checkUnexpectedReturnNULL "completionInfoNew" result + result' <- (newObject CompletionInfo) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method CompletionInfo::get_widget +-- method type : OrdinaryMethod +-- Args : [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 : Just (TInterface (Name {namespace = "Gtk", name = "Widget"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_completion_info_get_widget" gtk_source_completion_info_get_widget :: + Ptr CompletionInfo -> -- info : TInterface (Name {namespace = "GtkSource", name = "CompletionInfo"}) + IO (Ptr Gtk.Widget.Widget) + +{-# DEPRECATED completionInfoGetWidget ["(Since version 3.8)","Use 'GI.Gtk.Objects.Bin.binGetChild' instead."] #-} +{- | +Get the current content widget. +-} +completionInfoGetWidget :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletionInfo a) => + a + {- ^ /@info@/: a 'GI.GtkSource.Objects.CompletionInfo.CompletionInfo'. -} + -> m Gtk.Widget.Widget + {- ^ __Returns:__ The current content widget. -} +completionInfoGetWidget info = liftIO $ do + info' <- unsafeManagedPtrCastPtr info + result <- gtk_source_completion_info_get_widget info' + checkUnexpectedReturnNULL "completionInfoGetWidget" result + result' <- (newObject Gtk.Widget.Widget) result + touchManagedPtr info + return result' + +#if ENABLE_OVERLOADING +data CompletionInfoGetWidgetMethodInfo +instance (signature ~ (m Gtk.Widget.Widget), MonadIO m, IsCompletionInfo a) => O.MethodInfo CompletionInfoGetWidgetMethodInfo a signature where + overloadedMethod _ = completionInfoGetWidget + +#endif + +-- method CompletionInfo::move_to_iter +-- method type : OrdinaryMethod +-- Args : [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},Arg {argCName = "view", argType = TInterface (Name {namespace = "Gtk", name = "TextView"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextView on which the info window should be positioned.", 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 = True, 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_completion_info_move_to_iter" gtk_source_completion_info_move_to_iter :: + Ptr CompletionInfo -> -- info : TInterface (Name {namespace = "GtkSource", name = "CompletionInfo"}) + Ptr Gtk.TextView.TextView -> -- view : TInterface (Name {namespace = "Gtk", name = "TextView"}) + Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + IO () + +{- | +Moves the 'GI.GtkSource.Objects.CompletionInfo.CompletionInfo' to /@iter@/. If /@iter@/ is 'Nothing' /@info@/ is +moved to the cursor position. Moving will respect the 'GI.Gdk.Enums.Gravity' setting +of the info window and will ensure the line at /@iter@/ is not occluded by +the window. +-} +completionInfoMoveToIter :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletionInfo a, Gtk.TextView.IsTextView b) => + a + {- ^ /@info@/: a 'GI.GtkSource.Objects.CompletionInfo.CompletionInfo'. -} + -> b + {- ^ /@view@/: a 'GI.Gtk.Objects.TextView.TextView' on which the info window should be positioned. -} + -> Maybe (Gtk.TextIter.TextIter) + {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} + -> m () +completionInfoMoveToIter info view iter = liftIO $ do + info' <- unsafeManagedPtrCastPtr info + view' <- unsafeManagedPtrCastPtr view + maybeIter <- case iter of + Nothing -> return nullPtr + Just jIter -> do + jIter' <- unsafeManagedPtrGetPtr jIter + return jIter' + gtk_source_completion_info_move_to_iter info' view' maybeIter + touchManagedPtr info + touchManagedPtr view + whenJust iter touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data CompletionInfoMoveToIterMethodInfo +instance (signature ~ (b -> Maybe (Gtk.TextIter.TextIter) -> m ()), MonadIO m, IsCompletionInfo a, Gtk.TextView.IsTextView b) => O.MethodInfo CompletionInfoMoveToIterMethodInfo a signature where + overloadedMethod _ = completionInfoMoveToIter + +#endif + +-- method CompletionInfo::set_widget +-- method type : OrdinaryMethod +-- Args : [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},Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkWidget.", 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_info_set_widget" gtk_source_completion_info_set_widget :: + Ptr CompletionInfo -> -- info : TInterface (Name {namespace = "GtkSource", name = "CompletionInfo"}) + Ptr Gtk.Widget.Widget -> -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"}) + IO () + +{-# DEPRECATED completionInfoSetWidget ["(Since version 3.8)","Use 'GI.Gtk.Objects.Container.containerAdd' instead. If there is already a child","widget, remove it with 'GI.Gtk.Objects.Container.containerRemove'."] #-} +{- | +Sets the content widget of the info window. See that the previous widget will +lose a reference and it can be destroyed, so if you do not want this to +happen you must use 'GI.GObject.Objects.Object.objectRef' before calling this method. +-} +completionInfoSetWidget :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletionInfo a, Gtk.Widget.IsWidget b) => + a + {- ^ /@info@/: a 'GI.GtkSource.Objects.CompletionInfo.CompletionInfo'. -} + -> Maybe (b) + {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget'. -} + -> m () +completionInfoSetWidget info widget = liftIO $ do + info' <- unsafeManagedPtrCastPtr info + maybeWidget <- case widget of + Nothing -> return nullPtr + Just jWidget -> do + jWidget' <- unsafeManagedPtrCastPtr jWidget + return jWidget' + gtk_source_completion_info_set_widget info' maybeWidget + touchManagedPtr info + whenJust widget touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data CompletionInfoSetWidgetMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsCompletionInfo a, Gtk.Widget.IsWidget b) => O.MethodInfo CompletionInfoSetWidgetMethodInfo a signature where + overloadedMethod _ = completionInfoSetWidget + +#endif + + diff --git a/GI/GtkSource/Objects/CompletionInfo.hs-boot b/GI/GtkSource/Objects/CompletionInfo.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/CompletionInfo.hs-boot @@ -0,0 +1,41 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.CompletionInfo 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 CompletionInfo = CompletionInfo (ManagedPtr CompletionInfo) +instance GObject CompletionInfo where +class (GObject o, O.IsDescendantOf CompletionInfo o) => IsCompletionInfo o +instance (GObject o, O.IsDescendantOf CompletionInfo o) => IsCompletionInfo o +instance O.HasParentTypes CompletionInfo +#if ENABLE_OVERLOADING +data CompletionInfoBeforeShowSignalInfo +#endif +#if ENABLE_OVERLOADING +data CompletionInfoGetWidgetMethodInfo +#endif +#if ENABLE_OVERLOADING +data CompletionInfoMoveToIterMethodInfo +#endif +#if ENABLE_OVERLOADING +data CompletionInfoSetWidgetMethodInfo +#endif diff --git a/GI/GtkSource/Objects/CompletionItem.hs b/GI/GtkSource/Objects/CompletionItem.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/CompletionItem.hs @@ -0,0 +1,1277 @@ + + +{- | +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.CompletionItem + ( + +-- * Exported types + CompletionItem(..) , + IsCompletionItem , + toCompletionItem , + noCompletionItem , + + + -- * Methods +-- ** new #method:new# + + completionItemNew , + + +-- ** new2 #method:new2# + + completionItemNew2 , + + +-- ** newFromStock #method:newFromStock# + + completionItemNewFromStock , + + +-- ** newWithMarkup #method:newWithMarkup# + + completionItemNewWithMarkup , + + +-- ** setGicon #method:setGicon# + +#if ENABLE_OVERLOADING + CompletionItemSetGiconMethodInfo , +#endif + completionItemSetGicon , + + +-- ** setIcon #method:setIcon# + +#if ENABLE_OVERLOADING + CompletionItemSetIconMethodInfo , +#endif + completionItemSetIcon , + + +-- ** setIconName #method:setIconName# + +#if ENABLE_OVERLOADING + CompletionItemSetIconNameMethodInfo , +#endif + completionItemSetIconName , + + +-- ** setInfo #method:setInfo# + +#if ENABLE_OVERLOADING + CompletionItemSetInfoMethodInfo , +#endif + completionItemSetInfo , + + +-- ** setLabel #method:setLabel# + +#if ENABLE_OVERLOADING + CompletionItemSetLabelMethodInfo , +#endif + completionItemSetLabel , + + +-- ** setMarkup #method:setMarkup# + +#if ENABLE_OVERLOADING + CompletionItemSetMarkupMethodInfo , +#endif + completionItemSetMarkup , + + +-- ** setText #method:setText# + +#if ENABLE_OVERLOADING + CompletionItemSetTextMethodInfo , +#endif + completionItemSetText , + + + + + -- * Properties +-- ** gicon #attr:gicon# +{- | The 'GI.Gio.Interfaces.Icon.Icon' for the icon to be shown for this proposal. + +/Since: 3.18/ +-} +#if ENABLE_OVERLOADING + CompletionItemGiconPropertyInfo , +#endif + clearCompletionItemGicon , +#if ENABLE_OVERLOADING + completionItemGicon , +#endif + constructCompletionItemGicon , + getCompletionItemGicon , + setCompletionItemGicon , + + +-- ** icon #attr:icon# +{- | The 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' for the icon to be shown for this proposal. +-} +#if ENABLE_OVERLOADING + CompletionItemIconPropertyInfo , +#endif + clearCompletionItemIcon , +#if ENABLE_OVERLOADING + completionItemIcon , +#endif + constructCompletionItemIcon , + getCompletionItemIcon , + setCompletionItemIcon , + + +-- ** iconName #attr:iconName# +{- | The icon name for the icon to be shown for this proposal. + +/Since: 3.18/ +-} +#if ENABLE_OVERLOADING + CompletionItemIconNamePropertyInfo , +#endif + clearCompletionItemIconName , +#if ENABLE_OVERLOADING + completionItemIconName , +#endif + constructCompletionItemIconName , + getCompletionItemIconName , + setCompletionItemIconName , + + +-- ** info #attr:info# +{- | Optional extra information to be shown for this proposal. +-} +#if ENABLE_OVERLOADING + CompletionItemInfoPropertyInfo , +#endif + clearCompletionItemInfo , +#if ENABLE_OVERLOADING + completionItemInfo , +#endif + constructCompletionItemInfo , + getCompletionItemInfo , + setCompletionItemInfo , + + +-- ** label #attr:label# +{- | Label to be shown for this proposal. +-} +#if ENABLE_OVERLOADING + CompletionItemLabelPropertyInfo , +#endif + clearCompletionItemLabel , +#if ENABLE_OVERLOADING + completionItemLabel , +#endif + constructCompletionItemLabel , + getCompletionItemLabel , + setCompletionItemLabel , + + +-- ** markup #attr:markup# +{- | Label with markup to be shown for this proposal. +-} +#if ENABLE_OVERLOADING + CompletionItemMarkupPropertyInfo , +#endif + clearCompletionItemMarkup , +#if ENABLE_OVERLOADING + completionItemMarkup , +#endif + constructCompletionItemMarkup , + getCompletionItemMarkup , + setCompletionItemMarkup , + + +-- ** text #attr:text# +{- | Proposal text. +-} +#if ENABLE_OVERLOADING + CompletionItemTextPropertyInfo , +#endif + clearCompletionItemText , +#if ENABLE_OVERLOADING + completionItemText , +#endif + constructCompletionItemText , + getCompletionItemText , + setCompletionItemText , + + + + + ) 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 {-# SOURCE #-} qualified GI.GtkSource.Interfaces.CompletionProposal as GtkSource.CompletionProposal + +-- | Memory-managed wrapper type. +newtype CompletionItem = CompletionItem (ManagedPtr CompletionItem) +foreign import ccall "gtk_source_completion_item_get_type" + c_gtk_source_completion_item_get_type :: IO GType + +instance GObject CompletionItem where + gobjectType = c_gtk_source_completion_item_get_type + + +-- | Type class for types which can be safely cast to `CompletionItem`, for instance with `toCompletionItem`. +class (GObject o, O.IsDescendantOf CompletionItem o) => IsCompletionItem o +instance (GObject o, O.IsDescendantOf CompletionItem o) => IsCompletionItem o + +instance O.HasParentTypes CompletionItem +type instance O.ParentTypes CompletionItem = '[GObject.Object.Object, GtkSource.CompletionProposal.CompletionProposal] + +-- | Cast to `CompletionItem`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toCompletionItem :: (MonadIO m, IsCompletionItem o) => o -> m CompletionItem +toCompletionItem = liftIO . unsafeCastTo CompletionItem + +-- | A convenience alias for `Nothing` :: `Maybe` `CompletionItem`. +noCompletionItem :: Maybe CompletionItem +noCompletionItem = Nothing + +#if ENABLE_OVERLOADING +type family ResolveCompletionItemMethod (t :: Symbol) (o :: *) :: * where + ResolveCompletionItemMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveCompletionItemMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveCompletionItemMethod "changed" o = GtkSource.CompletionProposal.CompletionProposalChangedMethodInfo + ResolveCompletionItemMethod "equal" o = GtkSource.CompletionProposal.CompletionProposalEqualMethodInfo + ResolveCompletionItemMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveCompletionItemMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveCompletionItemMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveCompletionItemMethod "hash" o = GtkSource.CompletionProposal.CompletionProposalHashMethodInfo + ResolveCompletionItemMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveCompletionItemMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveCompletionItemMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveCompletionItemMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveCompletionItemMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveCompletionItemMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveCompletionItemMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveCompletionItemMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveCompletionItemMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveCompletionItemMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveCompletionItemMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveCompletionItemMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveCompletionItemMethod "getGicon" o = GtkSource.CompletionProposal.CompletionProposalGetGiconMethodInfo + ResolveCompletionItemMethod "getIcon" o = GtkSource.CompletionProposal.CompletionProposalGetIconMethodInfo + ResolveCompletionItemMethod "getIconName" o = GtkSource.CompletionProposal.CompletionProposalGetIconNameMethodInfo + ResolveCompletionItemMethod "getInfo" o = GtkSource.CompletionProposal.CompletionProposalGetInfoMethodInfo + ResolveCompletionItemMethod "getLabel" o = GtkSource.CompletionProposal.CompletionProposalGetLabelMethodInfo + ResolveCompletionItemMethod "getMarkup" o = GtkSource.CompletionProposal.CompletionProposalGetMarkupMethodInfo + ResolveCompletionItemMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveCompletionItemMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveCompletionItemMethod "getText" o = GtkSource.CompletionProposal.CompletionProposalGetTextMethodInfo + ResolveCompletionItemMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveCompletionItemMethod "setGicon" o = CompletionItemSetGiconMethodInfo + ResolveCompletionItemMethod "setIcon" o = CompletionItemSetIconMethodInfo + ResolveCompletionItemMethod "setIconName" o = CompletionItemSetIconNameMethodInfo + ResolveCompletionItemMethod "setInfo" o = CompletionItemSetInfoMethodInfo + ResolveCompletionItemMethod "setLabel" o = CompletionItemSetLabelMethodInfo + ResolveCompletionItemMethod "setMarkup" o = CompletionItemSetMarkupMethodInfo + ResolveCompletionItemMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveCompletionItemMethod "setText" o = CompletionItemSetTextMethodInfo + ResolveCompletionItemMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveCompletionItemMethod t CompletionItem, O.MethodInfo info CompletionItem p) => OL.IsLabel t (CompletionItem -> 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 + +-- VVV Prop "gicon" + -- Type: TInterface (Name {namespace = "Gio", name = "Icon"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Just True) + +{- | +Get the value of the “@gicon@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completionItem #gicon +@ +-} +getCompletionItemGicon :: (MonadIO m, IsCompletionItem o) => o -> m (Maybe Gio.Icon.Icon) +getCompletionItemGicon obj = liftIO $ B.Properties.getObjectPropertyObject obj "gicon" Gio.Icon.Icon + +{- | +Set the value of the “@gicon@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completionItem [ #gicon 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionItemGicon :: (MonadIO m, IsCompletionItem o, Gio.Icon.IsIcon a) => o -> a -> m () +setCompletionItemGicon obj val = liftIO $ B.Properties.setObjectPropertyObject obj "gicon" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@gicon@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionItemGicon :: (IsCompletionItem o, Gio.Icon.IsIcon a) => a -> IO (GValueConstruct o) +constructCompletionItemGicon val = B.Properties.constructObjectPropertyObject "gicon" (Just val) + +{- | +Set the value of the “@gicon@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #gicon +@ +-} +clearCompletionItemGicon :: (MonadIO m, IsCompletionItem o) => o -> m () +clearCompletionItemGicon obj = liftIO $ B.Properties.setObjectPropertyObject obj "gicon" (Nothing :: Maybe Gio.Icon.Icon) + +#if ENABLE_OVERLOADING +data CompletionItemGiconPropertyInfo +instance AttrInfo CompletionItemGiconPropertyInfo where + type AttrAllowedOps CompletionItemGiconPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CompletionItemGiconPropertyInfo = Gio.Icon.IsIcon + type AttrBaseTypeConstraint CompletionItemGiconPropertyInfo = IsCompletionItem + type AttrGetType CompletionItemGiconPropertyInfo = (Maybe Gio.Icon.Icon) + type AttrLabel CompletionItemGiconPropertyInfo = "gicon" + type AttrOrigin CompletionItemGiconPropertyInfo = CompletionItem + attrGet _ = getCompletionItemGicon + attrSet _ = setCompletionItemGicon + attrConstruct _ = constructCompletionItemGicon + attrClear _ = clearCompletionItemGicon +#endif + +-- VVV Prop "icon" + -- Type: TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Just True) + +{- | +Get the value of the “@icon@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completionItem #icon +@ +-} +getCompletionItemIcon :: (MonadIO m, IsCompletionItem o) => o -> m (Maybe GdkPixbuf.Pixbuf.Pixbuf) +getCompletionItemIcon obj = liftIO $ B.Properties.getObjectPropertyObject obj "icon" GdkPixbuf.Pixbuf.Pixbuf + +{- | +Set the value of the “@icon@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completionItem [ #icon 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionItemIcon :: (MonadIO m, IsCompletionItem o, GdkPixbuf.Pixbuf.IsPixbuf a) => o -> a -> m () +setCompletionItemIcon obj val = liftIO $ B.Properties.setObjectPropertyObject obj "icon" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@icon@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionItemIcon :: (IsCompletionItem o, GdkPixbuf.Pixbuf.IsPixbuf a) => a -> IO (GValueConstruct o) +constructCompletionItemIcon val = B.Properties.constructObjectPropertyObject "icon" (Just val) + +{- | +Set the value of the “@icon@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #icon +@ +-} +clearCompletionItemIcon :: (MonadIO m, IsCompletionItem o) => o -> m () +clearCompletionItemIcon obj = liftIO $ B.Properties.setObjectPropertyObject obj "icon" (Nothing :: Maybe GdkPixbuf.Pixbuf.Pixbuf) + +#if ENABLE_OVERLOADING +data CompletionItemIconPropertyInfo +instance AttrInfo CompletionItemIconPropertyInfo where + type AttrAllowedOps CompletionItemIconPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CompletionItemIconPropertyInfo = GdkPixbuf.Pixbuf.IsPixbuf + type AttrBaseTypeConstraint CompletionItemIconPropertyInfo = IsCompletionItem + type AttrGetType CompletionItemIconPropertyInfo = (Maybe GdkPixbuf.Pixbuf.Pixbuf) + type AttrLabel CompletionItemIconPropertyInfo = "icon" + type AttrOrigin CompletionItemIconPropertyInfo = CompletionItem + attrGet _ = getCompletionItemIcon + attrSet _ = setCompletionItemIcon + attrConstruct _ = constructCompletionItemIcon + attrClear _ = clearCompletionItemIcon +#endif + +-- VVV Prop "icon-name" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Just True) + +{- | +Get the value of the “@icon-name@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completionItem #iconName +@ +-} +getCompletionItemIconName :: (MonadIO m, IsCompletionItem o) => o -> m (Maybe T.Text) +getCompletionItemIconName obj = liftIO $ B.Properties.getObjectPropertyString obj "icon-name" + +{- | +Set the value of the “@icon-name@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completionItem [ #iconName 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionItemIconName :: (MonadIO m, IsCompletionItem o) => o -> T.Text -> m () +setCompletionItemIconName obj val = liftIO $ B.Properties.setObjectPropertyString obj "icon-name" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@icon-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionItemIconName :: (IsCompletionItem o) => T.Text -> IO (GValueConstruct o) +constructCompletionItemIconName val = B.Properties.constructObjectPropertyString "icon-name" (Just val) + +{- | +Set the value of the “@icon-name@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #iconName +@ +-} +clearCompletionItemIconName :: (MonadIO m, IsCompletionItem o) => o -> m () +clearCompletionItemIconName obj = liftIO $ B.Properties.setObjectPropertyString obj "icon-name" (Nothing :: Maybe T.Text) + +#if ENABLE_OVERLOADING +data CompletionItemIconNamePropertyInfo +instance AttrInfo CompletionItemIconNamePropertyInfo where + type AttrAllowedOps CompletionItemIconNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CompletionItemIconNamePropertyInfo = (~) T.Text + type AttrBaseTypeConstraint CompletionItemIconNamePropertyInfo = IsCompletionItem + type AttrGetType CompletionItemIconNamePropertyInfo = (Maybe T.Text) + type AttrLabel CompletionItemIconNamePropertyInfo = "icon-name" + type AttrOrigin CompletionItemIconNamePropertyInfo = CompletionItem + attrGet _ = getCompletionItemIconName + attrSet _ = setCompletionItemIconName + attrConstruct _ = constructCompletionItemIconName + attrClear _ = clearCompletionItemIconName +#endif + +-- VVV Prop "info" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Just True) + +{- | +Get the value of the “@info@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completionItem #info +@ +-} +getCompletionItemInfo :: (MonadIO m, IsCompletionItem o) => o -> m (Maybe T.Text) +getCompletionItemInfo obj = liftIO $ B.Properties.getObjectPropertyString obj "info" + +{- | +Set the value of the “@info@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completionItem [ #info 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionItemInfo :: (MonadIO m, IsCompletionItem o) => o -> T.Text -> m () +setCompletionItemInfo obj val = liftIO $ B.Properties.setObjectPropertyString obj "info" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@info@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionItemInfo :: (IsCompletionItem o) => T.Text -> IO (GValueConstruct o) +constructCompletionItemInfo val = B.Properties.constructObjectPropertyString "info" (Just val) + +{- | +Set the value of the “@info@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #info +@ +-} +clearCompletionItemInfo :: (MonadIO m, IsCompletionItem o) => o -> m () +clearCompletionItemInfo obj = liftIO $ B.Properties.setObjectPropertyString obj "info" (Nothing :: Maybe T.Text) + +#if ENABLE_OVERLOADING +data CompletionItemInfoPropertyInfo +instance AttrInfo CompletionItemInfoPropertyInfo where + type AttrAllowedOps CompletionItemInfoPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CompletionItemInfoPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint CompletionItemInfoPropertyInfo = IsCompletionItem + type AttrGetType CompletionItemInfoPropertyInfo = (Maybe T.Text) + type AttrLabel CompletionItemInfoPropertyInfo = "info" + type AttrOrigin CompletionItemInfoPropertyInfo = CompletionItem + attrGet _ = getCompletionItemInfo + attrSet _ = setCompletionItemInfo + attrConstruct _ = constructCompletionItemInfo + attrClear _ = clearCompletionItemInfo +#endif + +-- VVV Prop "label" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Just True) + +{- | +Get the value of the “@label@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completionItem #label +@ +-} +getCompletionItemLabel :: (MonadIO m, IsCompletionItem o) => o -> m (Maybe T.Text) +getCompletionItemLabel obj = liftIO $ B.Properties.getObjectPropertyString obj "label" + +{- | +Set the value of the “@label@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completionItem [ #label 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionItemLabel :: (MonadIO m, IsCompletionItem o) => o -> T.Text -> m () +setCompletionItemLabel obj val = liftIO $ B.Properties.setObjectPropertyString obj "label" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@label@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionItemLabel :: (IsCompletionItem o) => T.Text -> IO (GValueConstruct o) +constructCompletionItemLabel val = B.Properties.constructObjectPropertyString "label" (Just val) + +{- | +Set the value of the “@label@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #label +@ +-} +clearCompletionItemLabel :: (MonadIO m, IsCompletionItem o) => o -> m () +clearCompletionItemLabel obj = liftIO $ B.Properties.setObjectPropertyString obj "label" (Nothing :: Maybe T.Text) + +#if ENABLE_OVERLOADING +data CompletionItemLabelPropertyInfo +instance AttrInfo CompletionItemLabelPropertyInfo where + type AttrAllowedOps CompletionItemLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CompletionItemLabelPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint CompletionItemLabelPropertyInfo = IsCompletionItem + type AttrGetType CompletionItemLabelPropertyInfo = (Maybe T.Text) + type AttrLabel CompletionItemLabelPropertyInfo = "label" + type AttrOrigin CompletionItemLabelPropertyInfo = CompletionItem + attrGet _ = getCompletionItemLabel + attrSet _ = setCompletionItemLabel + attrConstruct _ = constructCompletionItemLabel + attrClear _ = clearCompletionItemLabel +#endif + +-- VVV Prop "markup" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Just True) + +{- | +Get the value of the “@markup@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completionItem #markup +@ +-} +getCompletionItemMarkup :: (MonadIO m, IsCompletionItem o) => o -> m (Maybe T.Text) +getCompletionItemMarkup obj = liftIO $ B.Properties.getObjectPropertyString obj "markup" + +{- | +Set the value of the “@markup@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completionItem [ #markup 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionItemMarkup :: (MonadIO m, IsCompletionItem o) => o -> T.Text -> m () +setCompletionItemMarkup obj val = liftIO $ B.Properties.setObjectPropertyString obj "markup" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@markup@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionItemMarkup :: (IsCompletionItem o) => T.Text -> IO (GValueConstruct o) +constructCompletionItemMarkup val = B.Properties.constructObjectPropertyString "markup" (Just val) + +{- | +Set the value of the “@markup@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #markup +@ +-} +clearCompletionItemMarkup :: (MonadIO m, IsCompletionItem o) => o -> m () +clearCompletionItemMarkup obj = liftIO $ B.Properties.setObjectPropertyString obj "markup" (Nothing :: Maybe T.Text) + +#if ENABLE_OVERLOADING +data CompletionItemMarkupPropertyInfo +instance AttrInfo CompletionItemMarkupPropertyInfo where + type AttrAllowedOps CompletionItemMarkupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CompletionItemMarkupPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint CompletionItemMarkupPropertyInfo = IsCompletionItem + type AttrGetType CompletionItemMarkupPropertyInfo = (Maybe T.Text) + type AttrLabel CompletionItemMarkupPropertyInfo = "markup" + type AttrOrigin CompletionItemMarkupPropertyInfo = CompletionItem + attrGet _ = getCompletionItemMarkup + attrSet _ = setCompletionItemMarkup + attrConstruct _ = constructCompletionItemMarkup + attrClear _ = clearCompletionItemMarkup +#endif + +-- VVV Prop "text" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Just True) + +{- | +Get the value of the “@text@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completionItem #text +@ +-} +getCompletionItemText :: (MonadIO m, IsCompletionItem o) => o -> m (Maybe T.Text) +getCompletionItemText obj = liftIO $ B.Properties.getObjectPropertyString obj "text" + +{- | +Set the value of the “@text@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completionItem [ #text 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionItemText :: (MonadIO m, IsCompletionItem o) => o -> T.Text -> m () +setCompletionItemText obj val = liftIO $ B.Properties.setObjectPropertyString obj "text" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@text@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionItemText :: (IsCompletionItem o) => T.Text -> IO (GValueConstruct o) +constructCompletionItemText val = B.Properties.constructObjectPropertyString "text" (Just val) + +{- | +Set the value of the “@text@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #text +@ +-} +clearCompletionItemText :: (MonadIO m, IsCompletionItem o) => o -> m () +clearCompletionItemText obj = liftIO $ B.Properties.setObjectPropertyString obj "text" (Nothing :: Maybe T.Text) + +#if ENABLE_OVERLOADING +data CompletionItemTextPropertyInfo +instance AttrInfo CompletionItemTextPropertyInfo where + type AttrAllowedOps CompletionItemTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CompletionItemTextPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint CompletionItemTextPropertyInfo = IsCompletionItem + type AttrGetType CompletionItemTextPropertyInfo = (Maybe T.Text) + type AttrLabel CompletionItemTextPropertyInfo = "text" + type AttrOrigin CompletionItemTextPropertyInfo = CompletionItem + attrGet _ = getCompletionItemText + attrSet _ = setCompletionItemText + attrConstruct _ = constructCompletionItemText + attrClear _ = clearCompletionItemText +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList CompletionItem +type instance O.AttributeList CompletionItem = CompletionItemAttributeList +type CompletionItemAttributeList = ('[ '("gicon", CompletionItemGiconPropertyInfo), '("icon", CompletionItemIconPropertyInfo), '("iconName", CompletionItemIconNamePropertyInfo), '("info", CompletionItemInfoPropertyInfo), '("label", CompletionItemLabelPropertyInfo), '("markup", CompletionItemMarkupPropertyInfo), '("text", CompletionItemTextPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +completionItemGicon :: AttrLabelProxy "gicon" +completionItemGicon = AttrLabelProxy + +completionItemIcon :: AttrLabelProxy "icon" +completionItemIcon = AttrLabelProxy + +completionItemIconName :: AttrLabelProxy "iconName" +completionItemIconName = AttrLabelProxy + +completionItemInfo :: AttrLabelProxy "info" +completionItemInfo = AttrLabelProxy + +completionItemLabel :: AttrLabelProxy "label" +completionItemLabel = AttrLabelProxy + +completionItemMarkup :: AttrLabelProxy "markup" +completionItemMarkup = AttrLabelProxy + +completionItemText :: AttrLabelProxy "text" +completionItemText = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList CompletionItem = CompletionItemSignalList +type CompletionItemSignalList = ('[ '("changed", GtkSource.CompletionProposal.CompletionProposalChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method CompletionItem::new +-- method type : Constructor +-- Args : [Arg {argCName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The item label.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The item text.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "icon", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The item icon.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The item extra information.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "CompletionItem"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_completion_item_new" gtk_source_completion_item_new :: + CString -> -- label : TBasicType TUTF8 + CString -> -- text : TBasicType TUTF8 + Ptr GdkPixbuf.Pixbuf.Pixbuf -> -- icon : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}) + CString -> -- info : TBasicType TUTF8 + IO (Ptr CompletionItem) + +{-# DEPRECATED completionItemNew ["(Since version 3.24)","Use 'GI.GtkSource.Objects.CompletionItem.completionItemNew2' instead."] #-} +{- | +Create a new 'GI.GtkSource.Objects.CompletionItem.CompletionItem' with label /@label@/, icon /@icon@/ and +extra information /@info@/. Both /@icon@/ and /@info@/ can be 'Nothing' in which case +there will be no icon shown and no extra information available. +-} +completionItemNew :: + (B.CallStack.HasCallStack, MonadIO m, GdkPixbuf.Pixbuf.IsPixbuf a) => + T.Text + {- ^ /@label@/: The item label. -} + -> T.Text + {- ^ /@text@/: The item text. -} + -> Maybe (a) + {- ^ /@icon@/: The item icon. -} + -> Maybe (T.Text) + {- ^ /@info@/: The item extra information. -} + -> m CompletionItem + {- ^ __Returns:__ a new 'GI.GtkSource.Objects.CompletionItem.CompletionItem'. -} +completionItemNew label text icon info = liftIO $ do + label' <- textToCString label + text' <- textToCString text + maybeIcon <- case icon of + Nothing -> return nullPtr + Just jIcon -> do + jIcon' <- unsafeManagedPtrCastPtr jIcon + return jIcon' + maybeInfo <- case info of + Nothing -> return nullPtr + Just jInfo -> do + jInfo' <- textToCString jInfo + return jInfo' + result <- gtk_source_completion_item_new label' text' maybeIcon maybeInfo + checkUnexpectedReturnNULL "completionItemNew" result + result' <- (wrapObject CompletionItem) result + whenJust icon touchManagedPtr + freeMem label' + freeMem text' + freeMem maybeInfo + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method CompletionItem::new_from_stock +-- method type : Constructor +-- Args : [Arg {argCName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The item label.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The item text.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stock", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The stock icon.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The item extra information.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "CompletionItem"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_completion_item_new_from_stock" gtk_source_completion_item_new_from_stock :: + CString -> -- label : TBasicType TUTF8 + CString -> -- text : TBasicType TUTF8 + CString -> -- stock : TBasicType TUTF8 + CString -> -- info : TBasicType TUTF8 + IO (Ptr CompletionItem) + +{-# DEPRECATED completionItemNewFromStock ["(Since version 3.10)","Use 'GI.GtkSource.Objects.CompletionItem.completionItemNew2' instead."] #-} +{- | +Creates a new 'GI.GtkSource.Objects.CompletionItem.CompletionItem' from a stock item. If /@label@/ is 'Nothing', +the stock label will be used. +-} +completionItemNewFromStock :: + (B.CallStack.HasCallStack, MonadIO m) => + Maybe (T.Text) + {- ^ /@label@/: The item label. -} + -> T.Text + {- ^ /@text@/: The item text. -} + -> T.Text + {- ^ /@stock@/: The stock icon. -} + -> Maybe (T.Text) + {- ^ /@info@/: The item extra information. -} + -> m CompletionItem + {- ^ __Returns:__ a new 'GI.GtkSource.Objects.CompletionItem.CompletionItem'. -} +completionItemNewFromStock label text stock info = liftIO $ do + maybeLabel <- case label of + Nothing -> return nullPtr + Just jLabel -> do + jLabel' <- textToCString jLabel + return jLabel' + text' <- textToCString text + stock' <- textToCString stock + maybeInfo <- case info of + Nothing -> return nullPtr + Just jInfo -> do + jInfo' <- textToCString jInfo + return jInfo' + result <- gtk_source_completion_item_new_from_stock maybeLabel text' stock' maybeInfo + checkUnexpectedReturnNULL "completionItemNewFromStock" result + result' <- (wrapObject CompletionItem) result + freeMem maybeLabel + freeMem text' + freeMem stock' + freeMem maybeInfo + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method CompletionItem::new_with_markup +-- method type : Constructor +-- Args : [Arg {argCName = "markup", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The item markup label.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The item text.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "icon", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The item icon.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The item extra information.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "CompletionItem"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_completion_item_new_with_markup" gtk_source_completion_item_new_with_markup :: + CString -> -- markup : TBasicType TUTF8 + CString -> -- text : TBasicType TUTF8 + Ptr GdkPixbuf.Pixbuf.Pixbuf -> -- icon : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}) + CString -> -- info : TBasicType TUTF8 + IO (Ptr CompletionItem) + +{-# DEPRECATED completionItemNewWithMarkup ["(Since version 3.24)","Use 'GI.GtkSource.Objects.CompletionItem.completionItemNew2' instead."] #-} +{- | +Create a new 'GI.GtkSource.Objects.CompletionItem.CompletionItem' with markup label /@markup@/, icon +/@icon@/ and extra information /@info@/. Both /@icon@/ and /@info@/ can be 'Nothing' in +which case there will be no icon shown and no extra information available. +-} +completionItemNewWithMarkup :: + (B.CallStack.HasCallStack, MonadIO m, GdkPixbuf.Pixbuf.IsPixbuf a) => + T.Text + {- ^ /@markup@/: The item markup label. -} + -> T.Text + {- ^ /@text@/: The item text. -} + -> Maybe (a) + {- ^ /@icon@/: The item icon. -} + -> Maybe (T.Text) + {- ^ /@info@/: The item extra information. -} + -> m CompletionItem + {- ^ __Returns:__ a new 'GI.GtkSource.Objects.CompletionItem.CompletionItem'. -} +completionItemNewWithMarkup markup text icon info = liftIO $ do + markup' <- textToCString markup + text' <- textToCString text + maybeIcon <- case icon of + Nothing -> return nullPtr + Just jIcon -> do + jIcon' <- unsafeManagedPtrCastPtr jIcon + return jIcon' + maybeInfo <- case info of + Nothing -> return nullPtr + Just jInfo -> do + jInfo' <- textToCString jInfo + return jInfo' + result <- gtk_source_completion_item_new_with_markup markup' text' maybeIcon maybeInfo + checkUnexpectedReturnNULL "completionItemNewWithMarkup" result + result' <- (wrapObject CompletionItem) result + whenJust icon touchManagedPtr + freeMem markup' + freeMem text' + freeMem maybeInfo + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method CompletionItem::set_gicon +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionItem.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gicon", argType = TInterface (Name {namespace = "Gio", name = "Icon"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the #GIcon, 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_completion_item_set_gicon" gtk_source_completion_item_set_gicon :: + Ptr CompletionItem -> -- item : TInterface (Name {namespace = "GtkSource", name = "CompletionItem"}) + Ptr Gio.Icon.Icon -> -- gicon : TInterface (Name {namespace = "Gio", name = "Icon"}) + IO () + +{- | +/No description available in the introspection data./ + +/Since: 3.24/ +-} +completionItemSetGicon :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletionItem a, Gio.Icon.IsIcon b) => + a + {- ^ /@item@/: a 'GI.GtkSource.Objects.CompletionItem.CompletionItem'. -} + -> Maybe (b) + {- ^ /@gicon@/: the 'GI.Gio.Interfaces.Icon.Icon', or 'Nothing'. -} + -> m () +completionItemSetGicon item gicon = liftIO $ do + item' <- unsafeManagedPtrCastPtr item + maybeGicon <- case gicon of + Nothing -> return nullPtr + Just jGicon -> do + jGicon' <- unsafeManagedPtrCastPtr jGicon + return jGicon' + gtk_source_completion_item_set_gicon item' maybeGicon + touchManagedPtr item + whenJust gicon touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data CompletionItemSetGiconMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsCompletionItem a, Gio.Icon.IsIcon b) => O.MethodInfo CompletionItemSetGiconMethodInfo a signature where + overloadedMethod _ = completionItemSetGicon + +#endif + +-- method CompletionItem::set_icon +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionItem.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "icon", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the #GdkPixbuf, 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_completion_item_set_icon" gtk_source_completion_item_set_icon :: + Ptr CompletionItem -> -- item : TInterface (Name {namespace = "GtkSource", name = "CompletionItem"}) + Ptr GdkPixbuf.Pixbuf.Pixbuf -> -- icon : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}) + IO () + +{- | +/No description available in the introspection data./ + +/Since: 3.24/ +-} +completionItemSetIcon :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletionItem a, GdkPixbuf.Pixbuf.IsPixbuf b) => + a + {- ^ /@item@/: a 'GI.GtkSource.Objects.CompletionItem.CompletionItem'. -} + -> Maybe (b) + {- ^ /@icon@/: the 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf', or 'Nothing'. -} + -> m () +completionItemSetIcon item icon = liftIO $ do + item' <- unsafeManagedPtrCastPtr item + maybeIcon <- case icon of + Nothing -> return nullPtr + Just jIcon -> do + jIcon' <- unsafeManagedPtrCastPtr jIcon + return jIcon' + gtk_source_completion_item_set_icon item' maybeIcon + touchManagedPtr item + whenJust icon touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data CompletionItemSetIconMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsCompletionItem a, GdkPixbuf.Pixbuf.IsPixbuf b) => O.MethodInfo CompletionItemSetIconMethodInfo a signature where + overloadedMethod _ = completionItemSetIcon + +#endif + +-- method CompletionItem::set_icon_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionItem.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "icon_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the icon name, 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_completion_item_set_icon_name" gtk_source_completion_item_set_icon_name :: + Ptr CompletionItem -> -- item : TInterface (Name {namespace = "GtkSource", name = "CompletionItem"}) + CString -> -- icon_name : TBasicType TUTF8 + IO () + +{- | +/No description available in the introspection data./ + +/Since: 3.24/ +-} +completionItemSetIconName :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletionItem a) => + a + {- ^ /@item@/: a 'GI.GtkSource.Objects.CompletionItem.CompletionItem'. -} + -> Maybe (T.Text) + {- ^ /@iconName@/: the icon name, or 'Nothing'. -} + -> m () +completionItemSetIconName item iconName = liftIO $ do + item' <- unsafeManagedPtrCastPtr item + maybeIconName <- case iconName of + Nothing -> return nullPtr + Just jIconName -> do + jIconName' <- textToCString jIconName + return jIconName' + gtk_source_completion_item_set_icon_name item' maybeIconName + touchManagedPtr item + freeMem maybeIconName + return () + +#if ENABLE_OVERLOADING +data CompletionItemSetIconNameMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsCompletionItem a) => O.MethodInfo CompletionItemSetIconNameMethodInfo a signature where + overloadedMethod _ = completionItemSetIconName + +#endif + +-- method CompletionItem::set_info +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionItem.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the info, 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_completion_item_set_info" gtk_source_completion_item_set_info :: + Ptr CompletionItem -> -- item : TInterface (Name {namespace = "GtkSource", name = "CompletionItem"}) + CString -> -- info : TBasicType TUTF8 + IO () + +{- | +/No description available in the introspection data./ + +/Since: 3.24/ +-} +completionItemSetInfo :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletionItem a) => + a + {- ^ /@item@/: a 'GI.GtkSource.Objects.CompletionItem.CompletionItem'. -} + -> Maybe (T.Text) + {- ^ /@info@/: the info, or 'Nothing'. -} + -> m () +completionItemSetInfo item info = liftIO $ do + item' <- unsafeManagedPtrCastPtr item + maybeInfo <- case info of + Nothing -> return nullPtr + Just jInfo -> do + jInfo' <- textToCString jInfo + return jInfo' + gtk_source_completion_item_set_info item' maybeInfo + touchManagedPtr item + freeMem maybeInfo + return () + +#if ENABLE_OVERLOADING +data CompletionItemSetInfoMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsCompletionItem a) => O.MethodInfo CompletionItemSetInfoMethodInfo a signature where + overloadedMethod _ = completionItemSetInfo + +#endif + +-- method CompletionItem::set_label +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionItem.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the label, 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_completion_item_set_label" gtk_source_completion_item_set_label :: + Ptr CompletionItem -> -- item : TInterface (Name {namespace = "GtkSource", name = "CompletionItem"}) + CString -> -- label : TBasicType TUTF8 + IO () + +{- | +/No description available in the introspection data./ + +/Since: 3.24/ +-} +completionItemSetLabel :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletionItem a) => + a + {- ^ /@item@/: a 'GI.GtkSource.Objects.CompletionItem.CompletionItem'. -} + -> Maybe (T.Text) + {- ^ /@label@/: the label, or 'Nothing'. -} + -> m () +completionItemSetLabel item label = liftIO $ do + item' <- unsafeManagedPtrCastPtr item + maybeLabel <- case label of + Nothing -> return nullPtr + Just jLabel -> do + jLabel' <- textToCString jLabel + return jLabel' + gtk_source_completion_item_set_label item' maybeLabel + touchManagedPtr item + freeMem maybeLabel + return () + +#if ENABLE_OVERLOADING +data CompletionItemSetLabelMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsCompletionItem a) => O.MethodInfo CompletionItemSetLabelMethodInfo a signature where + overloadedMethod _ = completionItemSetLabel + +#endif + +-- method CompletionItem::set_markup +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionItem.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "markup", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the markup, 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_completion_item_set_markup" gtk_source_completion_item_set_markup :: + Ptr CompletionItem -> -- item : TInterface (Name {namespace = "GtkSource", name = "CompletionItem"}) + CString -> -- markup : TBasicType TUTF8 + IO () + +{- | +/No description available in the introspection data./ + +/Since: 3.24/ +-} +completionItemSetMarkup :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletionItem a) => + a + {- ^ /@item@/: a 'GI.GtkSource.Objects.CompletionItem.CompletionItem'. -} + -> Maybe (T.Text) + {- ^ /@markup@/: the markup, or 'Nothing'. -} + -> m () +completionItemSetMarkup item markup = liftIO $ do + item' <- unsafeManagedPtrCastPtr item + maybeMarkup <- case markup of + Nothing -> return nullPtr + Just jMarkup -> do + jMarkup' <- textToCString jMarkup + return jMarkup' + gtk_source_completion_item_set_markup item' maybeMarkup + touchManagedPtr item + freeMem maybeMarkup + return () + +#if ENABLE_OVERLOADING +data CompletionItemSetMarkupMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsCompletionItem a) => O.MethodInfo CompletionItemSetMarkupMethodInfo a signature where + overloadedMethod _ = completionItemSetMarkup + +#endif + +-- method CompletionItem::set_text +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionItem.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the text, 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_completion_item_set_text" gtk_source_completion_item_set_text :: + Ptr CompletionItem -> -- item : TInterface (Name {namespace = "GtkSource", name = "CompletionItem"}) + CString -> -- text : TBasicType TUTF8 + IO () + +{- | +/No description available in the introspection data./ + +/Since: 3.24/ +-} +completionItemSetText :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletionItem a) => + a + {- ^ /@item@/: a 'GI.GtkSource.Objects.CompletionItem.CompletionItem'. -} + -> Maybe (T.Text) + {- ^ /@text@/: the text, or 'Nothing'. -} + -> m () +completionItemSetText item text = liftIO $ do + item' <- unsafeManagedPtrCastPtr item + maybeText <- case text of + Nothing -> return nullPtr + Just jText -> do + jText' <- textToCString jText + return jText' + gtk_source_completion_item_set_text item' maybeText + touchManagedPtr item + freeMem maybeText + return () + +#if ENABLE_OVERLOADING +data CompletionItemSetTextMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsCompletionItem a) => O.MethodInfo CompletionItemSetTextMethodInfo a signature where + overloadedMethod _ = completionItemSetText + +#endif + +-- method CompletionItem::new2 +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "CompletionItem"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_completion_item_new2" gtk_source_completion_item_new2 :: + IO (Ptr CompletionItem) + +{- | +Creates a new 'GI.GtkSource.Objects.CompletionItem.CompletionItem'. The desired properties need to be set +afterwards. + +/Since: 3.24/ +-} +completionItemNew2 :: + (B.CallStack.HasCallStack, MonadIO m) => + m CompletionItem + {- ^ __Returns:__ a new 'GI.GtkSource.Objects.CompletionItem.CompletionItem'. -} +completionItemNew2 = liftIO $ do + result <- gtk_source_completion_item_new2 + checkUnexpectedReturnNULL "completionItemNew2" result + result' <- (wrapObject CompletionItem) result + return result' + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/GtkSource/Objects/CompletionItem.hs-boot b/GI/GtkSource/Objects/CompletionItem.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/CompletionItem.hs-boot @@ -0,0 +1,71 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.CompletionItem 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 CompletionItem = CompletionItem (ManagedPtr CompletionItem) +instance GObject CompletionItem where +class (GObject o, O.IsDescendantOf CompletionItem o) => IsCompletionItem o +instance (GObject o, O.IsDescendantOf CompletionItem o) => IsCompletionItem o +instance O.HasParentTypes CompletionItem +#if ENABLE_OVERLOADING +data CompletionItemGiconPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionItemIconPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionItemIconNamePropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionItemInfoPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionItemLabelPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionItemMarkupPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionItemTextPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionItemSetGiconMethodInfo +#endif +#if ENABLE_OVERLOADING +data CompletionItemSetIconMethodInfo +#endif +#if ENABLE_OVERLOADING +data CompletionItemSetIconNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data CompletionItemSetInfoMethodInfo +#endif +#if ENABLE_OVERLOADING +data CompletionItemSetLabelMethodInfo +#endif +#if ENABLE_OVERLOADING +data CompletionItemSetMarkupMethodInfo +#endif +#if ENABLE_OVERLOADING +data CompletionItemSetTextMethodInfo +#endif diff --git a/GI/GtkSource/Objects/CompletionWords.hs b/GI/GtkSource/Objects/CompletionWords.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/CompletionWords.hs @@ -0,0 +1,834 @@ + + +{- | +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.CompletionWords + ( + +-- * Exported types + CompletionWords(..) , + IsCompletionWords , + toCompletionWords , + noCompletionWords , + + + -- * Methods +-- ** new #method:new# + + completionWordsNew , + + +-- ** register #method:register# + +#if ENABLE_OVERLOADING + CompletionWordsRegisterMethodInfo , +#endif + completionWordsRegister , + + +-- ** unregister #method:unregister# + +#if ENABLE_OVERLOADING + CompletionWordsUnregisterMethodInfo , +#endif + completionWordsUnregister , + + + + + -- * Properties +-- ** activation #attr:activation# +{- | The type of activation. + +/Since: 3.10/ +-} +#if ENABLE_OVERLOADING + CompletionWordsActivationPropertyInfo , +#endif +#if ENABLE_OVERLOADING + completionWordsActivation , +#endif + constructCompletionWordsActivation , + getCompletionWordsActivation , + setCompletionWordsActivation , + + +-- ** icon #attr:icon# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CompletionWordsIconPropertyInfo , +#endif + clearCompletionWordsIcon , +#if ENABLE_OVERLOADING + completionWordsIcon , +#endif + constructCompletionWordsIcon , + getCompletionWordsIcon , + setCompletionWordsIcon , + + +-- ** interactiveDelay #attr:interactiveDelay# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CompletionWordsInteractiveDelayPropertyInfo, +#endif +#if ENABLE_OVERLOADING + completionWordsInteractiveDelay , +#endif + constructCompletionWordsInteractiveDelay, + getCompletionWordsInteractiveDelay , + setCompletionWordsInteractiveDelay , + + +-- ** minimumWordSize #attr:minimumWordSize# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CompletionWordsMinimumWordSizePropertyInfo, +#endif +#if ENABLE_OVERLOADING + completionWordsMinimumWordSize , +#endif + constructCompletionWordsMinimumWordSize , + getCompletionWordsMinimumWordSize , + setCompletionWordsMinimumWordSize , + + +-- ** name #attr:name# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CompletionWordsNamePropertyInfo , +#endif + clearCompletionWordsName , +#if ENABLE_OVERLOADING + completionWordsName , +#endif + constructCompletionWordsName , + getCompletionWordsName , + setCompletionWordsName , + + +-- ** priority #attr:priority# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CompletionWordsPriorityPropertyInfo , +#endif +#if ENABLE_OVERLOADING + completionWordsPriority , +#endif + constructCompletionWordsPriority , + getCompletionWordsPriority , + setCompletionWordsPriority , + + +-- ** proposalsBatchSize #attr:proposalsBatchSize# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CompletionWordsProposalsBatchSizePropertyInfo, +#endif +#if ENABLE_OVERLOADING + completionWordsProposalsBatchSize , +#endif + constructCompletionWordsProposalsBatchSize, + getCompletionWordsProposalsBatchSize , + setCompletionWordsProposalsBatchSize , + + +-- ** scanBatchSize #attr:scanBatchSize# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + CompletionWordsScanBatchSizePropertyInfo, +#endif +#if ENABLE_OVERLOADING + completionWordsScanBatchSize , +#endif + constructCompletionWordsScanBatchSize , + getCompletionWordsScanBatchSize , + setCompletionWordsScanBatchSize , + + + + + ) 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.Gtk.Objects.TextBuffer as Gtk.TextBuffer +import {-# SOURCE #-} qualified GI.GtkSource.Flags as GtkSource.Flags +import {-# SOURCE #-} qualified GI.GtkSource.Interfaces.CompletionProvider as GtkSource.CompletionProvider + +-- | Memory-managed wrapper type. +newtype CompletionWords = CompletionWords (ManagedPtr CompletionWords) +foreign import ccall "gtk_source_completion_words_get_type" + c_gtk_source_completion_words_get_type :: IO GType + +instance GObject CompletionWords where + gobjectType = c_gtk_source_completion_words_get_type + + +-- | Type class for types which can be safely cast to `CompletionWords`, for instance with `toCompletionWords`. +class (GObject o, O.IsDescendantOf CompletionWords o) => IsCompletionWords o +instance (GObject o, O.IsDescendantOf CompletionWords o) => IsCompletionWords o + +instance O.HasParentTypes CompletionWords +type instance O.ParentTypes CompletionWords = '[GObject.Object.Object, GtkSource.CompletionProvider.CompletionProvider] + +-- | Cast to `CompletionWords`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toCompletionWords :: (MonadIO m, IsCompletionWords o) => o -> m CompletionWords +toCompletionWords = liftIO . unsafeCastTo CompletionWords + +-- | A convenience alias for `Nothing` :: `Maybe` `CompletionWords`. +noCompletionWords :: Maybe CompletionWords +noCompletionWords = Nothing + +#if ENABLE_OVERLOADING +type family ResolveCompletionWordsMethod (t :: Symbol) (o :: *) :: * where + ResolveCompletionWordsMethod "activateProposal" o = GtkSource.CompletionProvider.CompletionProviderActivateProposalMethodInfo + ResolveCompletionWordsMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveCompletionWordsMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveCompletionWordsMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveCompletionWordsMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveCompletionWordsMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveCompletionWordsMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveCompletionWordsMethod "match" o = GtkSource.CompletionProvider.CompletionProviderMatchMethodInfo + ResolveCompletionWordsMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveCompletionWordsMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveCompletionWordsMethod "populate" o = GtkSource.CompletionProvider.CompletionProviderPopulateMethodInfo + ResolveCompletionWordsMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveCompletionWordsMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveCompletionWordsMethod "register" o = CompletionWordsRegisterMethodInfo + ResolveCompletionWordsMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveCompletionWordsMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveCompletionWordsMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveCompletionWordsMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveCompletionWordsMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveCompletionWordsMethod "unregister" o = CompletionWordsUnregisterMethodInfo + ResolveCompletionWordsMethod "updateInfo" o = GtkSource.CompletionProvider.CompletionProviderUpdateInfoMethodInfo + ResolveCompletionWordsMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveCompletionWordsMethod "getActivation" o = GtkSource.CompletionProvider.CompletionProviderGetActivationMethodInfo + ResolveCompletionWordsMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveCompletionWordsMethod "getGicon" o = GtkSource.CompletionProvider.CompletionProviderGetGiconMethodInfo + ResolveCompletionWordsMethod "getIcon" o = GtkSource.CompletionProvider.CompletionProviderGetIconMethodInfo + ResolveCompletionWordsMethod "getIconName" o = GtkSource.CompletionProvider.CompletionProviderGetIconNameMethodInfo + ResolveCompletionWordsMethod "getInfoWidget" o = GtkSource.CompletionProvider.CompletionProviderGetInfoWidgetMethodInfo + ResolveCompletionWordsMethod "getInteractiveDelay" o = GtkSource.CompletionProvider.CompletionProviderGetInteractiveDelayMethodInfo + ResolveCompletionWordsMethod "getName" o = GtkSource.CompletionProvider.CompletionProviderGetNameMethodInfo + ResolveCompletionWordsMethod "getPriority" o = GtkSource.CompletionProvider.CompletionProviderGetPriorityMethodInfo + ResolveCompletionWordsMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveCompletionWordsMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveCompletionWordsMethod "getStartIter" o = GtkSource.CompletionProvider.CompletionProviderGetStartIterMethodInfo + ResolveCompletionWordsMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveCompletionWordsMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveCompletionWordsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveCompletionWordsMethod t CompletionWords, O.MethodInfo info CompletionWords p) => OL.IsLabel t (CompletionWords -> 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 + +-- VVV Prop "activation" + -- Type: TInterface (Name {namespace = "GtkSource", name = "CompletionActivation"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@activation@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completionWords #activation +@ +-} +getCompletionWordsActivation :: (MonadIO m, IsCompletionWords o) => o -> m [GtkSource.Flags.CompletionActivation] +getCompletionWordsActivation obj = liftIO $ B.Properties.getObjectPropertyFlags obj "activation" + +{- | +Set the value of the “@activation@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completionWords [ #activation 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionWordsActivation :: (MonadIO m, IsCompletionWords o) => o -> [GtkSource.Flags.CompletionActivation] -> m () +setCompletionWordsActivation obj val = liftIO $ B.Properties.setObjectPropertyFlags obj "activation" val + +{- | +Construct a `GValueConstruct` with valid value for the “@activation@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionWordsActivation :: (IsCompletionWords o) => [GtkSource.Flags.CompletionActivation] -> IO (GValueConstruct o) +constructCompletionWordsActivation val = B.Properties.constructObjectPropertyFlags "activation" val + +#if ENABLE_OVERLOADING +data CompletionWordsActivationPropertyInfo +instance AttrInfo CompletionWordsActivationPropertyInfo where + type AttrAllowedOps CompletionWordsActivationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint CompletionWordsActivationPropertyInfo = (~) [GtkSource.Flags.CompletionActivation] + type AttrBaseTypeConstraint CompletionWordsActivationPropertyInfo = IsCompletionWords + type AttrGetType CompletionWordsActivationPropertyInfo = [GtkSource.Flags.CompletionActivation] + type AttrLabel CompletionWordsActivationPropertyInfo = "activation" + type AttrOrigin CompletionWordsActivationPropertyInfo = CompletionWords + attrGet _ = getCompletionWordsActivation + attrSet _ = setCompletionWordsActivation + attrConstruct _ = constructCompletionWordsActivation + attrClear _ = undefined +#endif + +-- VVV Prop "icon" + -- Type: TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@icon@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completionWords #icon +@ +-} +getCompletionWordsIcon :: (MonadIO m, IsCompletionWords o) => o -> m (Maybe GdkPixbuf.Pixbuf.Pixbuf) +getCompletionWordsIcon obj = liftIO $ B.Properties.getObjectPropertyObject obj "icon" GdkPixbuf.Pixbuf.Pixbuf + +{- | +Set the value of the “@icon@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completionWords [ #icon 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionWordsIcon :: (MonadIO m, IsCompletionWords o, GdkPixbuf.Pixbuf.IsPixbuf a) => o -> a -> m () +setCompletionWordsIcon obj val = liftIO $ B.Properties.setObjectPropertyObject obj "icon" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@icon@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionWordsIcon :: (IsCompletionWords o, GdkPixbuf.Pixbuf.IsPixbuf a) => a -> IO (GValueConstruct o) +constructCompletionWordsIcon val = B.Properties.constructObjectPropertyObject "icon" (Just val) + +{- | +Set the value of the “@icon@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #icon +@ +-} +clearCompletionWordsIcon :: (MonadIO m, IsCompletionWords o) => o -> m () +clearCompletionWordsIcon obj = liftIO $ B.Properties.setObjectPropertyObject obj "icon" (Nothing :: Maybe GdkPixbuf.Pixbuf.Pixbuf) + +#if ENABLE_OVERLOADING +data CompletionWordsIconPropertyInfo +instance AttrInfo CompletionWordsIconPropertyInfo where + type AttrAllowedOps CompletionWordsIconPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CompletionWordsIconPropertyInfo = GdkPixbuf.Pixbuf.IsPixbuf + type AttrBaseTypeConstraint CompletionWordsIconPropertyInfo = IsCompletionWords + type AttrGetType CompletionWordsIconPropertyInfo = (Maybe GdkPixbuf.Pixbuf.Pixbuf) + type AttrLabel CompletionWordsIconPropertyInfo = "icon" + type AttrOrigin CompletionWordsIconPropertyInfo = CompletionWords + attrGet _ = getCompletionWordsIcon + attrSet _ = setCompletionWordsIcon + attrConstruct _ = constructCompletionWordsIcon + attrClear _ = clearCompletionWordsIcon +#endif + +-- VVV Prop "interactive-delay" + -- Type: TBasicType TInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@interactive-delay@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completionWords #interactiveDelay +@ +-} +getCompletionWordsInteractiveDelay :: (MonadIO m, IsCompletionWords o) => o -> m Int32 +getCompletionWordsInteractiveDelay obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "interactive-delay" + +{- | +Set the value of the “@interactive-delay@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completionWords [ #interactiveDelay 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionWordsInteractiveDelay :: (MonadIO m, IsCompletionWords o) => o -> Int32 -> m () +setCompletionWordsInteractiveDelay obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "interactive-delay" val + +{- | +Construct a `GValueConstruct` with valid value for the “@interactive-delay@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionWordsInteractiveDelay :: (IsCompletionWords o) => Int32 -> IO (GValueConstruct o) +constructCompletionWordsInteractiveDelay val = B.Properties.constructObjectPropertyInt32 "interactive-delay" val + +#if ENABLE_OVERLOADING +data CompletionWordsInteractiveDelayPropertyInfo +instance AttrInfo CompletionWordsInteractiveDelayPropertyInfo where + type AttrAllowedOps CompletionWordsInteractiveDelayPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint CompletionWordsInteractiveDelayPropertyInfo = (~) Int32 + type AttrBaseTypeConstraint CompletionWordsInteractiveDelayPropertyInfo = IsCompletionWords + type AttrGetType CompletionWordsInteractiveDelayPropertyInfo = Int32 + type AttrLabel CompletionWordsInteractiveDelayPropertyInfo = "interactive-delay" + type AttrOrigin CompletionWordsInteractiveDelayPropertyInfo = CompletionWords + attrGet _ = getCompletionWordsInteractiveDelay + attrSet _ = setCompletionWordsInteractiveDelay + attrConstruct _ = constructCompletionWordsInteractiveDelay + attrClear _ = undefined +#endif + +-- VVV Prop "minimum-word-size" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@minimum-word-size@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completionWords #minimumWordSize +@ +-} +getCompletionWordsMinimumWordSize :: (MonadIO m, IsCompletionWords o) => o -> m Word32 +getCompletionWordsMinimumWordSize obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "minimum-word-size" + +{- | +Set the value of the “@minimum-word-size@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completionWords [ #minimumWordSize 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionWordsMinimumWordSize :: (MonadIO m, IsCompletionWords o) => o -> Word32 -> m () +setCompletionWordsMinimumWordSize obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "minimum-word-size" val + +{- | +Construct a `GValueConstruct` with valid value for the “@minimum-word-size@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionWordsMinimumWordSize :: (IsCompletionWords o) => Word32 -> IO (GValueConstruct o) +constructCompletionWordsMinimumWordSize val = B.Properties.constructObjectPropertyUInt32 "minimum-word-size" val + +#if ENABLE_OVERLOADING +data CompletionWordsMinimumWordSizePropertyInfo +instance AttrInfo CompletionWordsMinimumWordSizePropertyInfo where + type AttrAllowedOps CompletionWordsMinimumWordSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint CompletionWordsMinimumWordSizePropertyInfo = (~) Word32 + type AttrBaseTypeConstraint CompletionWordsMinimumWordSizePropertyInfo = IsCompletionWords + type AttrGetType CompletionWordsMinimumWordSizePropertyInfo = Word32 + type AttrLabel CompletionWordsMinimumWordSizePropertyInfo = "minimum-word-size" + type AttrOrigin CompletionWordsMinimumWordSizePropertyInfo = CompletionWords + attrGet _ = getCompletionWordsMinimumWordSize + attrSet _ = setCompletionWordsMinimumWordSize + attrConstruct _ = constructCompletionWordsMinimumWordSize + attrClear _ = undefined +#endif + +-- VVV Prop "name" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@name@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completionWords #name +@ +-} +getCompletionWordsName :: (MonadIO m, IsCompletionWords o) => o -> m (Maybe T.Text) +getCompletionWordsName obj = liftIO $ B.Properties.getObjectPropertyString obj "name" + +{- | +Set the value of the “@name@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completionWords [ #name 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionWordsName :: (MonadIO m, IsCompletionWords o) => o -> T.Text -> m () +setCompletionWordsName obj val = liftIO $ B.Properties.setObjectPropertyString obj "name" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionWordsName :: (IsCompletionWords o) => T.Text -> IO (GValueConstruct o) +constructCompletionWordsName val = B.Properties.constructObjectPropertyString "name" (Just val) + +{- | +Set the value of the “@name@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #name +@ +-} +clearCompletionWordsName :: (MonadIO m, IsCompletionWords o) => o -> m () +clearCompletionWordsName obj = liftIO $ B.Properties.setObjectPropertyString obj "name" (Nothing :: Maybe T.Text) + +#if ENABLE_OVERLOADING +data CompletionWordsNamePropertyInfo +instance AttrInfo CompletionWordsNamePropertyInfo where + type AttrAllowedOps CompletionWordsNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint CompletionWordsNamePropertyInfo = (~) T.Text + type AttrBaseTypeConstraint CompletionWordsNamePropertyInfo = IsCompletionWords + type AttrGetType CompletionWordsNamePropertyInfo = (Maybe T.Text) + type AttrLabel CompletionWordsNamePropertyInfo = "name" + type AttrOrigin CompletionWordsNamePropertyInfo = CompletionWords + attrGet _ = getCompletionWordsName + attrSet _ = setCompletionWordsName + attrConstruct _ = constructCompletionWordsName + attrClear _ = clearCompletionWordsName +#endif + +-- VVV Prop "priority" + -- Type: TBasicType TInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@priority@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completionWords #priority +@ +-} +getCompletionWordsPriority :: (MonadIO m, IsCompletionWords o) => o -> m Int32 +getCompletionWordsPriority obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "priority" + +{- | +Set the value of the “@priority@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completionWords [ #priority 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionWordsPriority :: (MonadIO m, IsCompletionWords o) => o -> Int32 -> m () +setCompletionWordsPriority obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "priority" val + +{- | +Construct a `GValueConstruct` with valid value for the “@priority@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionWordsPriority :: (IsCompletionWords o) => Int32 -> IO (GValueConstruct o) +constructCompletionWordsPriority val = B.Properties.constructObjectPropertyInt32 "priority" val + +#if ENABLE_OVERLOADING +data CompletionWordsPriorityPropertyInfo +instance AttrInfo CompletionWordsPriorityPropertyInfo where + type AttrAllowedOps CompletionWordsPriorityPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint CompletionWordsPriorityPropertyInfo = (~) Int32 + type AttrBaseTypeConstraint CompletionWordsPriorityPropertyInfo = IsCompletionWords + type AttrGetType CompletionWordsPriorityPropertyInfo = Int32 + type AttrLabel CompletionWordsPriorityPropertyInfo = "priority" + type AttrOrigin CompletionWordsPriorityPropertyInfo = CompletionWords + attrGet _ = getCompletionWordsPriority + attrSet _ = setCompletionWordsPriority + attrConstruct _ = constructCompletionWordsPriority + attrClear _ = undefined +#endif + +-- VVV Prop "proposals-batch-size" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@proposals-batch-size@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completionWords #proposalsBatchSize +@ +-} +getCompletionWordsProposalsBatchSize :: (MonadIO m, IsCompletionWords o) => o -> m Word32 +getCompletionWordsProposalsBatchSize obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "proposals-batch-size" + +{- | +Set the value of the “@proposals-batch-size@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completionWords [ #proposalsBatchSize 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionWordsProposalsBatchSize :: (MonadIO m, IsCompletionWords o) => o -> Word32 -> m () +setCompletionWordsProposalsBatchSize obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "proposals-batch-size" val + +{- | +Construct a `GValueConstruct` with valid value for the “@proposals-batch-size@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionWordsProposalsBatchSize :: (IsCompletionWords o) => Word32 -> IO (GValueConstruct o) +constructCompletionWordsProposalsBatchSize val = B.Properties.constructObjectPropertyUInt32 "proposals-batch-size" val + +#if ENABLE_OVERLOADING +data CompletionWordsProposalsBatchSizePropertyInfo +instance AttrInfo CompletionWordsProposalsBatchSizePropertyInfo where + type AttrAllowedOps CompletionWordsProposalsBatchSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint CompletionWordsProposalsBatchSizePropertyInfo = (~) Word32 + type AttrBaseTypeConstraint CompletionWordsProposalsBatchSizePropertyInfo = IsCompletionWords + type AttrGetType CompletionWordsProposalsBatchSizePropertyInfo = Word32 + type AttrLabel CompletionWordsProposalsBatchSizePropertyInfo = "proposals-batch-size" + type AttrOrigin CompletionWordsProposalsBatchSizePropertyInfo = CompletionWords + attrGet _ = getCompletionWordsProposalsBatchSize + attrSet _ = setCompletionWordsProposalsBatchSize + attrConstruct _ = constructCompletionWordsProposalsBatchSize + attrClear _ = undefined +#endif + +-- VVV Prop "scan-batch-size" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@scan-batch-size@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' completionWords #scanBatchSize +@ +-} +getCompletionWordsScanBatchSize :: (MonadIO m, IsCompletionWords o) => o -> m Word32 +getCompletionWordsScanBatchSize obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "scan-batch-size" + +{- | +Set the value of the “@scan-batch-size@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' completionWords [ #scanBatchSize 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setCompletionWordsScanBatchSize :: (MonadIO m, IsCompletionWords o) => o -> Word32 -> m () +setCompletionWordsScanBatchSize obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "scan-batch-size" val + +{- | +Construct a `GValueConstruct` with valid value for the “@scan-batch-size@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructCompletionWordsScanBatchSize :: (IsCompletionWords o) => Word32 -> IO (GValueConstruct o) +constructCompletionWordsScanBatchSize val = B.Properties.constructObjectPropertyUInt32 "scan-batch-size" val + +#if ENABLE_OVERLOADING +data CompletionWordsScanBatchSizePropertyInfo +instance AttrInfo CompletionWordsScanBatchSizePropertyInfo where + type AttrAllowedOps CompletionWordsScanBatchSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint CompletionWordsScanBatchSizePropertyInfo = (~) Word32 + type AttrBaseTypeConstraint CompletionWordsScanBatchSizePropertyInfo = IsCompletionWords + type AttrGetType CompletionWordsScanBatchSizePropertyInfo = Word32 + type AttrLabel CompletionWordsScanBatchSizePropertyInfo = "scan-batch-size" + type AttrOrigin CompletionWordsScanBatchSizePropertyInfo = CompletionWords + attrGet _ = getCompletionWordsScanBatchSize + attrSet _ = setCompletionWordsScanBatchSize + attrConstruct _ = constructCompletionWordsScanBatchSize + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList CompletionWords +type instance O.AttributeList CompletionWords = CompletionWordsAttributeList +type CompletionWordsAttributeList = ('[ '("activation", CompletionWordsActivationPropertyInfo), '("icon", CompletionWordsIconPropertyInfo), '("interactiveDelay", CompletionWordsInteractiveDelayPropertyInfo), '("minimumWordSize", CompletionWordsMinimumWordSizePropertyInfo), '("name", CompletionWordsNamePropertyInfo), '("priority", CompletionWordsPriorityPropertyInfo), '("proposalsBatchSize", CompletionWordsProposalsBatchSizePropertyInfo), '("scanBatchSize", CompletionWordsScanBatchSizePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +completionWordsActivation :: AttrLabelProxy "activation" +completionWordsActivation = AttrLabelProxy + +completionWordsIcon :: AttrLabelProxy "icon" +completionWordsIcon = AttrLabelProxy + +completionWordsInteractiveDelay :: AttrLabelProxy "interactiveDelay" +completionWordsInteractiveDelay = AttrLabelProxy + +completionWordsMinimumWordSize :: AttrLabelProxy "minimumWordSize" +completionWordsMinimumWordSize = AttrLabelProxy + +completionWordsName :: AttrLabelProxy "name" +completionWordsName = AttrLabelProxy + +completionWordsPriority :: AttrLabelProxy "priority" +completionWordsPriority = AttrLabelProxy + +completionWordsProposalsBatchSize :: AttrLabelProxy "proposalsBatchSize" +completionWordsProposalsBatchSize = AttrLabelProxy + +completionWordsScanBatchSize :: AttrLabelProxy "scanBatchSize" +completionWordsScanBatchSize = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList CompletionWords = CompletionWordsSignalList +type CompletionWordsSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method CompletionWords::new +-- method type : Constructor +-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The name for the provider, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "icon", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A specific icon for the provider, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "CompletionWords"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_completion_words_new" gtk_source_completion_words_new :: + CString -> -- name : TBasicType TUTF8 + Ptr GdkPixbuf.Pixbuf.Pixbuf -> -- icon : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}) + IO (Ptr CompletionWords) + +{- | +/No description available in the introspection data./ +-} +completionWordsNew :: + (B.CallStack.HasCallStack, MonadIO m, GdkPixbuf.Pixbuf.IsPixbuf a) => + Maybe (T.Text) + {- ^ /@name@/: The name for the provider, or 'Nothing'. -} + -> Maybe (a) + {- ^ /@icon@/: A specific icon for the provider, or 'Nothing'. -} + -> m CompletionWords + {- ^ __Returns:__ a new 'GI.GtkSource.Objects.CompletionWords.CompletionWords' provider -} +completionWordsNew name icon = liftIO $ do + maybeName <- case name of + Nothing -> return nullPtr + Just jName -> do + jName' <- textToCString jName + return jName' + maybeIcon <- case icon of + Nothing -> return nullPtr + Just jIcon -> do + jIcon' <- unsafeManagedPtrCastPtr jIcon + return jIcon' + result <- gtk_source_completion_words_new maybeName maybeIcon + checkUnexpectedReturnNULL "completionWordsNew" result + result' <- (wrapObject CompletionWords) result + whenJust icon touchManagedPtr + freeMem maybeName + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method CompletionWords::register +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "words", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionWords"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionWords", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_completion_words_register" gtk_source_completion_words_register :: + Ptr CompletionWords -> -- words : TInterface (Name {namespace = "GtkSource", name = "CompletionWords"}) + Ptr Gtk.TextBuffer.TextBuffer -> -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"}) + IO () + +{- | +Registers /@buffer@/ in the /@words@/ provider. +-} +completionWordsRegister :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletionWords a, Gtk.TextBuffer.IsTextBuffer b) => + a + {- ^ /@words@/: a 'GI.GtkSource.Objects.CompletionWords.CompletionWords' -} + -> b + {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -} + -> m () +completionWordsRegister words buffer = liftIO $ do + words' <- unsafeManagedPtrCastPtr words + buffer' <- unsafeManagedPtrCastPtr buffer + gtk_source_completion_words_register words' buffer' + touchManagedPtr words + touchManagedPtr buffer + return () + +#if ENABLE_OVERLOADING +data CompletionWordsRegisterMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsCompletionWords a, Gtk.TextBuffer.IsTextBuffer b) => O.MethodInfo CompletionWordsRegisterMethodInfo a signature where + overloadedMethod _ = completionWordsRegister + +#endif + +-- method CompletionWords::unregister +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "words", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionWords"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionWords", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_completion_words_unregister" gtk_source_completion_words_unregister :: + Ptr CompletionWords -> -- words : TInterface (Name {namespace = "GtkSource", name = "CompletionWords"}) + Ptr Gtk.TextBuffer.TextBuffer -> -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"}) + IO () + +{- | +Unregisters /@buffer@/ from the /@words@/ provider. +-} +completionWordsUnregister :: + (B.CallStack.HasCallStack, MonadIO m, IsCompletionWords a, Gtk.TextBuffer.IsTextBuffer b) => + a + {- ^ /@words@/: a 'GI.GtkSource.Objects.CompletionWords.CompletionWords' -} + -> b + {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -} + -> m () +completionWordsUnregister words buffer = liftIO $ do + words' <- unsafeManagedPtrCastPtr words + buffer' <- unsafeManagedPtrCastPtr buffer + gtk_source_completion_words_unregister words' buffer' + touchManagedPtr words + touchManagedPtr buffer + return () + +#if ENABLE_OVERLOADING +data CompletionWordsUnregisterMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsCompletionWords a, Gtk.TextBuffer.IsTextBuffer b) => O.MethodInfo CompletionWordsUnregisterMethodInfo a signature where + overloadedMethod _ = completionWordsUnregister + +#endif + + diff --git a/GI/GtkSource/Objects/CompletionWords.hs-boot b/GI/GtkSource/Objects/CompletionWords.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/CompletionWords.hs-boot @@ -0,0 +1,59 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.CompletionWords 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 CompletionWords = CompletionWords (ManagedPtr CompletionWords) +instance GObject CompletionWords where +class (GObject o, O.IsDescendantOf CompletionWords o) => IsCompletionWords o +instance (GObject o, O.IsDescendantOf CompletionWords o) => IsCompletionWords o +instance O.HasParentTypes CompletionWords +#if ENABLE_OVERLOADING +data CompletionWordsActivationPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionWordsIconPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionWordsInteractiveDelayPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionWordsMinimumWordSizePropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionWordsNamePropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionWordsPriorityPropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionWordsProposalsBatchSizePropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionWordsScanBatchSizePropertyInfo +#endif +#if ENABLE_OVERLOADING +data CompletionWordsRegisterMethodInfo +#endif +#if ENABLE_OVERLOADING +data CompletionWordsUnregisterMethodInfo +#endif diff --git a/GI/GtkSource/Objects/File.hs b/GI/GtkSource/Objects/File.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/File.hs @@ -0,0 +1,926 @@ + + +{- | +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.File + ( + +-- * Exported types + File(..) , + IsFile , + toFile , + noFile , + + + -- * Methods +-- ** checkFileOnDisk #method:checkFileOnDisk# + +#if ENABLE_OVERLOADING + FileCheckFileOnDiskMethodInfo , +#endif + fileCheckFileOnDisk , + + +-- ** getCompressionType #method:getCompressionType# + +#if ENABLE_OVERLOADING + FileGetCompressionTypeMethodInfo , +#endif + fileGetCompressionType , + + +-- ** getEncoding #method:getEncoding# + +#if ENABLE_OVERLOADING + FileGetEncodingMethodInfo , +#endif + fileGetEncoding , + + +-- ** getLocation #method:getLocation# + +#if ENABLE_OVERLOADING + FileGetLocationMethodInfo , +#endif + fileGetLocation , + + +-- ** getNewlineType #method:getNewlineType# + +#if ENABLE_OVERLOADING + FileGetNewlineTypeMethodInfo , +#endif + fileGetNewlineType , + + +-- ** isDeleted #method:isDeleted# + +#if ENABLE_OVERLOADING + FileIsDeletedMethodInfo , +#endif + fileIsDeleted , + + +-- ** isExternallyModified #method:isExternallyModified# + +#if ENABLE_OVERLOADING + FileIsExternallyModifiedMethodInfo , +#endif + fileIsExternallyModified , + + +-- ** isLocal #method:isLocal# + +#if ENABLE_OVERLOADING + FileIsLocalMethodInfo , +#endif + fileIsLocal , + + +-- ** isReadonly #method:isReadonly# + +#if ENABLE_OVERLOADING + FileIsReadonlyMethodInfo , +#endif + fileIsReadonly , + + +-- ** new #method:new# + + fileNew , + + +-- ** setLocation #method:setLocation# + +#if ENABLE_OVERLOADING + FileSetLocationMethodInfo , +#endif + fileSetLocation , + + + + + -- * Properties +-- ** compressionType #attr:compressionType# +{- | The compression type. + +/Since: 3.14/ +-} +#if ENABLE_OVERLOADING + FileCompressionTypePropertyInfo , +#endif +#if ENABLE_OVERLOADING + fileCompressionType , +#endif + getFileCompressionType , + + +-- ** encoding #attr:encoding# +{- | The character encoding, initially 'Nothing'. After a successful file +loading or saving operation, the encoding is non-'Nothing'. + +/Since: 3.14/ +-} +#if ENABLE_OVERLOADING + FileEncodingPropertyInfo , +#endif +#if ENABLE_OVERLOADING + fileEncoding , +#endif + getFileEncoding , + + +-- ** location #attr:location# +{- | The location. + +/Since: 3.14/ +-} +#if ENABLE_OVERLOADING + FileLocationPropertyInfo , +#endif + clearFileLocation , + constructFileLocation , +#if ENABLE_OVERLOADING + fileLocation , +#endif + getFileLocation , + setFileLocation , + + +-- ** newlineType #attr:newlineType# +{- | The line ending type. + +/Since: 3.14/ +-} +#if ENABLE_OVERLOADING + FileNewlineTypePropertyInfo , +#endif +#if ENABLE_OVERLOADING + fileNewlineType , +#endif + getFileNewlineType , + + +-- ** readOnly #attr:readOnly# +{- | Whether the file is read-only or not. The value of this property is +not updated automatically (there is no file monitors). + +/Since: 3.18/ +-} +#if ENABLE_OVERLOADING + FileReadOnlyPropertyInfo , +#endif +#if ENABLE_OVERLOADING + fileReadOnly , +#endif + getFileReadOnly , + + + + + ) 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.Gio.Interfaces.File as Gio.File +import {-# SOURCE #-} qualified GI.GtkSource.Enums as GtkSource.Enums +import {-# SOURCE #-} qualified GI.GtkSource.Structs.Encoding as GtkSource.Encoding + +-- | Memory-managed wrapper type. +newtype File = File (ManagedPtr File) +foreign import ccall "gtk_source_file_get_type" + c_gtk_source_file_get_type :: IO GType + +instance GObject File where + gobjectType = c_gtk_source_file_get_type + + +-- | Type class for types which can be safely cast to `File`, for instance with `toFile`. +class (GObject o, O.IsDescendantOf File o) => IsFile o +instance (GObject o, O.IsDescendantOf File o) => IsFile o + +instance O.HasParentTypes File +type instance O.ParentTypes File = '[GObject.Object.Object] + +-- | Cast to `File`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toFile :: (MonadIO m, IsFile o) => o -> m File +toFile = liftIO . unsafeCastTo File + +-- | A convenience alias for `Nothing` :: `Maybe` `File`. +noFile :: Maybe File +noFile = Nothing + +#if ENABLE_OVERLOADING +type family ResolveFileMethod (t :: Symbol) (o :: *) :: * where + ResolveFileMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveFileMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveFileMethod "checkFileOnDisk" o = FileCheckFileOnDiskMethodInfo + ResolveFileMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveFileMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveFileMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveFileMethod "isDeleted" o = FileIsDeletedMethodInfo + ResolveFileMethod "isExternallyModified" o = FileIsExternallyModifiedMethodInfo + ResolveFileMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveFileMethod "isLocal" o = FileIsLocalMethodInfo + ResolveFileMethod "isReadonly" o = FileIsReadonlyMethodInfo + ResolveFileMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveFileMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveFileMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveFileMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveFileMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveFileMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveFileMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveFileMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveFileMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveFileMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveFileMethod "getCompressionType" o = FileGetCompressionTypeMethodInfo + ResolveFileMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveFileMethod "getEncoding" o = FileGetEncodingMethodInfo + ResolveFileMethod "getLocation" o = FileGetLocationMethodInfo + ResolveFileMethod "getNewlineType" o = FileGetNewlineTypeMethodInfo + ResolveFileMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveFileMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveFileMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveFileMethod "setLocation" o = FileSetLocationMethodInfo + ResolveFileMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveFileMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveFileMethod t File, O.MethodInfo info File p) => OL.IsLabel t (File -> 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 + +-- VVV Prop "compression-type" + -- Type: TInterface (Name {namespace = "GtkSource", name = "CompressionType"}) + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@compression-type@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' file #compressionType +@ +-} +getFileCompressionType :: (MonadIO m, IsFile o) => o -> m GtkSource.Enums.CompressionType +getFileCompressionType obj = liftIO $ B.Properties.getObjectPropertyEnum obj "compression-type" + +#if ENABLE_OVERLOADING +data FileCompressionTypePropertyInfo +instance AttrInfo FileCompressionTypePropertyInfo where + type AttrAllowedOps FileCompressionTypePropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint FileCompressionTypePropertyInfo = (~) () + type AttrBaseTypeConstraint FileCompressionTypePropertyInfo = IsFile + type AttrGetType FileCompressionTypePropertyInfo = GtkSource.Enums.CompressionType + type AttrLabel FileCompressionTypePropertyInfo = "compression-type" + type AttrOrigin FileCompressionTypePropertyInfo = File + attrGet _ = getFileCompressionType + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "encoding" + -- Type: TInterface (Name {namespace = "GtkSource", name = "Encoding"}) + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@encoding@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' file #encoding +@ +-} +getFileEncoding :: (MonadIO m, IsFile o) => o -> m GtkSource.Encoding.Encoding +getFileEncoding obj = liftIO $ checkUnexpectedNothing "getFileEncoding" $ B.Properties.getObjectPropertyBoxed obj "encoding" GtkSource.Encoding.Encoding + +#if ENABLE_OVERLOADING +data FileEncodingPropertyInfo +instance AttrInfo FileEncodingPropertyInfo where + type AttrAllowedOps FileEncodingPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint FileEncodingPropertyInfo = (~) () + type AttrBaseTypeConstraint FileEncodingPropertyInfo = IsFile + type AttrGetType FileEncodingPropertyInfo = GtkSource.Encoding.Encoding + type AttrLabel FileEncodingPropertyInfo = "encoding" + type AttrOrigin FileEncodingPropertyInfo = File + attrGet _ = getFileEncoding + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "location" + -- Type: TInterface (Name {namespace = "Gio", name = "File"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just True) + +{- | +Get the value of the “@location@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' file #location +@ +-} +getFileLocation :: (MonadIO m, IsFile o) => o -> m Gio.File.File +getFileLocation obj = liftIO $ checkUnexpectedNothing "getFileLocation" $ B.Properties.getObjectPropertyObject obj "location" Gio.File.File + +{- | +Set the value of the “@location@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' file [ #location 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setFileLocation :: (MonadIO m, IsFile o, Gio.File.IsFile a) => o -> a -> m () +setFileLocation obj val = liftIO $ B.Properties.setObjectPropertyObject obj "location" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@location@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructFileLocation :: (IsFile o, Gio.File.IsFile a) => a -> IO (GValueConstruct o) +constructFileLocation val = B.Properties.constructObjectPropertyObject "location" (Just val) + +{- | +Set the value of the “@location@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #location +@ +-} +clearFileLocation :: (MonadIO m, IsFile o) => o -> m () +clearFileLocation obj = liftIO $ B.Properties.setObjectPropertyObject obj "location" (Nothing :: Maybe Gio.File.File) + +#if ENABLE_OVERLOADING +data FileLocationPropertyInfo +instance AttrInfo FileLocationPropertyInfo where + type AttrAllowedOps FileLocationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint FileLocationPropertyInfo = Gio.File.IsFile + type AttrBaseTypeConstraint FileLocationPropertyInfo = IsFile + type AttrGetType FileLocationPropertyInfo = Gio.File.File + type AttrLabel FileLocationPropertyInfo = "location" + type AttrOrigin FileLocationPropertyInfo = File + attrGet _ = getFileLocation + attrSet _ = setFileLocation + attrConstruct _ = constructFileLocation + attrClear _ = clearFileLocation +#endif + +-- VVV Prop "newline-type" + -- Type: TInterface (Name {namespace = "GtkSource", name = "NewlineType"}) + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@newline-type@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' file #newlineType +@ +-} +getFileNewlineType :: (MonadIO m, IsFile o) => o -> m GtkSource.Enums.NewlineType +getFileNewlineType obj = liftIO $ B.Properties.getObjectPropertyEnum obj "newline-type" + +#if ENABLE_OVERLOADING +data FileNewlineTypePropertyInfo +instance AttrInfo FileNewlineTypePropertyInfo where + type AttrAllowedOps FileNewlineTypePropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint FileNewlineTypePropertyInfo = (~) () + type AttrBaseTypeConstraint FileNewlineTypePropertyInfo = IsFile + type AttrGetType FileNewlineTypePropertyInfo = GtkSource.Enums.NewlineType + type AttrLabel FileNewlineTypePropertyInfo = "newline-type" + type AttrOrigin FileNewlineTypePropertyInfo = File + attrGet _ = getFileNewlineType + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "read-only" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@read-only@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' file #readOnly +@ +-} +getFileReadOnly :: (MonadIO m, IsFile o) => o -> m Bool +getFileReadOnly obj = liftIO $ B.Properties.getObjectPropertyBool obj "read-only" + +#if ENABLE_OVERLOADING +data FileReadOnlyPropertyInfo +instance AttrInfo FileReadOnlyPropertyInfo where + type AttrAllowedOps FileReadOnlyPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint FileReadOnlyPropertyInfo = (~) () + type AttrBaseTypeConstraint FileReadOnlyPropertyInfo = IsFile + type AttrGetType FileReadOnlyPropertyInfo = Bool + type AttrLabel FileReadOnlyPropertyInfo = "read-only" + type AttrOrigin FileReadOnlyPropertyInfo = File + attrGet _ = getFileReadOnly + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList File +type instance O.AttributeList File = FileAttributeList +type FileAttributeList = ('[ '("compressionType", FileCompressionTypePropertyInfo), '("encoding", FileEncodingPropertyInfo), '("location", FileLocationPropertyInfo), '("newlineType", FileNewlineTypePropertyInfo), '("readOnly", FileReadOnlyPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +fileCompressionType :: AttrLabelProxy "compressionType" +fileCompressionType = AttrLabelProxy + +fileEncoding :: AttrLabelProxy "encoding" +fileEncoding = AttrLabelProxy + +fileLocation :: AttrLabelProxy "location" +fileLocation = AttrLabelProxy + +fileNewlineType :: AttrLabelProxy "newlineType" +fileNewlineType = AttrLabelProxy + +fileReadOnly :: AttrLabelProxy "readOnly" +fileReadOnly = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList File = FileSignalList +type FileSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method File::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "File"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_file_new" gtk_source_file_new :: + IO (Ptr File) + +{- | +/No description available in the introspection data./ + +/Since: 3.14/ +-} +fileNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m File + {- ^ __Returns:__ a new 'GI.GtkSource.Objects.File.File' object. -} +fileNew = liftIO $ do + result <- gtk_source_file_new + checkUnexpectedReturnNULL "fileNew" result + result' <- (wrapObject File) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method File::check_file_on_disk +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "file", argType = TInterface (Name {namespace = "GtkSource", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFile.", 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_file_check_file_on_disk" gtk_source_file_check_file_on_disk :: + Ptr File -> -- file : TInterface (Name {namespace = "GtkSource", name = "File"}) + IO () + +{- | +Checks synchronously the file on disk, to know whether the file is externally +modified, or has been deleted, and whether the file is read-only. + +'GI.GtkSource.Objects.File.File' doesn\'t create a 'GI.Gio.Objects.FileMonitor.FileMonitor' to track those properties, so +this function needs to be called instead. Creating lots of 'GI.Gio.Objects.FileMonitor.FileMonitor'\'s +would take lots of resources. + +Since this function is synchronous, it is advised to call it only on local +files. See 'GI.GtkSource.Objects.File.fileIsLocal'. + +/Since: 3.18/ +-} +fileCheckFileOnDisk :: + (B.CallStack.HasCallStack, MonadIO m, IsFile a) => + a + {- ^ /@file@/: a 'GI.GtkSource.Objects.File.File'. -} + -> m () +fileCheckFileOnDisk file = liftIO $ do + file' <- unsafeManagedPtrCastPtr file + gtk_source_file_check_file_on_disk file' + touchManagedPtr file + return () + +#if ENABLE_OVERLOADING +data FileCheckFileOnDiskMethodInfo +instance (signature ~ (m ()), MonadIO m, IsFile a) => O.MethodInfo FileCheckFileOnDiskMethodInfo a signature where + overloadedMethod _ = fileCheckFileOnDisk + +#endif + +-- method File::get_compression_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "file", argType = TInterface (Name {namespace = "GtkSource", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFile.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "CompressionType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_file_get_compression_type" gtk_source_file_get_compression_type :: + Ptr File -> -- file : TInterface (Name {namespace = "GtkSource", name = "File"}) + IO CUInt + +{- | +/No description available in the introspection data./ + +/Since: 3.14/ +-} +fileGetCompressionType :: + (B.CallStack.HasCallStack, MonadIO m, IsFile a) => + a + {- ^ /@file@/: a 'GI.GtkSource.Objects.File.File'. -} + -> m GtkSource.Enums.CompressionType + {- ^ __Returns:__ the compression type. -} +fileGetCompressionType file = liftIO $ do + file' <- unsafeManagedPtrCastPtr file + result <- gtk_source_file_get_compression_type file' + let result' = (toEnum . fromIntegral) result + touchManagedPtr file + return result' + +#if ENABLE_OVERLOADING +data FileGetCompressionTypeMethodInfo +instance (signature ~ (m GtkSource.Enums.CompressionType), MonadIO m, IsFile a) => O.MethodInfo FileGetCompressionTypeMethodInfo a signature where + overloadedMethod _ = fileGetCompressionType + +#endif + +-- method File::get_encoding +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "file", argType = TInterface (Name {namespace = "GtkSource", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFile.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Encoding"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_file_get_encoding" gtk_source_file_get_encoding :: + Ptr File -> -- file : TInterface (Name {namespace = "GtkSource", name = "File"}) + IO (Ptr GtkSource.Encoding.Encoding) + +{- | +The encoding is initially 'Nothing'. After a successful file loading or saving +operation, the encoding is non-'Nothing'. + +/Since: 3.14/ +-} +fileGetEncoding :: + (B.CallStack.HasCallStack, MonadIO m, IsFile a) => + a + {- ^ /@file@/: a 'GI.GtkSource.Objects.File.File'. -} + -> m GtkSource.Encoding.Encoding + {- ^ __Returns:__ the character encoding. -} +fileGetEncoding file = liftIO $ do + file' <- unsafeManagedPtrCastPtr file + result <- gtk_source_file_get_encoding file' + checkUnexpectedReturnNULL "fileGetEncoding" result + result' <- (newBoxed GtkSource.Encoding.Encoding) result + touchManagedPtr file + return result' + +#if ENABLE_OVERLOADING +data FileGetEncodingMethodInfo +instance (signature ~ (m GtkSource.Encoding.Encoding), MonadIO m, IsFile a) => O.MethodInfo FileGetEncodingMethodInfo a signature where + overloadedMethod _ = fileGetEncoding + +#endif + +-- method File::get_location +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "file", argType = TInterface (Name {namespace = "GtkSource", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFile.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gio", name = "File"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_file_get_location" gtk_source_file_get_location :: + Ptr File -> -- file : TInterface (Name {namespace = "GtkSource", name = "File"}) + IO (Ptr Gio.File.File) + +{- | +/No description available in the introspection data./ + +/Since: 3.14/ +-} +fileGetLocation :: + (B.CallStack.HasCallStack, MonadIO m, IsFile a) => + a + {- ^ /@file@/: a 'GI.GtkSource.Objects.File.File'. -} + -> m Gio.File.File + {- ^ __Returns:__ the 'GI.Gio.Interfaces.File.File'. -} +fileGetLocation file = liftIO $ do + file' <- unsafeManagedPtrCastPtr file + result <- gtk_source_file_get_location file' + checkUnexpectedReturnNULL "fileGetLocation" result + result' <- (newObject Gio.File.File) result + touchManagedPtr file + return result' + +#if ENABLE_OVERLOADING +data FileGetLocationMethodInfo +instance (signature ~ (m Gio.File.File), MonadIO m, IsFile a) => O.MethodInfo FileGetLocationMethodInfo a signature where + overloadedMethod _ = fileGetLocation + +#endif + +-- method File::get_newline_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "file", argType = TInterface (Name {namespace = "GtkSource", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFile.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "NewlineType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_file_get_newline_type" gtk_source_file_get_newline_type :: + Ptr File -> -- file : TInterface (Name {namespace = "GtkSource", name = "File"}) + IO CUInt + +{- | +/No description available in the introspection data./ + +/Since: 3.14/ +-} +fileGetNewlineType :: + (B.CallStack.HasCallStack, MonadIO m, IsFile a) => + a + {- ^ /@file@/: a 'GI.GtkSource.Objects.File.File'. -} + -> m GtkSource.Enums.NewlineType + {- ^ __Returns:__ the newline type. -} +fileGetNewlineType file = liftIO $ do + file' <- unsafeManagedPtrCastPtr file + result <- gtk_source_file_get_newline_type file' + let result' = (toEnum . fromIntegral) result + touchManagedPtr file + return result' + +#if ENABLE_OVERLOADING +data FileGetNewlineTypeMethodInfo +instance (signature ~ (m GtkSource.Enums.NewlineType), MonadIO m, IsFile a) => O.MethodInfo FileGetNewlineTypeMethodInfo a signature where + overloadedMethod _ = fileGetNewlineType + +#endif + +-- method File::is_deleted +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "file", argType = TInterface (Name {namespace = "GtkSource", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFile.", 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_file_is_deleted" gtk_source_file_is_deleted :: + Ptr File -> -- file : TInterface (Name {namespace = "GtkSource", name = "File"}) + IO CInt + +{- | +Returns whether the file has been deleted. If the +'GI.GtkSource.Objects.File.File':@/location/@ is 'Nothing', returns 'False'. + +To have an up-to-date value, you must first call +'GI.GtkSource.Objects.File.fileCheckFileOnDisk'. + +/Since: 3.18/ +-} +fileIsDeleted :: + (B.CallStack.HasCallStack, MonadIO m, IsFile a) => + a + {- ^ /@file@/: a 'GI.GtkSource.Objects.File.File'. -} + -> m Bool + {- ^ __Returns:__ whether the file has been deleted. -} +fileIsDeleted file = liftIO $ do + file' <- unsafeManagedPtrCastPtr file + result <- gtk_source_file_is_deleted file' + let result' = (/= 0) result + touchManagedPtr file + return result' + +#if ENABLE_OVERLOADING +data FileIsDeletedMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsFile a) => O.MethodInfo FileIsDeletedMethodInfo a signature where + overloadedMethod _ = fileIsDeleted + +#endif + +-- method File::is_externally_modified +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "file", argType = TInterface (Name {namespace = "GtkSource", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFile.", 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_file_is_externally_modified" gtk_source_file_is_externally_modified :: + Ptr File -> -- file : TInterface (Name {namespace = "GtkSource", name = "File"}) + IO CInt + +{- | +Returns whether the file is externally modified. If the +'GI.GtkSource.Objects.File.File':@/location/@ is 'Nothing', returns 'False'. + +To have an up-to-date value, you must first call +'GI.GtkSource.Objects.File.fileCheckFileOnDisk'. + +/Since: 3.18/ +-} +fileIsExternallyModified :: + (B.CallStack.HasCallStack, MonadIO m, IsFile a) => + a + {- ^ /@file@/: a 'GI.GtkSource.Objects.File.File'. -} + -> m Bool + {- ^ __Returns:__ whether the file is externally modified. -} +fileIsExternallyModified file = liftIO $ do + file' <- unsafeManagedPtrCastPtr file + result <- gtk_source_file_is_externally_modified file' + let result' = (/= 0) result + touchManagedPtr file + return result' + +#if ENABLE_OVERLOADING +data FileIsExternallyModifiedMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsFile a) => O.MethodInfo FileIsExternallyModifiedMethodInfo a signature where + overloadedMethod _ = fileIsExternallyModified + +#endif + +-- method File::is_local +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "file", argType = TInterface (Name {namespace = "GtkSource", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFile.", 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_file_is_local" gtk_source_file_is_local :: + Ptr File -> -- file : TInterface (Name {namespace = "GtkSource", name = "File"}) + IO CInt + +{- | +Returns whether the file is local. If the 'GI.GtkSource.Objects.File.File':@/location/@ is 'Nothing', +returns 'False'. + +/Since: 3.18/ +-} +fileIsLocal :: + (B.CallStack.HasCallStack, MonadIO m, IsFile a) => + a + {- ^ /@file@/: a 'GI.GtkSource.Objects.File.File'. -} + -> m Bool + {- ^ __Returns:__ whether the file is local. -} +fileIsLocal file = liftIO $ do + file' <- unsafeManagedPtrCastPtr file + result <- gtk_source_file_is_local file' + let result' = (/= 0) result + touchManagedPtr file + return result' + +#if ENABLE_OVERLOADING +data FileIsLocalMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsFile a) => O.MethodInfo FileIsLocalMethodInfo a signature where + overloadedMethod _ = fileIsLocal + +#endif + +-- method File::is_readonly +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "file", argType = TInterface (Name {namespace = "GtkSource", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFile.", 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_file_is_readonly" gtk_source_file_is_readonly :: + Ptr File -> -- file : TInterface (Name {namespace = "GtkSource", name = "File"}) + IO CInt + +{- | +Returns whether the file is read-only. If the +'GI.GtkSource.Objects.File.File':@/location/@ is 'Nothing', returns 'False'. + +To have an up-to-date value, you must first call +'GI.GtkSource.Objects.File.fileCheckFileOnDisk'. + +/Since: 3.18/ +-} +fileIsReadonly :: + (B.CallStack.HasCallStack, MonadIO m, IsFile a) => + a + {- ^ /@file@/: a 'GI.GtkSource.Objects.File.File'. -} + -> m Bool + {- ^ __Returns:__ whether the file is read-only. -} +fileIsReadonly file = liftIO $ do + file' <- unsafeManagedPtrCastPtr file + result <- gtk_source_file_is_readonly file' + let result' = (/= 0) result + touchManagedPtr file + return result' + +#if ENABLE_OVERLOADING +data FileIsReadonlyMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsFile a) => O.MethodInfo FileIsReadonlyMethodInfo a signature where + overloadedMethod _ = fileIsReadonly + +#endif + +-- method File::set_location +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "file", argType = TInterface (Name {namespace = "GtkSource", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFile.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "location", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the new #GFile, 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_file_set_location" gtk_source_file_set_location :: + Ptr File -> -- file : TInterface (Name {namespace = "GtkSource", name = "File"}) + Ptr Gio.File.File -> -- location : TInterface (Name {namespace = "Gio", name = "File"}) + IO () + +{- | +Sets the location. + +/Since: 3.14/ +-} +fileSetLocation :: + (B.CallStack.HasCallStack, MonadIO m, IsFile a, Gio.File.IsFile b) => + a + {- ^ /@file@/: a 'GI.GtkSource.Objects.File.File'. -} + -> Maybe (b) + {- ^ /@location@/: the new 'GI.Gio.Interfaces.File.File', or 'Nothing'. -} + -> m () +fileSetLocation file location = liftIO $ do + file' <- unsafeManagedPtrCastPtr file + maybeLocation <- case location of + Nothing -> return nullPtr + Just jLocation -> do + jLocation' <- unsafeManagedPtrCastPtr jLocation + return jLocation' + gtk_source_file_set_location file' maybeLocation + touchManagedPtr file + whenJust location touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data FileSetLocationMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsFile a, Gio.File.IsFile b) => O.MethodInfo FileSetLocationMethodInfo a signature where + overloadedMethod _ = fileSetLocation + +#endif + + diff --git a/GI/GtkSource/Objects/File.hs-boot b/GI/GtkSource/Objects/File.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/File.hs-boot @@ -0,0 +1,74 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.File 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 File = File (ManagedPtr File) +instance GObject File where +class (GObject o, O.IsDescendantOf File o) => IsFile o +instance (GObject o, O.IsDescendantOf File o) => IsFile o +instance O.HasParentTypes File +#if ENABLE_OVERLOADING +data FileCompressionTypePropertyInfo +#endif +#if ENABLE_OVERLOADING +data FileEncodingPropertyInfo +#endif +#if ENABLE_OVERLOADING +data FileLocationPropertyInfo +#endif +#if ENABLE_OVERLOADING +data FileNewlineTypePropertyInfo +#endif +#if ENABLE_OVERLOADING +data FileReadOnlyPropertyInfo +#endif +#if ENABLE_OVERLOADING +data FileCheckFileOnDiskMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileGetCompressionTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileGetEncodingMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileGetLocationMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileGetNewlineTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileIsDeletedMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileIsExternallyModifiedMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileIsLocalMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileIsReadonlyMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileSetLocationMethodInfo +#endif diff --git a/GI/GtkSource/Objects/FileLoader.hs b/GI/GtkSource/Objects/FileLoader.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/FileLoader.hs @@ -0,0 +1,996 @@ + + +{- | +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.FileLoader + ( + +-- * Exported types + FileLoader(..) , + IsFileLoader , + toFileLoader , + noFileLoader , + + + -- * Methods +-- ** getBuffer #method:getBuffer# + +#if ENABLE_OVERLOADING + FileLoaderGetBufferMethodInfo , +#endif + fileLoaderGetBuffer , + + +-- ** getCompressionType #method:getCompressionType# + +#if ENABLE_OVERLOADING + FileLoaderGetCompressionTypeMethodInfo , +#endif + fileLoaderGetCompressionType , + + +-- ** getEncoding #method:getEncoding# + +#if ENABLE_OVERLOADING + FileLoaderGetEncodingMethodInfo , +#endif + fileLoaderGetEncoding , + + +-- ** getFile #method:getFile# + +#if ENABLE_OVERLOADING + FileLoaderGetFileMethodInfo , +#endif + fileLoaderGetFile , + + +-- ** getInputStream #method:getInputStream# + +#if ENABLE_OVERLOADING + FileLoaderGetInputStreamMethodInfo , +#endif + fileLoaderGetInputStream , + + +-- ** getLocation #method:getLocation# + +#if ENABLE_OVERLOADING + FileLoaderGetLocationMethodInfo , +#endif + fileLoaderGetLocation , + + +-- ** getNewlineType #method:getNewlineType# + +#if ENABLE_OVERLOADING + FileLoaderGetNewlineTypeMethodInfo , +#endif + fileLoaderGetNewlineType , + + +-- ** loadAsync #method:loadAsync# + +#if ENABLE_OVERLOADING + FileLoaderLoadAsyncMethodInfo , +#endif + fileLoaderLoadAsync , + + +-- ** loadFinish #method:loadFinish# + +#if ENABLE_OVERLOADING + FileLoaderLoadFinishMethodInfo , +#endif + fileLoaderLoadFinish , + + +-- ** new #method:new# + + fileLoaderNew , + + +-- ** newFromStream #method:newFromStream# + + fileLoaderNewFromStream , + + +-- ** setCandidateEncodings #method:setCandidateEncodings# + +#if ENABLE_OVERLOADING + FileLoaderSetCandidateEncodingsMethodInfo, +#endif + fileLoaderSetCandidateEncodings , + + + + + -- * Properties +-- ** buffer #attr:buffer# +{- | The 'GI.GtkSource.Objects.Buffer.Buffer' to load the contents into. The +'GI.GtkSource.Objects.FileLoader.FileLoader' object has a weak reference to the buffer. + +/Since: 3.14/ +-} +#if ENABLE_OVERLOADING + FileLoaderBufferPropertyInfo , +#endif + constructFileLoaderBuffer , +#if ENABLE_OVERLOADING + fileLoaderBuffer , +#endif + getFileLoaderBuffer , + + +-- ** file #attr:file# +{- | The 'GI.GtkSource.Objects.File.File'. The 'GI.GtkSource.Objects.FileLoader.FileLoader' object has a weak +reference to the file. + +/Since: 3.14/ +-} +#if ENABLE_OVERLOADING + FileLoaderFilePropertyInfo , +#endif + constructFileLoaderFile , +#if ENABLE_OVERLOADING + fileLoaderFile , +#endif + getFileLoaderFile , + + +-- ** inputStream #attr:inputStream# +{- | The 'GI.Gio.Objects.InputStream.InputStream' to load. Useful for reading stdin. If this property +is set, the 'GI.GtkSource.Objects.FileLoader.FileLoader':@/location/@ property is ignored. + +/Since: 3.14/ +-} +#if ENABLE_OVERLOADING + FileLoaderInputStreamPropertyInfo , +#endif + constructFileLoaderInputStream , +#if ENABLE_OVERLOADING + fileLoaderInputStream , +#endif + getFileLoaderInputStream , + + +-- ** location #attr:location# +{- | The 'GI.Gio.Interfaces.File.File' to load. If the 'GI.GtkSource.Objects.FileLoader.FileLoader':@/input-stream/@ is +'Nothing', by default the location is taken from the 'GI.GtkSource.Objects.File.File' at +construction time. + +/Since: 3.14/ +-} +#if ENABLE_OVERLOADING + FileLoaderLocationPropertyInfo , +#endif + constructFileLoaderLocation , +#if ENABLE_OVERLOADING + fileLoaderLocation , +#endif + getFileLoaderLocation , + + + + + ) 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.GLib.Callbacks as GLib.Callbacks +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Interfaces.File as Gio.File +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Gio.Objects.InputStream as Gio.InputStream +import {-# SOURCE #-} qualified GI.GtkSource.Enums as GtkSource.Enums +import {-# SOURCE #-} qualified GI.GtkSource.Objects.Buffer as GtkSource.Buffer +import {-# SOURCE #-} qualified GI.GtkSource.Objects.File as GtkSource.File +import {-# SOURCE #-} qualified GI.GtkSource.Structs.Encoding as GtkSource.Encoding + +-- | Memory-managed wrapper type. +newtype FileLoader = FileLoader (ManagedPtr FileLoader) +foreign import ccall "gtk_source_file_loader_get_type" + c_gtk_source_file_loader_get_type :: IO GType + +instance GObject FileLoader where + gobjectType = c_gtk_source_file_loader_get_type + + +-- | Type class for types which can be safely cast to `FileLoader`, for instance with `toFileLoader`. +class (GObject o, O.IsDescendantOf FileLoader o) => IsFileLoader o +instance (GObject o, O.IsDescendantOf FileLoader o) => IsFileLoader o + +instance O.HasParentTypes FileLoader +type instance O.ParentTypes FileLoader = '[GObject.Object.Object] + +-- | Cast to `FileLoader`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toFileLoader :: (MonadIO m, IsFileLoader o) => o -> m FileLoader +toFileLoader = liftIO . unsafeCastTo FileLoader + +-- | A convenience alias for `Nothing` :: `Maybe` `FileLoader`. +noFileLoader :: Maybe FileLoader +noFileLoader = Nothing + +#if ENABLE_OVERLOADING +type family ResolveFileLoaderMethod (t :: Symbol) (o :: *) :: * where + ResolveFileLoaderMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveFileLoaderMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveFileLoaderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveFileLoaderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveFileLoaderMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveFileLoaderMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveFileLoaderMethod "loadAsync" o = FileLoaderLoadAsyncMethodInfo + ResolveFileLoaderMethod "loadFinish" o = FileLoaderLoadFinishMethodInfo + ResolveFileLoaderMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveFileLoaderMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveFileLoaderMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveFileLoaderMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveFileLoaderMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveFileLoaderMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveFileLoaderMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveFileLoaderMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveFileLoaderMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveFileLoaderMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveFileLoaderMethod "getBuffer" o = FileLoaderGetBufferMethodInfo + ResolveFileLoaderMethod "getCompressionType" o = FileLoaderGetCompressionTypeMethodInfo + ResolveFileLoaderMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveFileLoaderMethod "getEncoding" o = FileLoaderGetEncodingMethodInfo + ResolveFileLoaderMethod "getFile" o = FileLoaderGetFileMethodInfo + ResolveFileLoaderMethod "getInputStream" o = FileLoaderGetInputStreamMethodInfo + ResolveFileLoaderMethod "getLocation" o = FileLoaderGetLocationMethodInfo + ResolveFileLoaderMethod "getNewlineType" o = FileLoaderGetNewlineTypeMethodInfo + ResolveFileLoaderMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveFileLoaderMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveFileLoaderMethod "setCandidateEncodings" o = FileLoaderSetCandidateEncodingsMethodInfo + ResolveFileLoaderMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveFileLoaderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveFileLoaderMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveFileLoaderMethod t FileLoader, O.MethodInfo info FileLoader p) => OL.IsLabel t (FileLoader -> 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 + +-- VVV Prop "buffer" + -- Type: TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@buffer@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' fileLoader #buffer +@ +-} +getFileLoaderBuffer :: (MonadIO m, IsFileLoader o) => o -> m GtkSource.Buffer.Buffer +getFileLoaderBuffer obj = liftIO $ checkUnexpectedNothing "getFileLoaderBuffer" $ B.Properties.getObjectPropertyObject obj "buffer" GtkSource.Buffer.Buffer + +{- | +Construct a `GValueConstruct` with valid value for the “@buffer@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructFileLoaderBuffer :: (IsFileLoader o, GtkSource.Buffer.IsBuffer a) => a -> IO (GValueConstruct o) +constructFileLoaderBuffer val = B.Properties.constructObjectPropertyObject "buffer" (Just val) + +#if ENABLE_OVERLOADING +data FileLoaderBufferPropertyInfo +instance AttrInfo FileLoaderBufferPropertyInfo where + type AttrAllowedOps FileLoaderBufferPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint FileLoaderBufferPropertyInfo = GtkSource.Buffer.IsBuffer + type AttrBaseTypeConstraint FileLoaderBufferPropertyInfo = IsFileLoader + type AttrGetType FileLoaderBufferPropertyInfo = GtkSource.Buffer.Buffer + type AttrLabel FileLoaderBufferPropertyInfo = "buffer" + type AttrOrigin FileLoaderBufferPropertyInfo = FileLoader + attrGet _ = getFileLoaderBuffer + attrSet _ = undefined + attrConstruct _ = constructFileLoaderBuffer + attrClear _ = undefined +#endif + +-- VVV Prop "file" + -- Type: TInterface (Name {namespace = "GtkSource", name = "File"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@file@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' fileLoader #file +@ +-} +getFileLoaderFile :: (MonadIO m, IsFileLoader o) => o -> m GtkSource.File.File +getFileLoaderFile obj = liftIO $ checkUnexpectedNothing "getFileLoaderFile" $ B.Properties.getObjectPropertyObject obj "file" GtkSource.File.File + +{- | +Construct a `GValueConstruct` with valid value for the “@file@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructFileLoaderFile :: (IsFileLoader o, GtkSource.File.IsFile a) => a -> IO (GValueConstruct o) +constructFileLoaderFile val = B.Properties.constructObjectPropertyObject "file" (Just val) + +#if ENABLE_OVERLOADING +data FileLoaderFilePropertyInfo +instance AttrInfo FileLoaderFilePropertyInfo where + type AttrAllowedOps FileLoaderFilePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint FileLoaderFilePropertyInfo = GtkSource.File.IsFile + type AttrBaseTypeConstraint FileLoaderFilePropertyInfo = IsFileLoader + type AttrGetType FileLoaderFilePropertyInfo = GtkSource.File.File + type AttrLabel FileLoaderFilePropertyInfo = "file" + type AttrOrigin FileLoaderFilePropertyInfo = FileLoader + attrGet _ = getFileLoaderFile + attrSet _ = undefined + attrConstruct _ = constructFileLoaderFile + attrClear _ = undefined +#endif + +-- VVV Prop "input-stream" + -- Type: TInterface (Name {namespace = "Gio", name = "InputStream"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@input-stream@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' fileLoader #inputStream +@ +-} +getFileLoaderInputStream :: (MonadIO m, IsFileLoader o) => o -> m (Maybe Gio.InputStream.InputStream) +getFileLoaderInputStream obj = liftIO $ B.Properties.getObjectPropertyObject obj "input-stream" Gio.InputStream.InputStream + +{- | +Construct a `GValueConstruct` with valid value for the “@input-stream@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructFileLoaderInputStream :: (IsFileLoader o, Gio.InputStream.IsInputStream a) => a -> IO (GValueConstruct o) +constructFileLoaderInputStream val = B.Properties.constructObjectPropertyObject "input-stream" (Just val) + +#if ENABLE_OVERLOADING +data FileLoaderInputStreamPropertyInfo +instance AttrInfo FileLoaderInputStreamPropertyInfo where + type AttrAllowedOps FileLoaderInputStreamPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint FileLoaderInputStreamPropertyInfo = Gio.InputStream.IsInputStream + type AttrBaseTypeConstraint FileLoaderInputStreamPropertyInfo = IsFileLoader + type AttrGetType FileLoaderInputStreamPropertyInfo = (Maybe Gio.InputStream.InputStream) + type AttrLabel FileLoaderInputStreamPropertyInfo = "input-stream" + type AttrOrigin FileLoaderInputStreamPropertyInfo = FileLoader + attrGet _ = getFileLoaderInputStream + attrSet _ = undefined + attrConstruct _ = constructFileLoaderInputStream + attrClear _ = undefined +#endif + +-- VVV Prop "location" + -- Type: TInterface (Name {namespace = "Gio", name = "File"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@location@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' fileLoader #location +@ +-} +getFileLoaderLocation :: (MonadIO m, IsFileLoader o) => o -> m (Maybe Gio.File.File) +getFileLoaderLocation obj = liftIO $ B.Properties.getObjectPropertyObject obj "location" Gio.File.File + +{- | +Construct a `GValueConstruct` with valid value for the “@location@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructFileLoaderLocation :: (IsFileLoader o, Gio.File.IsFile a) => a -> IO (GValueConstruct o) +constructFileLoaderLocation val = B.Properties.constructObjectPropertyObject "location" (Just val) + +#if ENABLE_OVERLOADING +data FileLoaderLocationPropertyInfo +instance AttrInfo FileLoaderLocationPropertyInfo where + type AttrAllowedOps FileLoaderLocationPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint FileLoaderLocationPropertyInfo = Gio.File.IsFile + type AttrBaseTypeConstraint FileLoaderLocationPropertyInfo = IsFileLoader + type AttrGetType FileLoaderLocationPropertyInfo = (Maybe Gio.File.File) + type AttrLabel FileLoaderLocationPropertyInfo = "location" + type AttrOrigin FileLoaderLocationPropertyInfo = FileLoader + attrGet _ = getFileLoaderLocation + attrSet _ = undefined + attrConstruct _ = constructFileLoaderLocation + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList FileLoader +type instance O.AttributeList FileLoader = FileLoaderAttributeList +type FileLoaderAttributeList = ('[ '("buffer", FileLoaderBufferPropertyInfo), '("file", FileLoaderFilePropertyInfo), '("inputStream", FileLoaderInputStreamPropertyInfo), '("location", FileLoaderLocationPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +fileLoaderBuffer :: AttrLabelProxy "buffer" +fileLoaderBuffer = AttrLabelProxy + +fileLoaderFile :: AttrLabelProxy "file" +fileLoaderFile = AttrLabelProxy + +fileLoaderInputStream :: AttrLabelProxy "inputStream" +fileLoaderInputStream = AttrLabelProxy + +fileLoaderLocation :: AttrLabelProxy "location" +fileLoaderLocation = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList FileLoader = FileLoaderSignalList +type FileLoaderSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method FileLoader::new +-- method type : Constructor +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkSourceBuffer to load the contents into.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file", argType = TInterface (Name {namespace = "GtkSource", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkSourceFile.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "FileLoader"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_file_loader_new" gtk_source_file_loader_new :: + Ptr GtkSource.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + Ptr GtkSource.File.File -> -- file : TInterface (Name {namespace = "GtkSource", name = "File"}) + IO (Ptr FileLoader) + +{- | +Creates a new 'GI.GtkSource.Objects.FileLoader.FileLoader' object. The contents is read from the +'GI.GtkSource.Objects.File.File'\'s location. If not already done, call +'GI.GtkSource.Objects.File.fileSetLocation' before calling this constructor. The previous +location is anyway not needed, because as soon as the file loading begins, +the /@buffer@/ is emptied. + +/Since: 3.14/ +-} +fileLoaderNew :: + (B.CallStack.HasCallStack, MonadIO m, GtkSource.Buffer.IsBuffer a, GtkSource.File.IsFile b) => + a + {- ^ /@buffer@/: the 'GI.GtkSource.Objects.Buffer.Buffer' to load the contents into. -} + -> b + {- ^ /@file@/: the 'GI.GtkSource.Objects.File.File'. -} + -> m FileLoader + {- ^ __Returns:__ a new 'GI.GtkSource.Objects.FileLoader.FileLoader' object. -} +fileLoaderNew buffer file = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + file' <- unsafeManagedPtrCastPtr file + result <- gtk_source_file_loader_new buffer' file' + checkUnexpectedReturnNULL "fileLoaderNew" result + result' <- (wrapObject FileLoader) result + touchManagedPtr buffer + touchManagedPtr file + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method FileLoader::new_from_stream +-- method type : Constructor +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkSourceBuffer to load the contents into.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file", argType = TInterface (Name {namespace = "GtkSource", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkSourceFile.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GInputStream to load, e.g. stdin.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "FileLoader"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_file_loader_new_from_stream" gtk_source_file_loader_new_from_stream :: + Ptr GtkSource.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + Ptr GtkSource.File.File -> -- file : TInterface (Name {namespace = "GtkSource", name = "File"}) + Ptr Gio.InputStream.InputStream -> -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"}) + IO (Ptr FileLoader) + +{- | +Creates a new 'GI.GtkSource.Objects.FileLoader.FileLoader' object. The contents is read from /@stream@/. + +/Since: 3.14/ +-} +fileLoaderNewFromStream :: + (B.CallStack.HasCallStack, MonadIO m, GtkSource.Buffer.IsBuffer a, GtkSource.File.IsFile b, Gio.InputStream.IsInputStream c) => + a + {- ^ /@buffer@/: the 'GI.GtkSource.Objects.Buffer.Buffer' to load the contents into. -} + -> b + {- ^ /@file@/: the 'GI.GtkSource.Objects.File.File'. -} + -> c + {- ^ /@stream@/: the 'GI.Gio.Objects.InputStream.InputStream' to load, e.g. stdin. -} + -> m FileLoader + {- ^ __Returns:__ a new 'GI.GtkSource.Objects.FileLoader.FileLoader' object. -} +fileLoaderNewFromStream buffer file stream = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + file' <- unsafeManagedPtrCastPtr file + stream' <- unsafeManagedPtrCastPtr stream + result <- gtk_source_file_loader_new_from_stream buffer' file' stream' + checkUnexpectedReturnNULL "fileLoaderNewFromStream" result + result' <- (wrapObject FileLoader) result + touchManagedPtr buffer + touchManagedPtr file + touchManagedPtr stream + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method FileLoader::get_buffer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GtkSource", name = "FileLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileLoader.", 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_file_loader_get_buffer" gtk_source_file_loader_get_buffer :: + Ptr FileLoader -> -- loader : TInterface (Name {namespace = "GtkSource", name = "FileLoader"}) + IO (Ptr GtkSource.Buffer.Buffer) + +{- | +/No description available in the introspection data./ + +/Since: 3.14/ +-} +fileLoaderGetBuffer :: + (B.CallStack.HasCallStack, MonadIO m, IsFileLoader a) => + a + {- ^ /@loader@/: a 'GI.GtkSource.Objects.FileLoader.FileLoader'. -} + -> m GtkSource.Buffer.Buffer + {- ^ __Returns:__ the 'GI.GtkSource.Objects.Buffer.Buffer' to load the contents into. -} +fileLoaderGetBuffer loader = liftIO $ do + loader' <- unsafeManagedPtrCastPtr loader + result <- gtk_source_file_loader_get_buffer loader' + checkUnexpectedReturnNULL "fileLoaderGetBuffer" result + result' <- (newObject GtkSource.Buffer.Buffer) result + touchManagedPtr loader + return result' + +#if ENABLE_OVERLOADING +data FileLoaderGetBufferMethodInfo +instance (signature ~ (m GtkSource.Buffer.Buffer), MonadIO m, IsFileLoader a) => O.MethodInfo FileLoaderGetBufferMethodInfo a signature where + overloadedMethod _ = fileLoaderGetBuffer + +#endif + +-- method FileLoader::get_compression_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GtkSource", name = "FileLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileLoader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "CompressionType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_file_loader_get_compression_type" gtk_source_file_loader_get_compression_type :: + Ptr FileLoader -> -- loader : TInterface (Name {namespace = "GtkSource", name = "FileLoader"}) + IO CUInt + +{- | +/No description available in the introspection data./ + +/Since: 3.14/ +-} +fileLoaderGetCompressionType :: + (B.CallStack.HasCallStack, MonadIO m, IsFileLoader a) => + a + {- ^ /@loader@/: a 'GI.GtkSource.Objects.FileLoader.FileLoader'. -} + -> m GtkSource.Enums.CompressionType + {- ^ __Returns:__ the detected compression type. -} +fileLoaderGetCompressionType loader = liftIO $ do + loader' <- unsafeManagedPtrCastPtr loader + result <- gtk_source_file_loader_get_compression_type loader' + let result' = (toEnum . fromIntegral) result + touchManagedPtr loader + return result' + +#if ENABLE_OVERLOADING +data FileLoaderGetCompressionTypeMethodInfo +instance (signature ~ (m GtkSource.Enums.CompressionType), MonadIO m, IsFileLoader a) => O.MethodInfo FileLoaderGetCompressionTypeMethodInfo a signature where + overloadedMethod _ = fileLoaderGetCompressionType + +#endif + +-- method FileLoader::get_encoding +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GtkSource", name = "FileLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileLoader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Encoding"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_file_loader_get_encoding" gtk_source_file_loader_get_encoding :: + Ptr FileLoader -> -- loader : TInterface (Name {namespace = "GtkSource", name = "FileLoader"}) + IO (Ptr GtkSource.Encoding.Encoding) + +{- | +/No description available in the introspection data./ + +/Since: 3.14/ +-} +fileLoaderGetEncoding :: + (B.CallStack.HasCallStack, MonadIO m, IsFileLoader a) => + a + {- ^ /@loader@/: a 'GI.GtkSource.Objects.FileLoader.FileLoader'. -} + -> m GtkSource.Encoding.Encoding + {- ^ __Returns:__ the detected file encoding. -} +fileLoaderGetEncoding loader = liftIO $ do + loader' <- unsafeManagedPtrCastPtr loader + result <- gtk_source_file_loader_get_encoding loader' + checkUnexpectedReturnNULL "fileLoaderGetEncoding" result + result' <- (newBoxed GtkSource.Encoding.Encoding) result + touchManagedPtr loader + return result' + +#if ENABLE_OVERLOADING +data FileLoaderGetEncodingMethodInfo +instance (signature ~ (m GtkSource.Encoding.Encoding), MonadIO m, IsFileLoader a) => O.MethodInfo FileLoaderGetEncodingMethodInfo a signature where + overloadedMethod _ = fileLoaderGetEncoding + +#endif + +-- method FileLoader::get_file +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GtkSource", name = "FileLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileLoader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "File"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_file_loader_get_file" gtk_source_file_loader_get_file :: + Ptr FileLoader -> -- loader : TInterface (Name {namespace = "GtkSource", name = "FileLoader"}) + IO (Ptr GtkSource.File.File) + +{- | +/No description available in the introspection data./ + +/Since: 3.14/ +-} +fileLoaderGetFile :: + (B.CallStack.HasCallStack, MonadIO m, IsFileLoader a) => + a + {- ^ /@loader@/: a 'GI.GtkSource.Objects.FileLoader.FileLoader'. -} + -> m GtkSource.File.File + {- ^ __Returns:__ the 'GI.GtkSource.Objects.File.File'. -} +fileLoaderGetFile loader = liftIO $ do + loader' <- unsafeManagedPtrCastPtr loader + result <- gtk_source_file_loader_get_file loader' + checkUnexpectedReturnNULL "fileLoaderGetFile" result + result' <- (newObject GtkSource.File.File) result + touchManagedPtr loader + return result' + +#if ENABLE_OVERLOADING +data FileLoaderGetFileMethodInfo +instance (signature ~ (m GtkSource.File.File), MonadIO m, IsFileLoader a) => O.MethodInfo FileLoaderGetFileMethodInfo a signature where + overloadedMethod _ = fileLoaderGetFile + +#endif + +-- method FileLoader::get_input_stream +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GtkSource", name = "FileLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileLoader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gio", name = "InputStream"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_file_loader_get_input_stream" gtk_source_file_loader_get_input_stream :: + Ptr FileLoader -> -- loader : TInterface (Name {namespace = "GtkSource", name = "FileLoader"}) + IO (Ptr Gio.InputStream.InputStream) + +{- | +/No description available in the introspection data./ + +/Since: 3.14/ +-} +fileLoaderGetInputStream :: + (B.CallStack.HasCallStack, MonadIO m, IsFileLoader a) => + a + {- ^ /@loader@/: a 'GI.GtkSource.Objects.FileLoader.FileLoader'. -} + -> m (Maybe Gio.InputStream.InputStream) + {- ^ __Returns:__ the 'GI.Gio.Objects.InputStream.InputStream' to load, or 'Nothing' +if a 'GI.Gio.Interfaces.File.File' is used. -} +fileLoaderGetInputStream loader = liftIO $ do + loader' <- unsafeManagedPtrCastPtr loader + result <- gtk_source_file_loader_get_input_stream loader' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject Gio.InputStream.InputStream) result' + return result'' + touchManagedPtr loader + return maybeResult + +#if ENABLE_OVERLOADING +data FileLoaderGetInputStreamMethodInfo +instance (signature ~ (m (Maybe Gio.InputStream.InputStream)), MonadIO m, IsFileLoader a) => O.MethodInfo FileLoaderGetInputStreamMethodInfo a signature where + overloadedMethod _ = fileLoaderGetInputStream + +#endif + +-- method FileLoader::get_location +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GtkSource", name = "FileLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileLoader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gio", name = "File"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_file_loader_get_location" gtk_source_file_loader_get_location :: + Ptr FileLoader -> -- loader : TInterface (Name {namespace = "GtkSource", name = "FileLoader"}) + IO (Ptr Gio.File.File) + +{- | +/No description available in the introspection data./ + +/Since: 3.14/ +-} +fileLoaderGetLocation :: + (B.CallStack.HasCallStack, MonadIO m, IsFileLoader a) => + a + {- ^ /@loader@/: a 'GI.GtkSource.Objects.FileLoader.FileLoader'. -} + -> m (Maybe Gio.File.File) + {- ^ __Returns:__ the 'GI.Gio.Interfaces.File.File' to load, or 'Nothing' +if an input stream is used. -} +fileLoaderGetLocation loader = liftIO $ do + loader' <- unsafeManagedPtrCastPtr loader + result <- gtk_source_file_loader_get_location loader' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject Gio.File.File) result' + return result'' + touchManagedPtr loader + return maybeResult + +#if ENABLE_OVERLOADING +data FileLoaderGetLocationMethodInfo +instance (signature ~ (m (Maybe Gio.File.File)), MonadIO m, IsFileLoader a) => O.MethodInfo FileLoaderGetLocationMethodInfo a signature where + overloadedMethod _ = fileLoaderGetLocation + +#endif + +-- method FileLoader::get_newline_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GtkSource", name = "FileLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileLoader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "NewlineType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_file_loader_get_newline_type" gtk_source_file_loader_get_newline_type :: + Ptr FileLoader -> -- loader : TInterface (Name {namespace = "GtkSource", name = "FileLoader"}) + IO CUInt + +{- | +/No description available in the introspection data./ + +/Since: 3.14/ +-} +fileLoaderGetNewlineType :: + (B.CallStack.HasCallStack, MonadIO m, IsFileLoader a) => + a + {- ^ /@loader@/: a 'GI.GtkSource.Objects.FileLoader.FileLoader'. -} + -> m GtkSource.Enums.NewlineType + {- ^ __Returns:__ the detected newline type. -} +fileLoaderGetNewlineType loader = liftIO $ do + loader' <- unsafeManagedPtrCastPtr loader + result <- gtk_source_file_loader_get_newline_type loader' + let result' = (toEnum . fromIntegral) result + touchManagedPtr loader + return result' + +#if ENABLE_OVERLOADING +data FileLoaderGetNewlineTypeMethodInfo +instance (signature ~ (m GtkSource.Enums.NewlineType), MonadIO m, IsFileLoader a) => O.MethodInfo FileLoaderGetNewlineTypeMethodInfo a signature where + overloadedMethod _ = fileLoaderGetNewlineType + +#endif + +-- method FileLoader::load_async +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GtkSource", name = "FileLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileLoader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the I/O priority of the request. E.g. %G_PRIORITY_LOW,\n %G_PRIORITY_DEFAULT or %G_PRIORITY_HIGH.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "progress_callback", argType = TInterface (Name {namespace = "Gio", name = "FileProgressCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "function to call back with\n progress information, or %NULL if progress information is not needed.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 4, argDestroy = 5, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "progress_callback_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @progress_callback.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "progress_callback_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "function to call on\n @progress_callback_data when the @progress_callback is no longer needed, or\n %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the request is\n satisfied.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 7, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @callback.", 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_file_loader_load_async" gtk_source_file_loader_load_async :: + Ptr FileLoader -> -- loader : TInterface (Name {namespace = "GtkSource", name = "FileLoader"}) + Int32 -> -- io_priority : TBasicType TInt + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + FunPtr Gio.Callbacks.C_FileProgressCallback -> -- progress_callback : TInterface (Name {namespace = "Gio", name = "FileProgressCallback"}) + Ptr () -> -- progress_callback_data : TBasicType TPtr + FunPtr GLib.Callbacks.C_DestroyNotify -> -- progress_callback_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) + FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + IO () + +{- | +Loads asynchronously the file or input stream contents into the +'GI.GtkSource.Objects.Buffer.Buffer'. See the 'GI.Gio.Interfaces.AsyncResult.AsyncResult' documentation to know how to use this +function. + +/Since: 3.14/ +-} +fileLoaderLoadAsync :: + (B.CallStack.HasCallStack, MonadIO m, IsFileLoader a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@loader@/: a 'GI.GtkSource.Objects.FileLoader.FileLoader'. -} + -> Int32 + {- ^ /@ioPriority@/: the I\/O priority of the request. E.g. 'GI.GLib.Constants.PRIORITY_LOW', + 'GI.GLib.Constants.PRIORITY_DEFAULT' or 'GI.GLib.Constants.PRIORITY_HIGH'. -} + -> Maybe (b) + {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -} + -> Maybe (Gio.Callbacks.FileProgressCallback) + {- ^ /@progressCallback@/: function to call back with + progress information, or 'Nothing' if progress information is not needed. -} + -> Maybe (Gio.Callbacks.AsyncReadyCallback) + {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is + satisfied. -} + -> m () +fileLoaderLoadAsync loader ioPriority cancellable progressCallback callback = liftIO $ do + loader' <- unsafeManagedPtrCastPtr loader + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + maybeProgressCallback <- case progressCallback of + Nothing -> return (castPtrToFunPtr nullPtr) + Just jProgressCallback -> do + jProgressCallback' <- Gio.Callbacks.mk_FileProgressCallback (Gio.Callbacks.wrap_FileProgressCallback Nothing (Gio.Callbacks.drop_closures_FileProgressCallback jProgressCallback)) + return jProgressCallback' + maybeCallback <- case callback of + Nothing -> return (castPtrToFunPtr nullPtr) + Just jCallback -> do + ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback)) + jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback)) + poke ptrcallback jCallback' + return jCallback' + let progressCallbackData = castFunPtrToPtr maybeProgressCallback + let progressCallbackNotify = safeFreeFunPtrPtr + let userData = nullPtr + gtk_source_file_loader_load_async loader' ioPriority maybeCancellable maybeProgressCallback progressCallbackData progressCallbackNotify maybeCallback userData + touchManagedPtr loader + whenJust cancellable touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data FileLoaderLoadAsyncMethodInfo +instance (signature ~ (Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.FileProgressCallback) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsFileLoader a, Gio.Cancellable.IsCancellable b) => O.MethodInfo FileLoaderLoadAsyncMethodInfo a signature where + overloadedMethod _ = fileLoaderLoadAsync + +#endif + +-- method FileLoader::load_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GtkSource", name = "FileLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileLoader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "gtk_source_file_loader_load_finish" gtk_source_file_loader_load_finish :: + Ptr FileLoader -> -- loader : TInterface (Name {namespace = "GtkSource", name = "FileLoader"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Finishes a file loading started with 'GI.GtkSource.Objects.FileLoader.fileLoaderLoadAsync'. + +If the contents has been loaded, the following 'GI.GtkSource.Objects.File.File' properties will +be updated: the location, the encoding, the newline type and the compression +type. + +/Since: 3.14/ +-} +fileLoaderLoadFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsFileLoader a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@loader@/: a 'GI.GtkSource.Objects.FileLoader.FileLoader'. -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +fileLoaderLoadFinish loader result_ = liftIO $ do + loader' <- unsafeManagedPtrCastPtr loader + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + _ <- propagateGError $ gtk_source_file_loader_load_finish loader' result_' + touchManagedPtr loader + touchManagedPtr result_ + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data FileLoaderLoadFinishMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsFileLoader a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo FileLoaderLoadFinishMethodInfo a signature where + overloadedMethod _ = fileLoaderLoadFinish + +#endif + +-- method FileLoader::set_candidate_encodings +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GtkSource", name = "FileLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileLoader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "candidate_encodings", argType = TGSList (TInterface (Name {namespace = "GtkSource", name = "Encoding"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a list of\n #GtkSourceEncodings.", 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_file_loader_set_candidate_encodings" gtk_source_file_loader_set_candidate_encodings :: + Ptr FileLoader -> -- loader : TInterface (Name {namespace = "GtkSource", name = "FileLoader"}) + Ptr (GSList (Ptr GtkSource.Encoding.Encoding)) -> -- candidate_encodings : TGSList (TInterface (Name {namespace = "GtkSource", name = "Encoding"})) + IO () + +{- | +Sets the candidate encodings for the file loading. The encodings are tried in +the same order as the list. + +For convenience, /@candidateEncodings@/ can contain duplicates. Only the first +occurrence of a duplicated encoding is kept in the list. + +By default the candidate encodings are (in that order in the list): +1. If set, the 'GI.GtkSource.Objects.File.File'\'s encoding as returned by +'GI.GtkSource.Objects.File.fileGetEncoding'. +2. The default candidates as returned by +'GI.GtkSource.Functions.encodingGetDefaultCandidates'. + +/Since: 3.14/ +-} +fileLoaderSetCandidateEncodings :: + (B.CallStack.HasCallStack, MonadIO m, IsFileLoader a) => + a + {- ^ /@loader@/: a 'GI.GtkSource.Objects.FileLoader.FileLoader'. -} + -> [GtkSource.Encoding.Encoding] + {- ^ /@candidateEncodings@/: a list of + 'GI.GtkSource.Structs.Encoding.Encoding'\s. -} + -> m () +fileLoaderSetCandidateEncodings loader candidateEncodings = liftIO $ do + loader' <- unsafeManagedPtrCastPtr loader + candidateEncodings' <- mapM unsafeManagedPtrGetPtr candidateEncodings + candidateEncodings'' <- packGSList candidateEncodings' + gtk_source_file_loader_set_candidate_encodings loader' candidateEncodings'' + touchManagedPtr loader + mapM_ touchManagedPtr candidateEncodings + g_slist_free candidateEncodings'' + return () + +#if ENABLE_OVERLOADING +data FileLoaderSetCandidateEncodingsMethodInfo +instance (signature ~ ([GtkSource.Encoding.Encoding] -> m ()), MonadIO m, IsFileLoader a) => O.MethodInfo FileLoaderSetCandidateEncodingsMethodInfo a signature where + overloadedMethod _ = fileLoaderSetCandidateEncodings + +#endif + + diff --git a/GI/GtkSource/Objects/FileLoader.hs-boot b/GI/GtkSource/Objects/FileLoader.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/FileLoader.hs-boot @@ -0,0 +1,71 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.FileLoader 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 FileLoader = FileLoader (ManagedPtr FileLoader) +instance GObject FileLoader where +class (GObject o, O.IsDescendantOf FileLoader o) => IsFileLoader o +instance (GObject o, O.IsDescendantOf FileLoader o) => IsFileLoader o +instance O.HasParentTypes FileLoader +#if ENABLE_OVERLOADING +data FileLoaderBufferPropertyInfo +#endif +#if ENABLE_OVERLOADING +data FileLoaderFilePropertyInfo +#endif +#if ENABLE_OVERLOADING +data FileLoaderInputStreamPropertyInfo +#endif +#if ENABLE_OVERLOADING +data FileLoaderLocationPropertyInfo +#endif +#if ENABLE_OVERLOADING +data FileLoaderGetBufferMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileLoaderGetCompressionTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileLoaderGetEncodingMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileLoaderGetFileMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileLoaderGetInputStreamMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileLoaderGetLocationMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileLoaderGetNewlineTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileLoaderLoadAsyncMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileLoaderLoadFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileLoaderSetCandidateEncodingsMethodInfo +#endif diff --git a/GI/GtkSource/Objects/FileSaver.hs b/GI/GtkSource/Objects/FileSaver.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/FileSaver.hs @@ -0,0 +1,1360 @@ + + +{- | +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.FileSaver + ( + +-- * Exported types + FileSaver(..) , + IsFileSaver , + toFileSaver , + noFileSaver , + + + -- * Methods +-- ** getBuffer #method:getBuffer# + +#if ENABLE_OVERLOADING + FileSaverGetBufferMethodInfo , +#endif + fileSaverGetBuffer , + + +-- ** getCompressionType #method:getCompressionType# + +#if ENABLE_OVERLOADING + FileSaverGetCompressionTypeMethodInfo , +#endif + fileSaverGetCompressionType , + + +-- ** getEncoding #method:getEncoding# + +#if ENABLE_OVERLOADING + FileSaverGetEncodingMethodInfo , +#endif + fileSaverGetEncoding , + + +-- ** getFile #method:getFile# + +#if ENABLE_OVERLOADING + FileSaverGetFileMethodInfo , +#endif + fileSaverGetFile , + + +-- ** getFlags #method:getFlags# + +#if ENABLE_OVERLOADING + FileSaverGetFlagsMethodInfo , +#endif + fileSaverGetFlags , + + +-- ** getLocation #method:getLocation# + +#if ENABLE_OVERLOADING + FileSaverGetLocationMethodInfo , +#endif + fileSaverGetLocation , + + +-- ** getNewlineType #method:getNewlineType# + +#if ENABLE_OVERLOADING + FileSaverGetNewlineTypeMethodInfo , +#endif + fileSaverGetNewlineType , + + +-- ** new #method:new# + + fileSaverNew , + + +-- ** newWithTarget #method:newWithTarget# + + fileSaverNewWithTarget , + + +-- ** saveAsync #method:saveAsync# + +#if ENABLE_OVERLOADING + FileSaverSaveAsyncMethodInfo , +#endif + fileSaverSaveAsync , + + +-- ** saveFinish #method:saveFinish# + +#if ENABLE_OVERLOADING + FileSaverSaveFinishMethodInfo , +#endif + fileSaverSaveFinish , + + +-- ** setCompressionType #method:setCompressionType# + +#if ENABLE_OVERLOADING + FileSaverSetCompressionTypeMethodInfo , +#endif + fileSaverSetCompressionType , + + +-- ** setEncoding #method:setEncoding# + +#if ENABLE_OVERLOADING + FileSaverSetEncodingMethodInfo , +#endif + fileSaverSetEncoding , + + +-- ** setFlags #method:setFlags# + +#if ENABLE_OVERLOADING + FileSaverSetFlagsMethodInfo , +#endif + fileSaverSetFlags , + + +-- ** setNewlineType #method:setNewlineType# + +#if ENABLE_OVERLOADING + FileSaverSetNewlineTypeMethodInfo , +#endif + fileSaverSetNewlineType , + + + + + -- * Properties +-- ** buffer #attr:buffer# +{- | The 'GI.GtkSource.Objects.Buffer.Buffer' to save. The 'GI.GtkSource.Objects.FileSaver.FileSaver' object has a +weak reference to the buffer. + +/Since: 3.14/ +-} +#if ENABLE_OVERLOADING + FileSaverBufferPropertyInfo , +#endif + constructFileSaverBuffer , +#if ENABLE_OVERLOADING + fileSaverBuffer , +#endif + getFileSaverBuffer , + + +-- ** compressionType #attr:compressionType# +{- | The compression type. + +/Since: 3.14/ +-} +#if ENABLE_OVERLOADING + FileSaverCompressionTypePropertyInfo , +#endif + constructFileSaverCompressionType , +#if ENABLE_OVERLOADING + fileSaverCompressionType , +#endif + getFileSaverCompressionType , + setFileSaverCompressionType , + + +-- ** encoding #attr:encoding# +{- | The file\'s encoding. + +/Since: 3.14/ +-} +#if ENABLE_OVERLOADING + FileSaverEncodingPropertyInfo , +#endif + clearFileSaverEncoding , + constructFileSaverEncoding , +#if ENABLE_OVERLOADING + fileSaverEncoding , +#endif + getFileSaverEncoding , + setFileSaverEncoding , + + +-- ** file #attr:file# +{- | The 'GI.GtkSource.Objects.File.File'. The 'GI.GtkSource.Objects.FileSaver.FileSaver' object has a weak +reference to the file. + +/Since: 3.14/ +-} +#if ENABLE_OVERLOADING + FileSaverFilePropertyInfo , +#endif + constructFileSaverFile , +#if ENABLE_OVERLOADING + fileSaverFile , +#endif + getFileSaverFile , + + +-- ** flags #attr:flags# +{- | File saving flags. + +/Since: 3.14/ +-} +#if ENABLE_OVERLOADING + FileSaverFlagsPropertyInfo , +#endif + constructFileSaverFlags , +#if ENABLE_OVERLOADING + fileSaverFlags , +#endif + getFileSaverFlags , + setFileSaverFlags , + + +-- ** location #attr:location# +{- | The 'GI.Gio.Interfaces.File.File' where to save the buffer. By default the location is taken +from the 'GI.GtkSource.Objects.File.File' at construction time. + +/Since: 3.14/ +-} +#if ENABLE_OVERLOADING + FileSaverLocationPropertyInfo , +#endif + constructFileSaverLocation , +#if ENABLE_OVERLOADING + fileSaverLocation , +#endif + getFileSaverLocation , + + +-- ** newlineType #attr:newlineType# +{- | The newline type. + +/Since: 3.14/ +-} +#if ENABLE_OVERLOADING + FileSaverNewlineTypePropertyInfo , +#endif + constructFileSaverNewlineType , +#if ENABLE_OVERLOADING + fileSaverNewlineType , +#endif + getFileSaverNewlineType , + setFileSaverNewlineType , + + + + + ) 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.GLib.Callbacks as GLib.Callbacks +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Interfaces.File as Gio.File +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import {-# SOURCE #-} qualified GI.GtkSource.Enums as GtkSource.Enums +import {-# SOURCE #-} qualified GI.GtkSource.Flags as GtkSource.Flags +import {-# SOURCE #-} qualified GI.GtkSource.Objects.Buffer as GtkSource.Buffer +import {-# SOURCE #-} qualified GI.GtkSource.Objects.File as GtkSource.File +import {-# SOURCE #-} qualified GI.GtkSource.Structs.Encoding as GtkSource.Encoding + +-- | Memory-managed wrapper type. +newtype FileSaver = FileSaver (ManagedPtr FileSaver) +foreign import ccall "gtk_source_file_saver_get_type" + c_gtk_source_file_saver_get_type :: IO GType + +instance GObject FileSaver where + gobjectType = c_gtk_source_file_saver_get_type + + +-- | Type class for types which can be safely cast to `FileSaver`, for instance with `toFileSaver`. +class (GObject o, O.IsDescendantOf FileSaver o) => IsFileSaver o +instance (GObject o, O.IsDescendantOf FileSaver o) => IsFileSaver o + +instance O.HasParentTypes FileSaver +type instance O.ParentTypes FileSaver = '[GObject.Object.Object] + +-- | Cast to `FileSaver`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toFileSaver :: (MonadIO m, IsFileSaver o) => o -> m FileSaver +toFileSaver = liftIO . unsafeCastTo FileSaver + +-- | A convenience alias for `Nothing` :: `Maybe` `FileSaver`. +noFileSaver :: Maybe FileSaver +noFileSaver = Nothing + +#if ENABLE_OVERLOADING +type family ResolveFileSaverMethod (t :: Symbol) (o :: *) :: * where + ResolveFileSaverMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveFileSaverMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveFileSaverMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveFileSaverMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveFileSaverMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveFileSaverMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveFileSaverMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveFileSaverMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveFileSaverMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveFileSaverMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveFileSaverMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveFileSaverMethod "saveAsync" o = FileSaverSaveAsyncMethodInfo + ResolveFileSaverMethod "saveFinish" o = FileSaverSaveFinishMethodInfo + ResolveFileSaverMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveFileSaverMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveFileSaverMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveFileSaverMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveFileSaverMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveFileSaverMethod "getBuffer" o = FileSaverGetBufferMethodInfo + ResolveFileSaverMethod "getCompressionType" o = FileSaverGetCompressionTypeMethodInfo + ResolveFileSaverMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveFileSaverMethod "getEncoding" o = FileSaverGetEncodingMethodInfo + ResolveFileSaverMethod "getFile" o = FileSaverGetFileMethodInfo + ResolveFileSaverMethod "getFlags" o = FileSaverGetFlagsMethodInfo + ResolveFileSaverMethod "getLocation" o = FileSaverGetLocationMethodInfo + ResolveFileSaverMethod "getNewlineType" o = FileSaverGetNewlineTypeMethodInfo + ResolveFileSaverMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveFileSaverMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveFileSaverMethod "setCompressionType" o = FileSaverSetCompressionTypeMethodInfo + ResolveFileSaverMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveFileSaverMethod "setEncoding" o = FileSaverSetEncodingMethodInfo + ResolveFileSaverMethod "setFlags" o = FileSaverSetFlagsMethodInfo + ResolveFileSaverMethod "setNewlineType" o = FileSaverSetNewlineTypeMethodInfo + ResolveFileSaverMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveFileSaverMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveFileSaverMethod t FileSaver, O.MethodInfo info FileSaver p) => OL.IsLabel t (FileSaver -> 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 + +-- VVV Prop "buffer" + -- Type: TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@buffer@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' fileSaver #buffer +@ +-} +getFileSaverBuffer :: (MonadIO m, IsFileSaver o) => o -> m GtkSource.Buffer.Buffer +getFileSaverBuffer obj = liftIO $ checkUnexpectedNothing "getFileSaverBuffer" $ B.Properties.getObjectPropertyObject obj "buffer" GtkSource.Buffer.Buffer + +{- | +Construct a `GValueConstruct` with valid value for the “@buffer@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructFileSaverBuffer :: (IsFileSaver o, GtkSource.Buffer.IsBuffer a) => a -> IO (GValueConstruct o) +constructFileSaverBuffer val = B.Properties.constructObjectPropertyObject "buffer" (Just val) + +#if ENABLE_OVERLOADING +data FileSaverBufferPropertyInfo +instance AttrInfo FileSaverBufferPropertyInfo where + type AttrAllowedOps FileSaverBufferPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint FileSaverBufferPropertyInfo = GtkSource.Buffer.IsBuffer + type AttrBaseTypeConstraint FileSaverBufferPropertyInfo = IsFileSaver + type AttrGetType FileSaverBufferPropertyInfo = GtkSource.Buffer.Buffer + type AttrLabel FileSaverBufferPropertyInfo = "buffer" + type AttrOrigin FileSaverBufferPropertyInfo = FileSaver + attrGet _ = getFileSaverBuffer + attrSet _ = undefined + attrConstruct _ = constructFileSaverBuffer + attrClear _ = undefined +#endif + +-- VVV Prop "compression-type" + -- Type: TInterface (Name {namespace = "GtkSource", name = "CompressionType"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@compression-type@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' fileSaver #compressionType +@ +-} +getFileSaverCompressionType :: (MonadIO m, IsFileSaver o) => o -> m GtkSource.Enums.CompressionType +getFileSaverCompressionType obj = liftIO $ B.Properties.getObjectPropertyEnum obj "compression-type" + +{- | +Set the value of the “@compression-type@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' fileSaver [ #compressionType 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setFileSaverCompressionType :: (MonadIO m, IsFileSaver o) => o -> GtkSource.Enums.CompressionType -> m () +setFileSaverCompressionType obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "compression-type" val + +{- | +Construct a `GValueConstruct` with valid value for the “@compression-type@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructFileSaverCompressionType :: (IsFileSaver o) => GtkSource.Enums.CompressionType -> IO (GValueConstruct o) +constructFileSaverCompressionType val = B.Properties.constructObjectPropertyEnum "compression-type" val + +#if ENABLE_OVERLOADING +data FileSaverCompressionTypePropertyInfo +instance AttrInfo FileSaverCompressionTypePropertyInfo where + type AttrAllowedOps FileSaverCompressionTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint FileSaverCompressionTypePropertyInfo = (~) GtkSource.Enums.CompressionType + type AttrBaseTypeConstraint FileSaverCompressionTypePropertyInfo = IsFileSaver + type AttrGetType FileSaverCompressionTypePropertyInfo = GtkSource.Enums.CompressionType + type AttrLabel FileSaverCompressionTypePropertyInfo = "compression-type" + type AttrOrigin FileSaverCompressionTypePropertyInfo = FileSaver + attrGet _ = getFileSaverCompressionType + attrSet _ = setFileSaverCompressionType + attrConstruct _ = constructFileSaverCompressionType + attrClear _ = undefined +#endif + +-- VVV Prop "encoding" + -- Type: TInterface (Name {namespace = "GtkSource", name = "Encoding"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just True) + +{- | +Get the value of the “@encoding@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' fileSaver #encoding +@ +-} +getFileSaverEncoding :: (MonadIO m, IsFileSaver o) => o -> m GtkSource.Encoding.Encoding +getFileSaverEncoding obj = liftIO $ checkUnexpectedNothing "getFileSaverEncoding" $ B.Properties.getObjectPropertyBoxed obj "encoding" GtkSource.Encoding.Encoding + +{- | +Set the value of the “@encoding@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' fileSaver [ #encoding 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setFileSaverEncoding :: (MonadIO m, IsFileSaver o) => o -> GtkSource.Encoding.Encoding -> m () +setFileSaverEncoding obj val = liftIO $ B.Properties.setObjectPropertyBoxed obj "encoding" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@encoding@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructFileSaverEncoding :: (IsFileSaver o) => GtkSource.Encoding.Encoding -> IO (GValueConstruct o) +constructFileSaverEncoding val = B.Properties.constructObjectPropertyBoxed "encoding" (Just val) + +{- | +Set the value of the “@encoding@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #encoding +@ +-} +clearFileSaverEncoding :: (MonadIO m, IsFileSaver o) => o -> m () +clearFileSaverEncoding obj = liftIO $ B.Properties.setObjectPropertyBoxed obj "encoding" (Nothing :: Maybe GtkSource.Encoding.Encoding) + +#if ENABLE_OVERLOADING +data FileSaverEncodingPropertyInfo +instance AttrInfo FileSaverEncodingPropertyInfo where + type AttrAllowedOps FileSaverEncodingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint FileSaverEncodingPropertyInfo = (~) GtkSource.Encoding.Encoding + type AttrBaseTypeConstraint FileSaverEncodingPropertyInfo = IsFileSaver + type AttrGetType FileSaverEncodingPropertyInfo = GtkSource.Encoding.Encoding + type AttrLabel FileSaverEncodingPropertyInfo = "encoding" + type AttrOrigin FileSaverEncodingPropertyInfo = FileSaver + attrGet _ = getFileSaverEncoding + attrSet _ = setFileSaverEncoding + attrConstruct _ = constructFileSaverEncoding + attrClear _ = clearFileSaverEncoding +#endif + +-- VVV Prop "file" + -- Type: TInterface (Name {namespace = "GtkSource", name = "File"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@file@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' fileSaver #file +@ +-} +getFileSaverFile :: (MonadIO m, IsFileSaver o) => o -> m GtkSource.File.File +getFileSaverFile obj = liftIO $ checkUnexpectedNothing "getFileSaverFile" $ B.Properties.getObjectPropertyObject obj "file" GtkSource.File.File + +{- | +Construct a `GValueConstruct` with valid value for the “@file@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructFileSaverFile :: (IsFileSaver o, GtkSource.File.IsFile a) => a -> IO (GValueConstruct o) +constructFileSaverFile val = B.Properties.constructObjectPropertyObject "file" (Just val) + +#if ENABLE_OVERLOADING +data FileSaverFilePropertyInfo +instance AttrInfo FileSaverFilePropertyInfo where + type AttrAllowedOps FileSaverFilePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint FileSaverFilePropertyInfo = GtkSource.File.IsFile + type AttrBaseTypeConstraint FileSaverFilePropertyInfo = IsFileSaver + type AttrGetType FileSaverFilePropertyInfo = GtkSource.File.File + type AttrLabel FileSaverFilePropertyInfo = "file" + type AttrOrigin FileSaverFilePropertyInfo = FileSaver + attrGet _ = getFileSaverFile + attrSet _ = undefined + attrConstruct _ = constructFileSaverFile + attrClear _ = undefined +#endif + +-- VVV Prop "flags" + -- Type: TInterface (Name {namespace = "GtkSource", name = "FileSaverFlags"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@flags@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' fileSaver #flags +@ +-} +getFileSaverFlags :: (MonadIO m, IsFileSaver o) => o -> m [GtkSource.Flags.FileSaverFlags] +getFileSaverFlags obj = liftIO $ B.Properties.getObjectPropertyFlags obj "flags" + +{- | +Set the value of the “@flags@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' fileSaver [ #flags 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setFileSaverFlags :: (MonadIO m, IsFileSaver o) => o -> [GtkSource.Flags.FileSaverFlags] -> m () +setFileSaverFlags obj val = liftIO $ B.Properties.setObjectPropertyFlags obj "flags" val + +{- | +Construct a `GValueConstruct` with valid value for the “@flags@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructFileSaverFlags :: (IsFileSaver o) => [GtkSource.Flags.FileSaverFlags] -> IO (GValueConstruct o) +constructFileSaverFlags val = B.Properties.constructObjectPropertyFlags "flags" val + +#if ENABLE_OVERLOADING +data FileSaverFlagsPropertyInfo +instance AttrInfo FileSaverFlagsPropertyInfo where + type AttrAllowedOps FileSaverFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint FileSaverFlagsPropertyInfo = (~) [GtkSource.Flags.FileSaverFlags] + type AttrBaseTypeConstraint FileSaverFlagsPropertyInfo = IsFileSaver + type AttrGetType FileSaverFlagsPropertyInfo = [GtkSource.Flags.FileSaverFlags] + type AttrLabel FileSaverFlagsPropertyInfo = "flags" + type AttrOrigin FileSaverFlagsPropertyInfo = FileSaver + attrGet _ = getFileSaverFlags + attrSet _ = setFileSaverFlags + attrConstruct _ = constructFileSaverFlags + attrClear _ = undefined +#endif + +-- VVV Prop "location" + -- Type: TInterface (Name {namespace = "Gio", name = "File"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@location@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' fileSaver #location +@ +-} +getFileSaverLocation :: (MonadIO m, IsFileSaver o) => o -> m Gio.File.File +getFileSaverLocation obj = liftIO $ checkUnexpectedNothing "getFileSaverLocation" $ B.Properties.getObjectPropertyObject obj "location" Gio.File.File + +{- | +Construct a `GValueConstruct` with valid value for the “@location@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructFileSaverLocation :: (IsFileSaver o, Gio.File.IsFile a) => a -> IO (GValueConstruct o) +constructFileSaverLocation val = B.Properties.constructObjectPropertyObject "location" (Just val) + +#if ENABLE_OVERLOADING +data FileSaverLocationPropertyInfo +instance AttrInfo FileSaverLocationPropertyInfo where + type AttrAllowedOps FileSaverLocationPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint FileSaverLocationPropertyInfo = Gio.File.IsFile + type AttrBaseTypeConstraint FileSaverLocationPropertyInfo = IsFileSaver + type AttrGetType FileSaverLocationPropertyInfo = Gio.File.File + type AttrLabel FileSaverLocationPropertyInfo = "location" + type AttrOrigin FileSaverLocationPropertyInfo = FileSaver + attrGet _ = getFileSaverLocation + attrSet _ = undefined + attrConstruct _ = constructFileSaverLocation + attrClear _ = undefined +#endif + +-- VVV Prop "newline-type" + -- Type: TInterface (Name {namespace = "GtkSource", name = "NewlineType"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@newline-type@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' fileSaver #newlineType +@ +-} +getFileSaverNewlineType :: (MonadIO m, IsFileSaver o) => o -> m GtkSource.Enums.NewlineType +getFileSaverNewlineType obj = liftIO $ B.Properties.getObjectPropertyEnum obj "newline-type" + +{- | +Set the value of the “@newline-type@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' fileSaver [ #newlineType 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setFileSaverNewlineType :: (MonadIO m, IsFileSaver o) => o -> GtkSource.Enums.NewlineType -> m () +setFileSaverNewlineType obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "newline-type" val + +{- | +Construct a `GValueConstruct` with valid value for the “@newline-type@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructFileSaverNewlineType :: (IsFileSaver o) => GtkSource.Enums.NewlineType -> IO (GValueConstruct o) +constructFileSaverNewlineType val = B.Properties.constructObjectPropertyEnum "newline-type" val + +#if ENABLE_OVERLOADING +data FileSaverNewlineTypePropertyInfo +instance AttrInfo FileSaverNewlineTypePropertyInfo where + type AttrAllowedOps FileSaverNewlineTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint FileSaverNewlineTypePropertyInfo = (~) GtkSource.Enums.NewlineType + type AttrBaseTypeConstraint FileSaverNewlineTypePropertyInfo = IsFileSaver + type AttrGetType FileSaverNewlineTypePropertyInfo = GtkSource.Enums.NewlineType + type AttrLabel FileSaverNewlineTypePropertyInfo = "newline-type" + type AttrOrigin FileSaverNewlineTypePropertyInfo = FileSaver + attrGet _ = getFileSaverNewlineType + attrSet _ = setFileSaverNewlineType + attrConstruct _ = constructFileSaverNewlineType + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList FileSaver +type instance O.AttributeList FileSaver = FileSaverAttributeList +type FileSaverAttributeList = ('[ '("buffer", FileSaverBufferPropertyInfo), '("compressionType", FileSaverCompressionTypePropertyInfo), '("encoding", FileSaverEncodingPropertyInfo), '("file", FileSaverFilePropertyInfo), '("flags", FileSaverFlagsPropertyInfo), '("location", FileSaverLocationPropertyInfo), '("newlineType", FileSaverNewlineTypePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +fileSaverBuffer :: AttrLabelProxy "buffer" +fileSaverBuffer = AttrLabelProxy + +fileSaverCompressionType :: AttrLabelProxy "compressionType" +fileSaverCompressionType = AttrLabelProxy + +fileSaverEncoding :: AttrLabelProxy "encoding" +fileSaverEncoding = AttrLabelProxy + +fileSaverFile :: AttrLabelProxy "file" +fileSaverFile = AttrLabelProxy + +fileSaverFlags :: AttrLabelProxy "flags" +fileSaverFlags = AttrLabelProxy + +fileSaverLocation :: AttrLabelProxy "location" +fileSaverLocation = AttrLabelProxy + +fileSaverNewlineType :: AttrLabelProxy "newlineType" +fileSaverNewlineType = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList FileSaver = FileSaverSignalList +type FileSaverSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method FileSaver::new +-- method type : Constructor +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkSourceBuffer to save.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file", argType = TInterface (Name {namespace = "GtkSource", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkSourceFile.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "FileSaver"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_file_saver_new" gtk_source_file_saver_new :: + Ptr GtkSource.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + Ptr GtkSource.File.File -> -- file : TInterface (Name {namespace = "GtkSource", name = "File"}) + IO (Ptr FileSaver) + +{- | +Creates a new 'GI.GtkSource.Objects.FileSaver.FileSaver' object. The /@buffer@/ will be saved to the +'GI.GtkSource.Objects.File.File'\'s location. + +This constructor is suitable for a simple \"save\" operation, when the /@file@/ +already contains a non-'Nothing' 'GI.GtkSource.Objects.File.File':@/location/@. + +/Since: 3.14/ +-} +fileSaverNew :: + (B.CallStack.HasCallStack, MonadIO m, GtkSource.Buffer.IsBuffer a, GtkSource.File.IsFile b) => + a + {- ^ /@buffer@/: the 'GI.GtkSource.Objects.Buffer.Buffer' to save. -} + -> b + {- ^ /@file@/: the 'GI.GtkSource.Objects.File.File'. -} + -> m FileSaver + {- ^ __Returns:__ a new 'GI.GtkSource.Objects.FileSaver.FileSaver' object. -} +fileSaverNew buffer file = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + file' <- unsafeManagedPtrCastPtr file + result <- gtk_source_file_saver_new buffer' file' + checkUnexpectedReturnNULL "fileSaverNew" result + result' <- (wrapObject FileSaver) result + touchManagedPtr buffer + touchManagedPtr file + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method FileSaver::new_with_target +-- method type : Constructor +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkSourceBuffer to save.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file", argType = TInterface (Name {namespace = "GtkSource", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkSourceFile.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target_location", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GFile where to save the buffer to.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "FileSaver"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_file_saver_new_with_target" gtk_source_file_saver_new_with_target :: + Ptr GtkSource.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + Ptr GtkSource.File.File -> -- file : TInterface (Name {namespace = "GtkSource", name = "File"}) + Ptr Gio.File.File -> -- target_location : TInterface (Name {namespace = "Gio", name = "File"}) + IO (Ptr FileSaver) + +{- | +Creates a new 'GI.GtkSource.Objects.FileSaver.FileSaver' object with a target location. When the +file saving is finished successfully, /@targetLocation@/ is set to the /@file@/\'s +'GI.GtkSource.Objects.File.File':@/location/@ property. If an error occurs, the previous valid +location is still available in 'GI.GtkSource.Objects.File.File'. + +This constructor is suitable for a \"save as\" operation, or for saving a new +buffer for the first time. + +/Since: 3.14/ +-} +fileSaverNewWithTarget :: + (B.CallStack.HasCallStack, MonadIO m, GtkSource.Buffer.IsBuffer a, GtkSource.File.IsFile b, Gio.File.IsFile c) => + a + {- ^ /@buffer@/: the 'GI.GtkSource.Objects.Buffer.Buffer' to save. -} + -> b + {- ^ /@file@/: the 'GI.GtkSource.Objects.File.File'. -} + -> c + {- ^ /@targetLocation@/: the 'GI.Gio.Interfaces.File.File' where to save the buffer to. -} + -> m FileSaver + {- ^ __Returns:__ a new 'GI.GtkSource.Objects.FileSaver.FileSaver' object. -} +fileSaverNewWithTarget buffer file targetLocation = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + file' <- unsafeManagedPtrCastPtr file + targetLocation' <- unsafeManagedPtrCastPtr targetLocation + result <- gtk_source_file_saver_new_with_target buffer' file' targetLocation' + checkUnexpectedReturnNULL "fileSaverNewWithTarget" result + result' <- (wrapObject FileSaver) result + touchManagedPtr buffer + touchManagedPtr file + touchManagedPtr targetLocation + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method FileSaver::get_buffer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "saver", argType = TInterface (Name {namespace = "GtkSource", name = "FileSaver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileSaver.", 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_file_saver_get_buffer" gtk_source_file_saver_get_buffer :: + Ptr FileSaver -> -- saver : TInterface (Name {namespace = "GtkSource", name = "FileSaver"}) + IO (Ptr GtkSource.Buffer.Buffer) + +{- | +/No description available in the introspection data./ + +/Since: 3.14/ +-} +fileSaverGetBuffer :: + (B.CallStack.HasCallStack, MonadIO m, IsFileSaver a) => + a + {- ^ /@saver@/: a 'GI.GtkSource.Objects.FileSaver.FileSaver'. -} + -> m GtkSource.Buffer.Buffer + {- ^ __Returns:__ the 'GI.GtkSource.Objects.Buffer.Buffer' to save. -} +fileSaverGetBuffer saver = liftIO $ do + saver' <- unsafeManagedPtrCastPtr saver + result <- gtk_source_file_saver_get_buffer saver' + checkUnexpectedReturnNULL "fileSaverGetBuffer" result + result' <- (newObject GtkSource.Buffer.Buffer) result + touchManagedPtr saver + return result' + +#if ENABLE_OVERLOADING +data FileSaverGetBufferMethodInfo +instance (signature ~ (m GtkSource.Buffer.Buffer), MonadIO m, IsFileSaver a) => O.MethodInfo FileSaverGetBufferMethodInfo a signature where + overloadedMethod _ = fileSaverGetBuffer + +#endif + +-- method FileSaver::get_compression_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "saver", argType = TInterface (Name {namespace = "GtkSource", name = "FileSaver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileSaver.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "CompressionType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_file_saver_get_compression_type" gtk_source_file_saver_get_compression_type :: + Ptr FileSaver -> -- saver : TInterface (Name {namespace = "GtkSource", name = "FileSaver"}) + IO CUInt + +{- | +/No description available in the introspection data./ + +/Since: 3.14/ +-} +fileSaverGetCompressionType :: + (B.CallStack.HasCallStack, MonadIO m, IsFileSaver a) => + a + {- ^ /@saver@/: a 'GI.GtkSource.Objects.FileSaver.FileSaver'. -} + -> m GtkSource.Enums.CompressionType + {- ^ __Returns:__ the compression type. -} +fileSaverGetCompressionType saver = liftIO $ do + saver' <- unsafeManagedPtrCastPtr saver + result <- gtk_source_file_saver_get_compression_type saver' + let result' = (toEnum . fromIntegral) result + touchManagedPtr saver + return result' + +#if ENABLE_OVERLOADING +data FileSaverGetCompressionTypeMethodInfo +instance (signature ~ (m GtkSource.Enums.CompressionType), MonadIO m, IsFileSaver a) => O.MethodInfo FileSaverGetCompressionTypeMethodInfo a signature where + overloadedMethod _ = fileSaverGetCompressionType + +#endif + +-- method FileSaver::get_encoding +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "saver", argType = TInterface (Name {namespace = "GtkSource", name = "FileSaver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileSaver.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Encoding"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_file_saver_get_encoding" gtk_source_file_saver_get_encoding :: + Ptr FileSaver -> -- saver : TInterface (Name {namespace = "GtkSource", name = "FileSaver"}) + IO (Ptr GtkSource.Encoding.Encoding) + +{- | +/No description available in the introspection data./ + +/Since: 3.14/ +-} +fileSaverGetEncoding :: + (B.CallStack.HasCallStack, MonadIO m, IsFileSaver a) => + a + {- ^ /@saver@/: a 'GI.GtkSource.Objects.FileSaver.FileSaver'. -} + -> m GtkSource.Encoding.Encoding + {- ^ __Returns:__ the encoding. -} +fileSaverGetEncoding saver = liftIO $ do + saver' <- unsafeManagedPtrCastPtr saver + result <- gtk_source_file_saver_get_encoding saver' + checkUnexpectedReturnNULL "fileSaverGetEncoding" result + result' <- (newBoxed GtkSource.Encoding.Encoding) result + touchManagedPtr saver + return result' + +#if ENABLE_OVERLOADING +data FileSaverGetEncodingMethodInfo +instance (signature ~ (m GtkSource.Encoding.Encoding), MonadIO m, IsFileSaver a) => O.MethodInfo FileSaverGetEncodingMethodInfo a signature where + overloadedMethod _ = fileSaverGetEncoding + +#endif + +-- method FileSaver::get_file +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "saver", argType = TInterface (Name {namespace = "GtkSource", name = "FileSaver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileSaver.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "File"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_file_saver_get_file" gtk_source_file_saver_get_file :: + Ptr FileSaver -> -- saver : TInterface (Name {namespace = "GtkSource", name = "FileSaver"}) + IO (Ptr GtkSource.File.File) + +{- | +/No description available in the introspection data./ + +/Since: 3.14/ +-} +fileSaverGetFile :: + (B.CallStack.HasCallStack, MonadIO m, IsFileSaver a) => + a + {- ^ /@saver@/: a 'GI.GtkSource.Objects.FileSaver.FileSaver'. -} + -> m GtkSource.File.File + {- ^ __Returns:__ the 'GI.GtkSource.Objects.File.File'. -} +fileSaverGetFile saver = liftIO $ do + saver' <- unsafeManagedPtrCastPtr saver + result <- gtk_source_file_saver_get_file saver' + checkUnexpectedReturnNULL "fileSaverGetFile" result + result' <- (newObject GtkSource.File.File) result + touchManagedPtr saver + return result' + +#if ENABLE_OVERLOADING +data FileSaverGetFileMethodInfo +instance (signature ~ (m GtkSource.File.File), MonadIO m, IsFileSaver a) => O.MethodInfo FileSaverGetFileMethodInfo a signature where + overloadedMethod _ = fileSaverGetFile + +#endif + +-- method FileSaver::get_flags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "saver", argType = TInterface (Name {namespace = "GtkSource", name = "FileSaver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileSaver.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "FileSaverFlags"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_file_saver_get_flags" gtk_source_file_saver_get_flags :: + Ptr FileSaver -> -- saver : TInterface (Name {namespace = "GtkSource", name = "FileSaver"}) + IO CUInt + +{- | +/No description available in the introspection data./ + +/Since: 3.14/ +-} +fileSaverGetFlags :: + (B.CallStack.HasCallStack, MonadIO m, IsFileSaver a) => + a + {- ^ /@saver@/: a 'GI.GtkSource.Objects.FileSaver.FileSaver'. -} + -> m [GtkSource.Flags.FileSaverFlags] + {- ^ __Returns:__ the flags. -} +fileSaverGetFlags saver = liftIO $ do + saver' <- unsafeManagedPtrCastPtr saver + result <- gtk_source_file_saver_get_flags saver' + let result' = wordToGFlags result + touchManagedPtr saver + return result' + +#if ENABLE_OVERLOADING +data FileSaverGetFlagsMethodInfo +instance (signature ~ (m [GtkSource.Flags.FileSaverFlags]), MonadIO m, IsFileSaver a) => O.MethodInfo FileSaverGetFlagsMethodInfo a signature where + overloadedMethod _ = fileSaverGetFlags + +#endif + +-- method FileSaver::get_location +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "saver", argType = TInterface (Name {namespace = "GtkSource", name = "FileSaver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileSaver.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gio", name = "File"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_file_saver_get_location" gtk_source_file_saver_get_location :: + Ptr FileSaver -> -- saver : TInterface (Name {namespace = "GtkSource", name = "FileSaver"}) + IO (Ptr Gio.File.File) + +{- | +/No description available in the introspection data./ + +/Since: 3.14/ +-} +fileSaverGetLocation :: + (B.CallStack.HasCallStack, MonadIO m, IsFileSaver a) => + a + {- ^ /@saver@/: a 'GI.GtkSource.Objects.FileSaver.FileSaver'. -} + -> m Gio.File.File + {- ^ __Returns:__ the 'GI.Gio.Interfaces.File.File' where to save the buffer to. -} +fileSaverGetLocation saver = liftIO $ do + saver' <- unsafeManagedPtrCastPtr saver + result <- gtk_source_file_saver_get_location saver' + checkUnexpectedReturnNULL "fileSaverGetLocation" result + result' <- (newObject Gio.File.File) result + touchManagedPtr saver + return result' + +#if ENABLE_OVERLOADING +data FileSaverGetLocationMethodInfo +instance (signature ~ (m Gio.File.File), MonadIO m, IsFileSaver a) => O.MethodInfo FileSaverGetLocationMethodInfo a signature where + overloadedMethod _ = fileSaverGetLocation + +#endif + +-- method FileSaver::get_newline_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "saver", argType = TInterface (Name {namespace = "GtkSource", name = "FileSaver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileSaver.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "NewlineType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_file_saver_get_newline_type" gtk_source_file_saver_get_newline_type :: + Ptr FileSaver -> -- saver : TInterface (Name {namespace = "GtkSource", name = "FileSaver"}) + IO CUInt + +{- | +/No description available in the introspection data./ + +/Since: 3.14/ +-} +fileSaverGetNewlineType :: + (B.CallStack.HasCallStack, MonadIO m, IsFileSaver a) => + a + {- ^ /@saver@/: a 'GI.GtkSource.Objects.FileSaver.FileSaver'. -} + -> m GtkSource.Enums.NewlineType + {- ^ __Returns:__ the newline type. -} +fileSaverGetNewlineType saver = liftIO $ do + saver' <- unsafeManagedPtrCastPtr saver + result <- gtk_source_file_saver_get_newline_type saver' + let result' = (toEnum . fromIntegral) result + touchManagedPtr saver + return result' + +#if ENABLE_OVERLOADING +data FileSaverGetNewlineTypeMethodInfo +instance (signature ~ (m GtkSource.Enums.NewlineType), MonadIO m, IsFileSaver a) => O.MethodInfo FileSaverGetNewlineTypeMethodInfo a signature where + overloadedMethod _ = fileSaverGetNewlineType + +#endif + +-- method FileSaver::save_async +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "saver", argType = TInterface (Name {namespace = "GtkSource", name = "FileSaver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileSaver.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the I/O priority of the request. E.g. %G_PRIORITY_LOW,\n %G_PRIORITY_DEFAULT or %G_PRIORITY_HIGH.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "progress_callback", argType = TInterface (Name {namespace = "Gio", name = "FileProgressCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "function to call back with\n progress information, or %NULL if progress information is not needed.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 4, argDestroy = 5, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "progress_callback_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @progress_callback.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "progress_callback_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "function to call on\n @progress_callback_data when the @progress_callback is no longer needed, or\n %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the request is\n satisfied.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 7, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @callback.", 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_file_saver_save_async" gtk_source_file_saver_save_async :: + Ptr FileSaver -> -- saver : TInterface (Name {namespace = "GtkSource", name = "FileSaver"}) + Int32 -> -- io_priority : TBasicType TInt + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + FunPtr Gio.Callbacks.C_FileProgressCallback -> -- progress_callback : TInterface (Name {namespace = "Gio", name = "FileProgressCallback"}) + Ptr () -> -- progress_callback_data : TBasicType TPtr + FunPtr GLib.Callbacks.C_DestroyNotify -> -- progress_callback_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) + FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + IO () + +{- | +Saves asynchronously the buffer into the file. See the 'GI.Gio.Interfaces.AsyncResult.AsyncResult' +documentation to know how to use this function. + +/Since: 3.14/ +-} +fileSaverSaveAsync :: + (B.CallStack.HasCallStack, MonadIO m, IsFileSaver a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@saver@/: a 'GI.GtkSource.Objects.FileSaver.FileSaver'. -} + -> Int32 + {- ^ /@ioPriority@/: the I\/O priority of the request. E.g. 'GI.GLib.Constants.PRIORITY_LOW', + 'GI.GLib.Constants.PRIORITY_DEFAULT' or 'GI.GLib.Constants.PRIORITY_HIGH'. -} + -> Maybe (b) + {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -} + -> Maybe (Gio.Callbacks.FileProgressCallback) + {- ^ /@progressCallback@/: function to call back with + progress information, or 'Nothing' if progress information is not needed. -} + -> Maybe (Gio.Callbacks.AsyncReadyCallback) + {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is + satisfied. -} + -> m () +fileSaverSaveAsync saver ioPriority cancellable progressCallback callback = liftIO $ do + saver' <- unsafeManagedPtrCastPtr saver + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + maybeProgressCallback <- case progressCallback of + Nothing -> return (castPtrToFunPtr nullPtr) + Just jProgressCallback -> do + jProgressCallback' <- Gio.Callbacks.mk_FileProgressCallback (Gio.Callbacks.wrap_FileProgressCallback Nothing (Gio.Callbacks.drop_closures_FileProgressCallback jProgressCallback)) + return jProgressCallback' + maybeCallback <- case callback of + Nothing -> return (castPtrToFunPtr nullPtr) + Just jCallback -> do + ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback)) + jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback)) + poke ptrcallback jCallback' + return jCallback' + let progressCallbackData = castFunPtrToPtr maybeProgressCallback + let progressCallbackNotify = safeFreeFunPtrPtr + let userData = nullPtr + gtk_source_file_saver_save_async saver' ioPriority maybeCancellable maybeProgressCallback progressCallbackData progressCallbackNotify maybeCallback userData + touchManagedPtr saver + whenJust cancellable touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data FileSaverSaveAsyncMethodInfo +instance (signature ~ (Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.FileProgressCallback) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsFileSaver a, Gio.Cancellable.IsCancellable b) => O.MethodInfo FileSaverSaveAsyncMethodInfo a signature where + overloadedMethod _ = fileSaverSaveAsync + +#endif + +-- method FileSaver::save_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "saver", argType = TInterface (Name {namespace = "GtkSource", name = "FileSaver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileSaver.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "gtk_source_file_saver_save_finish" gtk_source_file_saver_save_finish :: + Ptr FileSaver -> -- saver : TInterface (Name {namespace = "GtkSource", name = "FileSaver"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Finishes a file saving started with 'GI.GtkSource.Objects.FileSaver.fileSaverSaveAsync'. + +If the file has been saved successfully, the following 'GI.GtkSource.Objects.File.File' +properties will be updated: the location, the encoding, the newline type and +the compression type. + +Since the 3.20 version, 'GI.Gtk.Objects.TextBuffer.textBufferSetModified' is called with 'False' +if the file has been saved successfully. + +/Since: 3.14/ +-} +fileSaverSaveFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsFileSaver a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@saver@/: a 'GI.GtkSource.Objects.FileSaver.FileSaver'. -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +fileSaverSaveFinish saver result_ = liftIO $ do + saver' <- unsafeManagedPtrCastPtr saver + result_' <- unsafeManagedPtrCastPtr result_ + onException (do + _ <- propagateGError $ gtk_source_file_saver_save_finish saver' result_' + touchManagedPtr saver + touchManagedPtr result_ + return () + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data FileSaverSaveFinishMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsFileSaver a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo FileSaverSaveFinishMethodInfo a signature where + overloadedMethod _ = fileSaverSaveFinish + +#endif + +-- method FileSaver::set_compression_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "saver", argType = TInterface (Name {namespace = "GtkSource", name = "FileSaver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileSaver.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "compression_type", argType = TInterface (Name {namespace = "GtkSource", name = "CompressionType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new compression type.", 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_file_saver_set_compression_type" gtk_source_file_saver_set_compression_type :: + Ptr FileSaver -> -- saver : TInterface (Name {namespace = "GtkSource", name = "FileSaver"}) + CUInt -> -- compression_type : TInterface (Name {namespace = "GtkSource", name = "CompressionType"}) + IO () + +{- | +Sets the compression type. By default the compression type is taken from the +'GI.GtkSource.Objects.File.File'. + +/Since: 3.14/ +-} +fileSaverSetCompressionType :: + (B.CallStack.HasCallStack, MonadIO m, IsFileSaver a) => + a + {- ^ /@saver@/: a 'GI.GtkSource.Objects.FileSaver.FileSaver'. -} + -> GtkSource.Enums.CompressionType + {- ^ /@compressionType@/: the new compression type. -} + -> m () +fileSaverSetCompressionType saver compressionType = liftIO $ do + saver' <- unsafeManagedPtrCastPtr saver + let compressionType' = (fromIntegral . fromEnum) compressionType + gtk_source_file_saver_set_compression_type saver' compressionType' + touchManagedPtr saver + return () + +#if ENABLE_OVERLOADING +data FileSaverSetCompressionTypeMethodInfo +instance (signature ~ (GtkSource.Enums.CompressionType -> m ()), MonadIO m, IsFileSaver a) => O.MethodInfo FileSaverSetCompressionTypeMethodInfo a signature where + overloadedMethod _ = fileSaverSetCompressionType + +#endif + +-- method FileSaver::set_encoding +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "saver", argType = TInterface (Name {namespace = "GtkSource", name = "FileSaver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileSaver.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "encoding", argType = TInterface (Name {namespace = "GtkSource", name = "Encoding"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the new encoding, or %NULL for UTF-8.", 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_file_saver_set_encoding" gtk_source_file_saver_set_encoding :: + Ptr FileSaver -> -- saver : TInterface (Name {namespace = "GtkSource", name = "FileSaver"}) + Ptr GtkSource.Encoding.Encoding -> -- encoding : TInterface (Name {namespace = "GtkSource", name = "Encoding"}) + IO () + +{- | +Sets the encoding. If /@encoding@/ is 'Nothing', the UTF-8 encoding will be set. +By default the encoding is taken from the 'GI.GtkSource.Objects.File.File'. + +/Since: 3.14/ +-} +fileSaverSetEncoding :: + (B.CallStack.HasCallStack, MonadIO m, IsFileSaver a) => + a + {- ^ /@saver@/: a 'GI.GtkSource.Objects.FileSaver.FileSaver'. -} + -> Maybe (GtkSource.Encoding.Encoding) + {- ^ /@encoding@/: the new encoding, or 'Nothing' for UTF-8. -} + -> m () +fileSaverSetEncoding saver encoding = liftIO $ do + saver' <- unsafeManagedPtrCastPtr saver + maybeEncoding <- case encoding of + Nothing -> return nullPtr + Just jEncoding -> do + jEncoding' <- unsafeManagedPtrGetPtr jEncoding + return jEncoding' + gtk_source_file_saver_set_encoding saver' maybeEncoding + touchManagedPtr saver + whenJust encoding touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data FileSaverSetEncodingMethodInfo +instance (signature ~ (Maybe (GtkSource.Encoding.Encoding) -> m ()), MonadIO m, IsFileSaver a) => O.MethodInfo FileSaverSetEncodingMethodInfo a signature where + overloadedMethod _ = fileSaverSetEncoding + +#endif + +-- method FileSaver::set_flags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "saver", argType = TInterface (Name {namespace = "GtkSource", name = "FileSaver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileSaver.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GtkSource", name = "FileSaverFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new flags.", 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_file_saver_set_flags" gtk_source_file_saver_set_flags :: + Ptr FileSaver -> -- saver : TInterface (Name {namespace = "GtkSource", name = "FileSaver"}) + CUInt -> -- flags : TInterface (Name {namespace = "GtkSource", name = "FileSaverFlags"}) + IO () + +{- | +/No description available in the introspection data./ + +/Since: 3.14/ +-} +fileSaverSetFlags :: + (B.CallStack.HasCallStack, MonadIO m, IsFileSaver a) => + a + {- ^ /@saver@/: a 'GI.GtkSource.Objects.FileSaver.FileSaver'. -} + -> [GtkSource.Flags.FileSaverFlags] + {- ^ /@flags@/: the new flags. -} + -> m () +fileSaverSetFlags saver flags = liftIO $ do + saver' <- unsafeManagedPtrCastPtr saver + let flags' = gflagsToWord flags + gtk_source_file_saver_set_flags saver' flags' + touchManagedPtr saver + return () + +#if ENABLE_OVERLOADING +data FileSaverSetFlagsMethodInfo +instance (signature ~ ([GtkSource.Flags.FileSaverFlags] -> m ()), MonadIO m, IsFileSaver a) => O.MethodInfo FileSaverSetFlagsMethodInfo a signature where + overloadedMethod _ = fileSaverSetFlags + +#endif + +-- method FileSaver::set_newline_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "saver", argType = TInterface (Name {namespace = "GtkSource", name = "FileSaver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileSaver.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "newline_type", argType = TInterface (Name {namespace = "GtkSource", name = "NewlineType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new newline type.", 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_file_saver_set_newline_type" gtk_source_file_saver_set_newline_type :: + Ptr FileSaver -> -- saver : TInterface (Name {namespace = "GtkSource", name = "FileSaver"}) + CUInt -> -- newline_type : TInterface (Name {namespace = "GtkSource", name = "NewlineType"}) + IO () + +{- | +Sets the newline type. By default the newline type is taken from the +'GI.GtkSource.Objects.File.File'. + +/Since: 3.14/ +-} +fileSaverSetNewlineType :: + (B.CallStack.HasCallStack, MonadIO m, IsFileSaver a) => + a + {- ^ /@saver@/: a 'GI.GtkSource.Objects.FileSaver.FileSaver'. -} + -> GtkSource.Enums.NewlineType + {- ^ /@newlineType@/: the new newline type. -} + -> m () +fileSaverSetNewlineType saver newlineType = liftIO $ do + saver' <- unsafeManagedPtrCastPtr saver + let newlineType' = (fromIntegral . fromEnum) newlineType + gtk_source_file_saver_set_newline_type saver' newlineType' + touchManagedPtr saver + return () + +#if ENABLE_OVERLOADING +data FileSaverSetNewlineTypeMethodInfo +instance (signature ~ (GtkSource.Enums.NewlineType -> m ()), MonadIO m, IsFileSaver a) => O.MethodInfo FileSaverSetNewlineTypeMethodInfo a signature where + overloadedMethod _ = fileSaverSetNewlineType + +#endif + + diff --git a/GI/GtkSource/Objects/FileSaver.hs-boot b/GI/GtkSource/Objects/FileSaver.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/FileSaver.hs-boot @@ -0,0 +1,89 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.FileSaver 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 FileSaver = FileSaver (ManagedPtr FileSaver) +instance GObject FileSaver where +class (GObject o, O.IsDescendantOf FileSaver o) => IsFileSaver o +instance (GObject o, O.IsDescendantOf FileSaver o) => IsFileSaver o +instance O.HasParentTypes FileSaver +#if ENABLE_OVERLOADING +data FileSaverBufferPropertyInfo +#endif +#if ENABLE_OVERLOADING +data FileSaverCompressionTypePropertyInfo +#endif +#if ENABLE_OVERLOADING +data FileSaverEncodingPropertyInfo +#endif +#if ENABLE_OVERLOADING +data FileSaverFilePropertyInfo +#endif +#if ENABLE_OVERLOADING +data FileSaverFlagsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data FileSaverLocationPropertyInfo +#endif +#if ENABLE_OVERLOADING +data FileSaverNewlineTypePropertyInfo +#endif +#if ENABLE_OVERLOADING +data FileSaverGetBufferMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileSaverGetCompressionTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileSaverGetEncodingMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileSaverGetFileMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileSaverGetFlagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileSaverGetLocationMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileSaverGetNewlineTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileSaverSaveAsyncMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileSaverSaveFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileSaverSetCompressionTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileSaverSetEncodingMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileSaverSetFlagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data FileSaverSetNewlineTypeMethodInfo +#endif diff --git a/GI/GtkSource/Objects/Gutter.hs b/GI/GtkSource/Objects/Gutter.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/Gutter.hs @@ -0,0 +1,856 @@ + + +{- | +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.Gutter + ( + +-- * Exported types + Gutter(..) , + IsGutter , + toGutter , + noGutter , + + + -- * Methods +-- ** getPadding #method:getPadding# + +#if ENABLE_OVERLOADING + GutterGetPaddingMethodInfo , +#endif + gutterGetPadding , + + +-- ** getRendererAtPos #method:getRendererAtPos# + +#if ENABLE_OVERLOADING + GutterGetRendererAtPosMethodInfo , +#endif + gutterGetRendererAtPos , + + +-- ** getView #method:getView# + +#if ENABLE_OVERLOADING + GutterGetViewMethodInfo , +#endif + gutterGetView , + + +-- ** getWindow #method:getWindow# + +#if ENABLE_OVERLOADING + GutterGetWindowMethodInfo , +#endif + gutterGetWindow , + + +-- ** getWindowType #method:getWindowType# + +#if ENABLE_OVERLOADING + GutterGetWindowTypeMethodInfo , +#endif + gutterGetWindowType , + + +-- ** insert #method:insert# + +#if ENABLE_OVERLOADING + GutterInsertMethodInfo , +#endif + gutterInsert , + + +-- ** queueDraw #method:queueDraw# + +#if ENABLE_OVERLOADING + GutterQueueDrawMethodInfo , +#endif + gutterQueueDraw , + + +-- ** remove #method:remove# + +#if ENABLE_OVERLOADING + GutterRemoveMethodInfo , +#endif + gutterRemove , + + +-- ** reorder #method:reorder# + +#if ENABLE_OVERLOADING + GutterReorderMethodInfo , +#endif + gutterReorder , + + +-- ** setPadding #method:setPadding# + +#if ENABLE_OVERLOADING + GutterSetPaddingMethodInfo , +#endif + gutterSetPadding , + + + + + -- * Properties +-- ** view #attr:view# +{- | The 'GI.GtkSource.Objects.View.View' of the gutter. +-} +#if ENABLE_OVERLOADING + GutterViewPropertyInfo , +#endif + constructGutterView , + getGutterView , +#if ENABLE_OVERLOADING + gutterView , +#endif + + +-- ** windowType #attr:windowType# +{- | The text window type on which the window is placed. +-} +#if ENABLE_OVERLOADING + GutterWindowTypePropertyInfo , +#endif + constructGutterWindowType , + getGutterWindowType , +#if ENABLE_OVERLOADING + gutterWindowType , +#endif + + +-- ** xpad #attr:xpad# +{- | The x-padding. +-} +#if ENABLE_OVERLOADING + GutterXpadPropertyInfo , +#endif + constructGutterXpad , + getGutterXpad , +#if ENABLE_OVERLOADING + gutterXpad , +#endif + setGutterXpad , + + +-- ** ypad #attr:ypad# +{- | The y-padding. +-} +#if ENABLE_OVERLOADING + GutterYpadPropertyInfo , +#endif + constructGutterYpad , + getGutterYpad , +#if ENABLE_OVERLOADING + gutterYpad , +#endif + setGutterYpad , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.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.Gdk.Objects.Window as Gdk.Window +import qualified GI.Gtk.Enums as Gtk.Enums +import {-# SOURCE #-} qualified GI.GtkSource.Objects.GutterRenderer as GtkSource.GutterRenderer +import {-# SOURCE #-} qualified GI.GtkSource.Objects.View as GtkSource.View + +-- | Memory-managed wrapper type. +newtype Gutter = Gutter (ManagedPtr Gutter) +foreign import ccall "gtk_source_gutter_get_type" + c_gtk_source_gutter_get_type :: IO GType + +instance GObject Gutter where + gobjectType = c_gtk_source_gutter_get_type + + +-- | Type class for types which can be safely cast to `Gutter`, for instance with `toGutter`. +class (GObject o, O.IsDescendantOf Gutter o) => IsGutter o +instance (GObject o, O.IsDescendantOf Gutter o) => IsGutter o + +instance O.HasParentTypes Gutter +type instance O.ParentTypes Gutter = '[GObject.Object.Object] + +-- | Cast to `Gutter`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toGutter :: (MonadIO m, IsGutter o) => o -> m Gutter +toGutter = liftIO . unsafeCastTo Gutter + +-- | A convenience alias for `Nothing` :: `Maybe` `Gutter`. +noGutter :: Maybe Gutter +noGutter = Nothing + +#if ENABLE_OVERLOADING +type family ResolveGutterMethod (t :: Symbol) (o :: *) :: * where + ResolveGutterMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveGutterMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveGutterMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveGutterMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveGutterMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveGutterMethod "insert" o = GutterInsertMethodInfo + ResolveGutterMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveGutterMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveGutterMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveGutterMethod "queueDraw" o = GutterQueueDrawMethodInfo + ResolveGutterMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveGutterMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveGutterMethod "remove" o = GutterRemoveMethodInfo + ResolveGutterMethod "reorder" o = GutterReorderMethodInfo + ResolveGutterMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveGutterMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveGutterMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveGutterMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveGutterMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveGutterMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveGutterMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveGutterMethod "getPadding" o = GutterGetPaddingMethodInfo + ResolveGutterMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveGutterMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveGutterMethod "getRendererAtPos" o = GutterGetRendererAtPosMethodInfo + ResolveGutterMethod "getView" o = GutterGetViewMethodInfo + ResolveGutterMethod "getWindow" o = GutterGetWindowMethodInfo + ResolveGutterMethod "getWindowType" o = GutterGetWindowTypeMethodInfo + ResolveGutterMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveGutterMethod "setPadding" o = GutterSetPaddingMethodInfo + ResolveGutterMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveGutterMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveGutterMethod t Gutter, O.MethodInfo info Gutter p) => OL.IsLabel t (Gutter -> 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 + +-- VVV Prop "view" + -- Type: TInterface (Name {namespace = "GtkSource", name = "View"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@view@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' gutter #view +@ +-} +getGutterView :: (MonadIO m, IsGutter o) => o -> m GtkSource.View.View +getGutterView obj = liftIO $ checkUnexpectedNothing "getGutterView" $ B.Properties.getObjectPropertyObject obj "view" GtkSource.View.View + +{- | +Construct a `GValueConstruct` with valid value for the “@view@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructGutterView :: (IsGutter o, GtkSource.View.IsView a) => a -> IO (GValueConstruct o) +constructGutterView val = B.Properties.constructObjectPropertyObject "view" (Just val) + +#if ENABLE_OVERLOADING +data GutterViewPropertyInfo +instance AttrInfo GutterViewPropertyInfo where + type AttrAllowedOps GutterViewPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint GutterViewPropertyInfo = GtkSource.View.IsView + type AttrBaseTypeConstraint GutterViewPropertyInfo = IsGutter + type AttrGetType GutterViewPropertyInfo = GtkSource.View.View + type AttrLabel GutterViewPropertyInfo = "view" + type AttrOrigin GutterViewPropertyInfo = Gutter + attrGet _ = getGutterView + attrSet _ = undefined + attrConstruct _ = constructGutterView + attrClear _ = undefined +#endif + +-- VVV Prop "window-type" + -- Type: TInterface (Name {namespace = "Gtk", name = "TextWindowType"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@window-type@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' gutter #windowType +@ +-} +getGutterWindowType :: (MonadIO m, IsGutter o) => o -> m Gtk.Enums.TextWindowType +getGutterWindowType obj = liftIO $ B.Properties.getObjectPropertyEnum obj "window-type" + +{- | +Construct a `GValueConstruct` with valid value for the “@window-type@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructGutterWindowType :: (IsGutter o) => Gtk.Enums.TextWindowType -> IO (GValueConstruct o) +constructGutterWindowType val = B.Properties.constructObjectPropertyEnum "window-type" val + +#if ENABLE_OVERLOADING +data GutterWindowTypePropertyInfo +instance AttrInfo GutterWindowTypePropertyInfo where + type AttrAllowedOps GutterWindowTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint GutterWindowTypePropertyInfo = (~) Gtk.Enums.TextWindowType + type AttrBaseTypeConstraint GutterWindowTypePropertyInfo = IsGutter + type AttrGetType GutterWindowTypePropertyInfo = Gtk.Enums.TextWindowType + type AttrLabel GutterWindowTypePropertyInfo = "window-type" + type AttrOrigin GutterWindowTypePropertyInfo = Gutter + attrGet _ = getGutterWindowType + attrSet _ = undefined + attrConstruct _ = constructGutterWindowType + attrClear _ = undefined +#endif + +-- VVV Prop "xpad" + -- Type: TBasicType TInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@xpad@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' gutter #xpad +@ +-} +getGutterXpad :: (MonadIO m, IsGutter o) => o -> m Int32 +getGutterXpad obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "xpad" + +{- | +Set the value of the “@xpad@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' gutter [ #xpad 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setGutterXpad :: (MonadIO m, IsGutter o) => o -> Int32 -> m () +setGutterXpad obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "xpad" val + +{- | +Construct a `GValueConstruct` with valid value for the “@xpad@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructGutterXpad :: (IsGutter o) => Int32 -> IO (GValueConstruct o) +constructGutterXpad val = B.Properties.constructObjectPropertyInt32 "xpad" val + +#if ENABLE_OVERLOADING +data GutterXpadPropertyInfo +instance AttrInfo GutterXpadPropertyInfo where + type AttrAllowedOps GutterXpadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint GutterXpadPropertyInfo = (~) Int32 + type AttrBaseTypeConstraint GutterXpadPropertyInfo = IsGutter + type AttrGetType GutterXpadPropertyInfo = Int32 + type AttrLabel GutterXpadPropertyInfo = "xpad" + type AttrOrigin GutterXpadPropertyInfo = Gutter + attrGet _ = getGutterXpad + attrSet _ = setGutterXpad + attrConstruct _ = constructGutterXpad + attrClear _ = undefined +#endif + +-- VVV Prop "ypad" + -- Type: TBasicType TInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@ypad@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' gutter #ypad +@ +-} +getGutterYpad :: (MonadIO m, IsGutter o) => o -> m Int32 +getGutterYpad obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "ypad" + +{- | +Set the value of the “@ypad@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' gutter [ #ypad 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setGutterYpad :: (MonadIO m, IsGutter o) => o -> Int32 -> m () +setGutterYpad obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "ypad" val + +{- | +Construct a `GValueConstruct` with valid value for the “@ypad@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructGutterYpad :: (IsGutter o) => Int32 -> IO (GValueConstruct o) +constructGutterYpad val = B.Properties.constructObjectPropertyInt32 "ypad" val + +#if ENABLE_OVERLOADING +data GutterYpadPropertyInfo +instance AttrInfo GutterYpadPropertyInfo where + type AttrAllowedOps GutterYpadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint GutterYpadPropertyInfo = (~) Int32 + type AttrBaseTypeConstraint GutterYpadPropertyInfo = IsGutter + type AttrGetType GutterYpadPropertyInfo = Int32 + type AttrLabel GutterYpadPropertyInfo = "ypad" + type AttrOrigin GutterYpadPropertyInfo = Gutter + attrGet _ = getGutterYpad + attrSet _ = setGutterYpad + attrConstruct _ = constructGutterYpad + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Gutter +type instance O.AttributeList Gutter = GutterAttributeList +type GutterAttributeList = ('[ '("view", GutterViewPropertyInfo), '("windowType", GutterWindowTypePropertyInfo), '("xpad", GutterXpadPropertyInfo), '("ypad", GutterYpadPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +gutterView :: AttrLabelProxy "view" +gutterView = AttrLabelProxy + +gutterWindowType :: AttrLabelProxy "windowType" +gutterWindowType = AttrLabelProxy + +gutterXpad :: AttrLabelProxy "xpad" +gutterXpad = AttrLabelProxy + +gutterYpad :: AttrLabelProxy "ypad" +gutterYpad = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Gutter = GutterSignalList +type GutterSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Gutter::get_padding +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "gutter", argType = TInterface (Name {namespace = "GtkSource", name = "Gutter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "xpad", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ypad", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_get_padding" gtk_source_gutter_get_padding :: + Ptr Gutter -> -- gutter : TInterface (Name {namespace = "GtkSource", name = "Gutter"}) + Int32 -> -- xpad : TBasicType TInt + Int32 -> -- ypad : TBasicType TInt + IO () + +{-# DEPRECATED gutterGetPadding ["(Since version 3.12)","Use 'GI.GtkSource.Objects.GutterRenderer.gutterRendererGetPadding' instead."] #-} +{- | +/No description available in the introspection data./ +-} +gutterGetPadding :: + (B.CallStack.HasCallStack, MonadIO m, IsGutter a) => + a + -> Int32 + -> Int32 + -> m () +gutterGetPadding gutter xpad ypad = liftIO $ do + gutter' <- unsafeManagedPtrCastPtr gutter + gtk_source_gutter_get_padding gutter' xpad ypad + touchManagedPtr gutter + return () + +#if ENABLE_OVERLOADING +data GutterGetPaddingMethodInfo +instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsGutter a) => O.MethodInfo GutterGetPaddingMethodInfo a signature where + overloadedMethod _ = gutterGetPadding + +#endif + +-- method Gutter::get_renderer_at_pos +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "gutter", argType = TInterface (Name {namespace = "GtkSource", name = "Gutter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkSourceGutter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The x position to get identified.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The y position to get identified.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_get_renderer_at_pos" gtk_source_gutter_get_renderer_at_pos :: + Ptr Gutter -> -- gutter : TInterface (Name {namespace = "GtkSource", name = "Gutter"}) + Int32 -> -- x : TBasicType TInt + Int32 -> -- y : TBasicType TInt + IO (Ptr GtkSource.GutterRenderer.GutterRenderer) + +{- | +Finds the 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' at (x, y). +-} +gutterGetRendererAtPos :: + (B.CallStack.HasCallStack, MonadIO m, IsGutter a) => + a + {- ^ /@gutter@/: A 'GI.GtkSource.Objects.Gutter.Gutter'. -} + -> Int32 + {- ^ /@x@/: The x position to get identified. -} + -> Int32 + {- ^ /@y@/: The y position to get identified. -} + -> m (Maybe GtkSource.GutterRenderer.GutterRenderer) + {- ^ __Returns:__ the renderer at (x, y) or 'Nothing'. -} +gutterGetRendererAtPos gutter x y = liftIO $ do + gutter' <- unsafeManagedPtrCastPtr gutter + result <- gtk_source_gutter_get_renderer_at_pos gutter' x y + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject GtkSource.GutterRenderer.GutterRenderer) result' + return result'' + touchManagedPtr gutter + return maybeResult + +#if ENABLE_OVERLOADING +data GutterGetRendererAtPosMethodInfo +instance (signature ~ (Int32 -> Int32 -> m (Maybe GtkSource.GutterRenderer.GutterRenderer)), MonadIO m, IsGutter a) => O.MethodInfo GutterGetRendererAtPosMethodInfo a signature where + overloadedMethod _ = gutterGetRendererAtPos + +#endif + +-- method Gutter::get_view +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "gutter", argType = TInterface (Name {namespace = "GtkSource", name = "Gutter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "View"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_get_view" gtk_source_gutter_get_view :: + Ptr Gutter -> -- gutter : TInterface (Name {namespace = "GtkSource", name = "Gutter"}) + IO (Ptr GtkSource.View.View) + +{- | +/No description available in the introspection data./ + +/Since: 3.24/ +-} +gutterGetView :: + (B.CallStack.HasCallStack, MonadIO m, IsGutter a) => + a + {- ^ /@gutter@/: a 'GI.GtkSource.Objects.Gutter.Gutter'. -} + -> m GtkSource.View.View + {- ^ __Returns:__ the associated 'GI.GtkSource.Objects.View.View'. -} +gutterGetView gutter = liftIO $ do + gutter' <- unsafeManagedPtrCastPtr gutter + result <- gtk_source_gutter_get_view gutter' + checkUnexpectedReturnNULL "gutterGetView" result + result' <- (newObject GtkSource.View.View) result + touchManagedPtr gutter + return result' + +#if ENABLE_OVERLOADING +data GutterGetViewMethodInfo +instance (signature ~ (m GtkSource.View.View), MonadIO m, IsGutter a) => O.MethodInfo GutterGetViewMethodInfo a signature where + overloadedMethod _ = gutterGetView + +#endif + +-- method Gutter::get_window +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "gutter", argType = TInterface (Name {namespace = "GtkSource", name = "Gutter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Window"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_get_window" gtk_source_gutter_get_window :: + Ptr Gutter -> -- gutter : TInterface (Name {namespace = "GtkSource", name = "Gutter"}) + IO (Ptr Gdk.Window.Window) + +{-# DEPRECATED gutterGetWindow ["(Since version 3.12)","Use 'GI.Gtk.Objects.TextView.textViewGetWindow' instead."] #-} +{- | +Get the 'GI.Gdk.Objects.Window.Window' of the gutter. The window will only be available when the +gutter has at least one, non-zero width, cell renderer packed. + +/Since: 2.8/ +-} +gutterGetWindow :: + (B.CallStack.HasCallStack, MonadIO m, IsGutter a) => + a + {- ^ /@gutter@/: a 'GI.GtkSource.Objects.Gutter.Gutter'. -} + -> m Gdk.Window.Window + {- ^ __Returns:__ the 'GI.Gdk.Objects.Window.Window' of the gutter, or 'Nothing' +if the gutter has no window. -} +gutterGetWindow gutter = liftIO $ do + gutter' <- unsafeManagedPtrCastPtr gutter + result <- gtk_source_gutter_get_window gutter' + checkUnexpectedReturnNULL "gutterGetWindow" result + result' <- (newObject Gdk.Window.Window) result + touchManagedPtr gutter + return result' + +#if ENABLE_OVERLOADING +data GutterGetWindowMethodInfo +instance (signature ~ (m Gdk.Window.Window), MonadIO m, IsGutter a) => O.MethodInfo GutterGetWindowMethodInfo a signature where + overloadedMethod _ = gutterGetWindow + +#endif + +-- method Gutter::get_window_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "gutter", argType = TInterface (Name {namespace = "GtkSource", name = "Gutter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "TextWindowType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_get_window_type" gtk_source_gutter_get_window_type :: + Ptr Gutter -> -- gutter : TInterface (Name {namespace = "GtkSource", name = "Gutter"}) + IO CUInt + +{- | +/No description available in the introspection data./ + +/Since: 3.24/ +-} +gutterGetWindowType :: + (B.CallStack.HasCallStack, MonadIO m, IsGutter a) => + a + {- ^ /@gutter@/: a 'GI.GtkSource.Objects.Gutter.Gutter'. -} + -> m Gtk.Enums.TextWindowType + {- ^ __Returns:__ the 'GI.Gtk.Enums.TextWindowType' of /@gutter@/. -} +gutterGetWindowType gutter = liftIO $ do + gutter' <- unsafeManagedPtrCastPtr gutter + result <- gtk_source_gutter_get_window_type gutter' + let result' = (toEnum . fromIntegral) result + touchManagedPtr gutter + return result' + +#if ENABLE_OVERLOADING +data GutterGetWindowTypeMethodInfo +instance (signature ~ (m Gtk.Enums.TextWindowType), MonadIO m, IsGutter a) => O.MethodInfo GutterGetWindowTypeMethodInfo a signature where + overloadedMethod _ = gutterGetWindowType + +#endif + +-- method Gutter::insert +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "gutter", argType = TInterface (Name {namespace = "GtkSource", name = "Gutter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a gutter renderer (must inherit from #GtkSourceGutterRenderer).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the renderer position.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_insert" gtk_source_gutter_insert :: + Ptr Gutter -> -- gutter : TInterface (Name {namespace = "GtkSource", name = "Gutter"}) + Ptr GtkSource.GutterRenderer.GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}) + Int32 -> -- position : TBasicType TInt + IO CInt + +{- | +Insert /@renderer@/ into the gutter. If /@renderer@/ is yet unowned then gutter +claims its ownership. Otherwise just increases renderer\'s reference count. +/@renderer@/ cannot be already inserted to another gutter. + +/Since: 3.0/ +-} +gutterInsert :: + (B.CallStack.HasCallStack, MonadIO m, IsGutter a, GtkSource.GutterRenderer.IsGutterRenderer b) => + a + {- ^ /@gutter@/: a 'GI.GtkSource.Objects.Gutter.Gutter'. -} + -> b + {- ^ /@renderer@/: a gutter renderer (must inherit from 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'). -} + -> Int32 + {- ^ /@position@/: the renderer position. -} + -> m Bool + {- ^ __Returns:__ 'True' if operation succeeded. Otherwise 'False'. -} +gutterInsert gutter renderer position = liftIO $ do + gutter' <- unsafeManagedPtrCastPtr gutter + renderer' <- unsafeManagedPtrCastPtr renderer + result <- gtk_source_gutter_insert gutter' renderer' position + let result' = (/= 0) result + touchManagedPtr gutter + touchManagedPtr renderer + return result' + +#if ENABLE_OVERLOADING +data GutterInsertMethodInfo +instance (signature ~ (b -> Int32 -> m Bool), MonadIO m, IsGutter a, GtkSource.GutterRenderer.IsGutterRenderer b) => O.MethodInfo GutterInsertMethodInfo a signature where + overloadedMethod _ = gutterInsert + +#endif + +-- method Gutter::queue_draw +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "gutter", argType = TInterface (Name {namespace = "GtkSource", name = "Gutter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_queue_draw" gtk_source_gutter_queue_draw :: + Ptr Gutter -> -- gutter : TInterface (Name {namespace = "GtkSource", name = "Gutter"}) + IO () + +{- | +Invalidates the drawable area of the gutter. You can use this to force a +redraw of the gutter if something has changed and needs to be redrawn. + +/Since: 2.8/ +-} +gutterQueueDraw :: + (B.CallStack.HasCallStack, MonadIO m, IsGutter a) => + a + {- ^ /@gutter@/: a 'GI.GtkSource.Objects.Gutter.Gutter'. -} + -> m () +gutterQueueDraw gutter = liftIO $ do + gutter' <- unsafeManagedPtrCastPtr gutter + gtk_source_gutter_queue_draw gutter' + touchManagedPtr gutter + return () + +#if ENABLE_OVERLOADING +data GutterQueueDrawMethodInfo +instance (signature ~ (m ()), MonadIO m, IsGutter a) => O.MethodInfo GutterQueueDrawMethodInfo a signature where + overloadedMethod _ = gutterQueueDraw + +#endif + +-- method Gutter::remove +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "gutter", argType = TInterface (Name {namespace = "GtkSource", name = "Gutter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRenderer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_remove" gtk_source_gutter_remove :: + Ptr Gutter -> -- gutter : TInterface (Name {namespace = "GtkSource", name = "Gutter"}) + Ptr GtkSource.GutterRenderer.GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}) + IO () + +{- | +Removes /@renderer@/ from /@gutter@/. + +/Since: 2.8/ +-} +gutterRemove :: + (B.CallStack.HasCallStack, MonadIO m, IsGutter a, GtkSource.GutterRenderer.IsGutterRenderer b) => + a + {- ^ /@gutter@/: a 'GI.GtkSource.Objects.Gutter.Gutter'. -} + -> b + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'. -} + -> m () +gutterRemove gutter renderer = liftIO $ do + gutter' <- unsafeManagedPtrCastPtr gutter + renderer' <- unsafeManagedPtrCastPtr renderer + gtk_source_gutter_remove gutter' renderer' + touchManagedPtr gutter + touchManagedPtr renderer + return () + +#if ENABLE_OVERLOADING +data GutterRemoveMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsGutter a, GtkSource.GutterRenderer.IsGutterRenderer b) => O.MethodInfo GutterRemoveMethodInfo a signature where + overloadedMethod _ = gutterRemove + +#endif + +-- method Gutter::reorder +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "gutter", argType = TInterface (Name {namespace = "GtkSource", name = "Gutter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRenderer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkCellRenderer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new renderer position.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_reorder" gtk_source_gutter_reorder :: + Ptr Gutter -> -- gutter : TInterface (Name {namespace = "GtkSource", name = "Gutter"}) + Ptr GtkSource.GutterRenderer.GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}) + Int32 -> -- position : TBasicType TInt + IO () + +{- | +Reorders /@renderer@/ in /@gutter@/ to new /@position@/. + +/Since: 2.8/ +-} +gutterReorder :: + (B.CallStack.HasCallStack, MonadIO m, IsGutter a, GtkSource.GutterRenderer.IsGutterRenderer b) => + a + {- ^ /@gutter@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'. -} + -> b + {- ^ /@renderer@/: a 'GI.Gtk.Objects.CellRenderer.CellRenderer'. -} + -> Int32 + {- ^ /@position@/: the new renderer position. -} + -> m () +gutterReorder gutter renderer position = liftIO $ do + gutter' <- unsafeManagedPtrCastPtr gutter + renderer' <- unsafeManagedPtrCastPtr renderer + gtk_source_gutter_reorder gutter' renderer' position + touchManagedPtr gutter + touchManagedPtr renderer + return () + +#if ENABLE_OVERLOADING +data GutterReorderMethodInfo +instance (signature ~ (b -> Int32 -> m ()), MonadIO m, IsGutter a, GtkSource.GutterRenderer.IsGutterRenderer b) => O.MethodInfo GutterReorderMethodInfo a signature where + overloadedMethod _ = gutterReorder + +#endif + +-- method Gutter::set_padding +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "gutter", argType = TInterface (Name {namespace = "GtkSource", name = "Gutter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "xpad", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ypad", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_set_padding" gtk_source_gutter_set_padding :: + Ptr Gutter -> -- gutter : TInterface (Name {namespace = "GtkSource", name = "Gutter"}) + Int32 -> -- xpad : TBasicType TInt + Int32 -> -- ypad : TBasicType TInt + IO () + +{-# DEPRECATED gutterSetPadding ["(Since version 3.12)","Use 'GI.GtkSource.Objects.GutterRenderer.gutterRendererSetPadding' instead."] #-} +{- | +/No description available in the introspection data./ +-} +gutterSetPadding :: + (B.CallStack.HasCallStack, MonadIO m, IsGutter a) => + a + -> Int32 + -> Int32 + -> m () +gutterSetPadding gutter xpad ypad = liftIO $ do + gutter' <- unsafeManagedPtrCastPtr gutter + gtk_source_gutter_set_padding gutter' xpad ypad + touchManagedPtr gutter + return () + +#if ENABLE_OVERLOADING +data GutterSetPaddingMethodInfo +instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsGutter a) => O.MethodInfo GutterSetPaddingMethodInfo a signature where + overloadedMethod _ = gutterSetPadding + +#endif + + diff --git a/GI/GtkSource/Objects/Gutter.hs-boot b/GI/GtkSource/Objects/Gutter.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/Gutter.hs-boot @@ -0,0 +1,71 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.Gutter 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 Gutter = Gutter (ManagedPtr Gutter) +instance GObject Gutter where +class (GObject o, O.IsDescendantOf Gutter o) => IsGutter o +instance (GObject o, O.IsDescendantOf Gutter o) => IsGutter o +instance O.HasParentTypes Gutter +#if ENABLE_OVERLOADING +data GutterViewPropertyInfo +#endif +#if ENABLE_OVERLOADING +data GutterWindowTypePropertyInfo +#endif +#if ENABLE_OVERLOADING +data GutterXpadPropertyInfo +#endif +#if ENABLE_OVERLOADING +data GutterYpadPropertyInfo +#endif +#if ENABLE_OVERLOADING +data GutterGetPaddingMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterGetRendererAtPosMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterGetViewMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterGetWindowMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterGetWindowTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterInsertMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterQueueDrawMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRemoveMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterReorderMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterSetPaddingMethodInfo +#endif diff --git a/GI/GtkSource/Objects/GutterRenderer.hs b/GI/GtkSource/Objects/GutterRenderer.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/GutterRenderer.hs @@ -0,0 +1,2423 @@ + + +{- | +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.GutterRenderer + ( +#if ENABLE_OVERLOADING + GutterRendererGetAlignmentMethodInfo , +#endif +#if ENABLE_OVERLOADING + GutterRendererGetPaddingMethodInfo , +#endif + +-- * Exported types + GutterRenderer(..) , + IsGutterRenderer , + toGutterRenderer , + noGutterRenderer , + + + -- * Methods +-- ** activate #method:activate# + +#if ENABLE_OVERLOADING + GutterRendererActivateMethodInfo , +#endif + gutterRendererActivate , + + +-- ** begin #method:begin# + +#if ENABLE_OVERLOADING + GutterRendererBeginMethodInfo , +#endif + gutterRendererBegin , + + +-- ** draw #method:draw# + +#if ENABLE_OVERLOADING + GutterRendererDrawMethodInfo , +#endif + gutterRendererDraw , + + +-- ** end #method:end# + +#if ENABLE_OVERLOADING + GutterRendererEndMethodInfo , +#endif + gutterRendererEnd , + + +-- ** getAlignmentMode #method:getAlignmentMode# + +#if ENABLE_OVERLOADING + GutterRendererGetAlignmentModeMethodInfo, +#endif + gutterRendererGetAlignmentMode , + + +-- ** getBackground #method:getBackground# + +#if ENABLE_OVERLOADING + GutterRendererGetBackgroundMethodInfo , +#endif + gutterRendererGetBackground , + + +-- ** getSize #method:getSize# + +#if ENABLE_OVERLOADING + GutterRendererGetSizeMethodInfo , +#endif + gutterRendererGetSize , + + +-- ** getView #method:getView# + +#if ENABLE_OVERLOADING + GutterRendererGetViewMethodInfo , +#endif + gutterRendererGetView , + + +-- ** getVisible #method:getVisible# + +#if ENABLE_OVERLOADING + GutterRendererGetVisibleMethodInfo , +#endif + gutterRendererGetVisible , + + +-- ** getWindowType #method:getWindowType# + +#if ENABLE_OVERLOADING + GutterRendererGetWindowTypeMethodInfo , +#endif + gutterRendererGetWindowType , + + +-- ** queryActivatable #method:queryActivatable# + +#if ENABLE_OVERLOADING + GutterRendererQueryActivatableMethodInfo, +#endif + gutterRendererQueryActivatable , + + +-- ** queryData #method:queryData# + +#if ENABLE_OVERLOADING + GutterRendererQueryDataMethodInfo , +#endif + gutterRendererQueryData , + + +-- ** queryTooltip #method:queryTooltip# + +#if ENABLE_OVERLOADING + GutterRendererQueryTooltipMethodInfo , +#endif + gutterRendererQueryTooltip , + + +-- ** queueDraw #method:queueDraw# + +#if ENABLE_OVERLOADING + GutterRendererQueueDrawMethodInfo , +#endif + gutterRendererQueueDraw , + + +-- ** setAlignment #method:setAlignment# + +#if ENABLE_OVERLOADING + GutterRendererSetAlignmentMethodInfo , +#endif + gutterRendererSetAlignment , + + +-- ** setAlignmentMode #method:setAlignmentMode# + +#if ENABLE_OVERLOADING + GutterRendererSetAlignmentModeMethodInfo, +#endif + gutterRendererSetAlignmentMode , + + +-- ** setBackground #method:setBackground# + +#if ENABLE_OVERLOADING + GutterRendererSetBackgroundMethodInfo , +#endif + gutterRendererSetBackground , + + +-- ** setPadding #method:setPadding# + +#if ENABLE_OVERLOADING + GutterRendererSetPaddingMethodInfo , +#endif + gutterRendererSetPadding , + + +-- ** setSize #method:setSize# + +#if ENABLE_OVERLOADING + GutterRendererSetSizeMethodInfo , +#endif + gutterRendererSetSize , + + +-- ** setVisible #method:setVisible# + +#if ENABLE_OVERLOADING + GutterRendererSetVisibleMethodInfo , +#endif + gutterRendererSetVisible , + + + + + -- * Properties +-- ** alignmentMode #attr:alignmentMode# +{- | The alignment mode of the renderer. This can be used to indicate +that in the case a cell spans multiple lines (due to text wrapping) +the alignment should work on either the full cell, the first line +or the last line. +-} +#if ENABLE_OVERLOADING + GutterRendererAlignmentModePropertyInfo , +#endif + constructGutterRendererAlignmentMode , + getGutterRendererAlignmentMode , +#if ENABLE_OVERLOADING + gutterRendererAlignmentMode , +#endif + setGutterRendererAlignmentMode , + + +-- ** backgroundRgba #attr:backgroundRgba# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + GutterRendererBackgroundRgbaPropertyInfo, +#endif + clearGutterRendererBackgroundRgba , + constructGutterRendererBackgroundRgba , + getGutterRendererBackgroundRgba , +#if ENABLE_OVERLOADING + gutterRendererBackgroundRgba , +#endif + setGutterRendererBackgroundRgba , + + +-- ** backgroundSet #attr:backgroundSet# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + GutterRendererBackgroundSetPropertyInfo , +#endif + constructGutterRendererBackgroundSet , + getGutterRendererBackgroundSet , +#if ENABLE_OVERLOADING + gutterRendererBackgroundSet , +#endif + setGutterRendererBackgroundSet , + + +-- ** size #attr:size# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + GutterRendererSizePropertyInfo , +#endif + constructGutterRendererSize , + getGutterRendererSize , +#if ENABLE_OVERLOADING + gutterRendererSize , +#endif + setGutterRendererSize , + + +-- ** view #attr:view# +{- | The view on which the renderer is placed. +-} +#if ENABLE_OVERLOADING + GutterRendererViewPropertyInfo , +#endif + getGutterRendererView , +#if ENABLE_OVERLOADING + gutterRendererView , +#endif + + +-- ** visible #attr:visible# +{- | The visibility of the renderer. +-} +#if ENABLE_OVERLOADING + GutterRendererVisiblePropertyInfo , +#endif + constructGutterRendererVisible , + getGutterRendererVisible , +#if ENABLE_OVERLOADING + gutterRendererVisible , +#endif + setGutterRendererVisible , + + +-- ** windowType #attr:windowType# +{- | The window type of the view on which the renderer is placed (left, +or right). +-} +#if ENABLE_OVERLOADING + GutterRendererWindowTypePropertyInfo , +#endif + getGutterRendererWindowType , +#if ENABLE_OVERLOADING + gutterRendererWindowType , +#endif + + +-- ** xalign #attr:xalign# +{- | The horizontal alignment of the renderer. Set to 0 for a left +alignment. 1 for a right alignment. And 0.5 for centering the cells. +A value lower than 0 doesn\'t modify the alignment. +-} +#if ENABLE_OVERLOADING + GutterRendererXalignPropertyInfo , +#endif + constructGutterRendererXalign , + getGutterRendererXalign , +#if ENABLE_OVERLOADING + gutterRendererXalign , +#endif + setGutterRendererXalign , + + +-- ** xpad #attr:xpad# +{- | The left and right padding of the renderer. +-} +#if ENABLE_OVERLOADING + GutterRendererXpadPropertyInfo , +#endif + constructGutterRendererXpad , + getGutterRendererXpad , +#if ENABLE_OVERLOADING + gutterRendererXpad , +#endif + setGutterRendererXpad , + + +-- ** yalign #attr:yalign# +{- | The vertical alignment of the renderer. Set to 0 for a top +alignment. 1 for a bottom alignment. And 0.5 for centering the cells. +A value lower than 0 doesn\'t modify the alignment. +-} +#if ENABLE_OVERLOADING + GutterRendererYalignPropertyInfo , +#endif + constructGutterRendererYalign , + getGutterRendererYalign , +#if ENABLE_OVERLOADING + gutterRendererYalign , +#endif + setGutterRendererYalign , + + +-- ** ypad #attr:ypad# +{- | The top and bottom padding of the renderer. +-} +#if ENABLE_OVERLOADING + GutterRendererYpadPropertyInfo , +#endif + constructGutterRendererYpad , + getGutterRendererYpad , +#if ENABLE_OVERLOADING + gutterRendererYpad , +#endif + setGutterRendererYpad , + + + + + -- * Signals +-- ** activate #signal:activate# + + C_GutterRendererActivateCallback , + GutterRendererActivateCallback , +#if ENABLE_OVERLOADING + GutterRendererActivateSignalInfo , +#endif + afterGutterRendererActivate , + genClosure_GutterRendererActivate , + mk_GutterRendererActivateCallback , + noGutterRendererActivateCallback , + onGutterRendererActivate , + wrap_GutterRendererActivateCallback , + + +-- ** queryActivatable #signal:queryActivatable# + + C_GutterRendererQueryActivatableCallback, + GutterRendererQueryActivatableCallback , +#if ENABLE_OVERLOADING + GutterRendererQueryActivatableSignalInfo, +#endif + afterGutterRendererQueryActivatable , + genClosure_GutterRendererQueryActivatable, + mk_GutterRendererQueryActivatableCallback, + noGutterRendererQueryActivatableCallback, + onGutterRendererQueryActivatable , + wrap_GutterRendererQueryActivatableCallback, + + +-- ** queryData #signal:queryData# + + C_GutterRendererQueryDataCallback , + GutterRendererQueryDataCallback , +#if ENABLE_OVERLOADING + GutterRendererQueryDataSignalInfo , +#endif + afterGutterRendererQueryData , + genClosure_GutterRendererQueryData , + mk_GutterRendererQueryDataCallback , + noGutterRendererQueryDataCallback , + onGutterRendererQueryData , + wrap_GutterRendererQueryDataCallback , + + +-- ** queryTooltip #signal:queryTooltip# + + C_GutterRendererQueryTooltipCallback , + GutterRendererQueryTooltipCallback , +#if ENABLE_OVERLOADING + GutterRendererQueryTooltipSignalInfo , +#endif + afterGutterRendererQueryTooltip , + genClosure_GutterRendererQueryTooltip , + mk_GutterRendererQueryTooltipCallback , + noGutterRendererQueryTooltipCallback , + onGutterRendererQueryTooltip , + wrap_GutterRendererQueryTooltipCallback , + + +-- ** queueDraw #signal:queueDraw# + + C_GutterRendererQueueDrawCallback , + GutterRendererQueueDrawCallback , +#if ENABLE_OVERLOADING + GutterRendererQueueDrawSignalInfo , +#endif + afterGutterRendererQueueDraw , + genClosure_GutterRendererQueueDraw , + mk_GutterRendererQueueDrawCallback , + noGutterRendererQueueDrawCallback , + onGutterRendererQueueDraw , + wrap_GutterRendererQueueDrawCallback , + + + + + ) 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.Cairo.Structs.Context as Cairo.Context +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA +import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle +import qualified GI.Gdk.Unions.Event as Gdk.Event +import qualified GI.Gtk.Enums as Gtk.Enums +import qualified GI.Gtk.Objects.TextView as Gtk.TextView +import qualified GI.Gtk.Objects.Tooltip as Gtk.Tooltip +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 + +-- | Memory-managed wrapper type. +newtype GutterRenderer = GutterRenderer (ManagedPtr GutterRenderer) +foreign import ccall "gtk_source_gutter_renderer_get_type" + c_gtk_source_gutter_renderer_get_type :: IO GType + +instance GObject GutterRenderer where + gobjectType = c_gtk_source_gutter_renderer_get_type + + +-- | Type class for types which can be safely cast to `GutterRenderer`, for instance with `toGutterRenderer`. +class (GObject o, O.IsDescendantOf GutterRenderer o) => IsGutterRenderer o +instance (GObject o, O.IsDescendantOf GutterRenderer o) => IsGutterRenderer o + +instance O.HasParentTypes GutterRenderer +type instance O.ParentTypes GutterRenderer = '[GObject.Object.Object] + +-- | Cast to `GutterRenderer`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toGutterRenderer :: (MonadIO m, IsGutterRenderer o) => o -> m GutterRenderer +toGutterRenderer = liftIO . unsafeCastTo GutterRenderer + +-- | A convenience alias for `Nothing` :: `Maybe` `GutterRenderer`. +noGutterRenderer :: Maybe GutterRenderer +noGutterRenderer = Nothing + +#if ENABLE_OVERLOADING +type family ResolveGutterRendererMethod (t :: Symbol) (o :: *) :: * where + ResolveGutterRendererMethod "activate" o = GutterRendererActivateMethodInfo + ResolveGutterRendererMethod "begin" o = GutterRendererBeginMethodInfo + ResolveGutterRendererMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveGutterRendererMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveGutterRendererMethod "draw" o = GutterRendererDrawMethodInfo + ResolveGutterRendererMethod "end" o = GutterRendererEndMethodInfo + ResolveGutterRendererMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveGutterRendererMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveGutterRendererMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveGutterRendererMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveGutterRendererMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveGutterRendererMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveGutterRendererMethod "queryActivatable" o = GutterRendererQueryActivatableMethodInfo + ResolveGutterRendererMethod "queryData" o = GutterRendererQueryDataMethodInfo + ResolveGutterRendererMethod "queryTooltip" o = GutterRendererQueryTooltipMethodInfo + ResolveGutterRendererMethod "queueDraw" o = GutterRendererQueueDrawMethodInfo + ResolveGutterRendererMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveGutterRendererMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveGutterRendererMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveGutterRendererMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveGutterRendererMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveGutterRendererMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveGutterRendererMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveGutterRendererMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveGutterRendererMethod "getAlignment" o = GutterRendererGetAlignmentMethodInfo + ResolveGutterRendererMethod "getAlignmentMode" o = GutterRendererGetAlignmentModeMethodInfo + ResolveGutterRendererMethod "getBackground" o = GutterRendererGetBackgroundMethodInfo + ResolveGutterRendererMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveGutterRendererMethod "getPadding" o = GutterRendererGetPaddingMethodInfo + ResolveGutterRendererMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveGutterRendererMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveGutterRendererMethod "getSize" o = GutterRendererGetSizeMethodInfo + ResolveGutterRendererMethod "getView" o = GutterRendererGetViewMethodInfo + ResolveGutterRendererMethod "getVisible" o = GutterRendererGetVisibleMethodInfo + ResolveGutterRendererMethod "getWindowType" o = GutterRendererGetWindowTypeMethodInfo + ResolveGutterRendererMethod "setAlignment" o = GutterRendererSetAlignmentMethodInfo + ResolveGutterRendererMethod "setAlignmentMode" o = GutterRendererSetAlignmentModeMethodInfo + ResolveGutterRendererMethod "setBackground" o = GutterRendererSetBackgroundMethodInfo + ResolveGutterRendererMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveGutterRendererMethod "setPadding" o = GutterRendererSetPaddingMethodInfo + ResolveGutterRendererMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveGutterRendererMethod "setSize" o = GutterRendererSetSizeMethodInfo + ResolveGutterRendererMethod "setVisible" o = GutterRendererSetVisibleMethodInfo + ResolveGutterRendererMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveGutterRendererMethod t GutterRenderer, O.MethodInfo info GutterRenderer p) => OL.IsLabel t (GutterRenderer -> 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 GutterRenderer::activate +{- | +The ::activate signal is emitted when the renderer is +activated. +-} +type GutterRendererActivateCallback = + Gtk.TextIter.TextIter + {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter' -} + -> Gdk.Rectangle.Rectangle + {- ^ /@area@/: a 'GI.Gdk.Structs.Rectangle.Rectangle' -} + -> Gdk.Event.Event + {- ^ /@event@/: the event that caused the activation -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `GutterRendererActivateCallback`@. +noGutterRendererActivateCallback :: Maybe GutterRendererActivateCallback +noGutterRendererActivateCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_GutterRendererActivateCallback = + Ptr () -> -- object + Ptr Gtk.TextIter.TextIter -> + Ptr Gdk.Rectangle.Rectangle -> + Ptr Gdk.Event.Event -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_GutterRendererActivateCallback`. +foreign import ccall "wrapper" + mk_GutterRendererActivateCallback :: C_GutterRendererActivateCallback -> IO (FunPtr C_GutterRendererActivateCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_GutterRendererActivate :: MonadIO m => GutterRendererActivateCallback -> m (GClosure C_GutterRendererActivateCallback) +genClosure_GutterRendererActivate cb = liftIO $ do + let cb' = wrap_GutterRendererActivateCallback cb + mk_GutterRendererActivateCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `GutterRendererActivateCallback` into a `C_GutterRendererActivateCallback`. +wrap_GutterRendererActivateCallback :: + GutterRendererActivateCallback -> + C_GutterRendererActivateCallback +wrap_GutterRendererActivateCallback _cb _ iter area event _ = do + B.ManagedPtr.withTransient Gtk.TextIter.TextIter iter $ \iter' -> do + B.ManagedPtr.withTransient Gdk.Rectangle.Rectangle area $ \area' -> do + B.ManagedPtr.withTransient Gdk.Event.Event event $ \event' -> do + _cb iter' area' event' + + +{- | +Connect a signal handler for the “@activate@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' gutterRenderer #activate callback +@ +-} +onGutterRendererActivate :: (IsGutterRenderer a, MonadIO m) => a -> GutterRendererActivateCallback -> m SignalHandlerId +onGutterRendererActivate obj cb = liftIO $ do + let cb' = wrap_GutterRendererActivateCallback cb + cb'' <- mk_GutterRendererActivateCallback cb' + connectSignalFunPtr obj "activate" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@activate@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' gutterRenderer #activate callback +@ +-} +afterGutterRendererActivate :: (IsGutterRenderer a, MonadIO m) => a -> GutterRendererActivateCallback -> m SignalHandlerId +afterGutterRendererActivate obj cb = liftIO $ do + let cb' = wrap_GutterRendererActivateCallback cb + cb'' <- mk_GutterRendererActivateCallback cb' + connectSignalFunPtr obj "activate" cb'' SignalConnectAfter + + +-- signal GutterRenderer::query-activatable +{- | +The ::query-activatable signal is emitted when the renderer +can possibly be activated. +-} +type GutterRendererQueryActivatableCallback = + Gtk.TextIter.TextIter + {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter' -} + -> Gdk.Rectangle.Rectangle + {- ^ /@area@/: a 'GI.Gdk.Structs.Rectangle.Rectangle' -} + -> Gdk.Event.Event + {- ^ /@event@/: the 'GI.Gdk.Unions.Event.Event' that is causing the activatable query -} + -> IO Bool + +-- | A convenience synonym for @`Nothing` :: `Maybe` `GutterRendererQueryActivatableCallback`@. +noGutterRendererQueryActivatableCallback :: Maybe GutterRendererQueryActivatableCallback +noGutterRendererQueryActivatableCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_GutterRendererQueryActivatableCallback = + Ptr () -> -- object + Ptr Gtk.TextIter.TextIter -> + Ptr Gdk.Rectangle.Rectangle -> + Ptr Gdk.Event.Event -> + Ptr () -> -- user_data + IO CInt + +-- | Generate a function pointer callable from C code, from a `C_GutterRendererQueryActivatableCallback`. +foreign import ccall "wrapper" + mk_GutterRendererQueryActivatableCallback :: C_GutterRendererQueryActivatableCallback -> IO (FunPtr C_GutterRendererQueryActivatableCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_GutterRendererQueryActivatable :: MonadIO m => GutterRendererQueryActivatableCallback -> m (GClosure C_GutterRendererQueryActivatableCallback) +genClosure_GutterRendererQueryActivatable cb = liftIO $ do + let cb' = wrap_GutterRendererQueryActivatableCallback cb + mk_GutterRendererQueryActivatableCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `GutterRendererQueryActivatableCallback` into a `C_GutterRendererQueryActivatableCallback`. +wrap_GutterRendererQueryActivatableCallback :: + GutterRendererQueryActivatableCallback -> + C_GutterRendererQueryActivatableCallback +wrap_GutterRendererQueryActivatableCallback _cb _ iter area event _ = do + B.ManagedPtr.withTransient Gtk.TextIter.TextIter iter $ \iter' -> do + B.ManagedPtr.withTransient Gdk.Rectangle.Rectangle area $ \area' -> do + B.ManagedPtr.withTransient Gdk.Event.Event event $ \event' -> do + result <- _cb iter' area' event' + let result' = (fromIntegral . fromEnum) result + return result' + + +{- | +Connect a signal handler for the “@query-activatable@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' gutterRenderer #queryActivatable callback +@ +-} +onGutterRendererQueryActivatable :: (IsGutterRenderer a, MonadIO m) => a -> GutterRendererQueryActivatableCallback -> m SignalHandlerId +onGutterRendererQueryActivatable obj cb = liftIO $ do + let cb' = wrap_GutterRendererQueryActivatableCallback cb + cb'' <- mk_GutterRendererQueryActivatableCallback cb' + connectSignalFunPtr obj "query-activatable" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@query-activatable@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' gutterRenderer #queryActivatable callback +@ +-} +afterGutterRendererQueryActivatable :: (IsGutterRenderer a, MonadIO m) => a -> GutterRendererQueryActivatableCallback -> m SignalHandlerId +afterGutterRendererQueryActivatable obj cb = liftIO $ do + let cb' = wrap_GutterRendererQueryActivatableCallback cb + cb'' <- mk_GutterRendererQueryActivatableCallback cb' + connectSignalFunPtr obj "query-activatable" cb'' SignalConnectAfter + + +-- signal GutterRenderer::query-data +{- | +The ::query-data signal is emitted when the renderer needs +to be filled with data just before a cell is drawn. This can +be used by general renderer implementations to allow render +data to be filled in externally. +-} +type GutterRendererQueryDataCallback = + Gtk.TextIter.TextIter + {- ^ /@start@/: a 'GI.Gtk.Structs.TextIter.TextIter' -} + -> Gtk.TextIter.TextIter + {- ^ /@end@/: a 'GI.Gtk.Structs.TextIter.TextIter' -} + -> [GtkSource.Flags.GutterRendererState] + {- ^ /@state@/: the renderer state -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `GutterRendererQueryDataCallback`@. +noGutterRendererQueryDataCallback :: Maybe GutterRendererQueryDataCallback +noGutterRendererQueryDataCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_GutterRendererQueryDataCallback = + Ptr () -> -- object + Ptr Gtk.TextIter.TextIter -> + Ptr Gtk.TextIter.TextIter -> + CUInt -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_GutterRendererQueryDataCallback`. +foreign import ccall "wrapper" + mk_GutterRendererQueryDataCallback :: C_GutterRendererQueryDataCallback -> IO (FunPtr C_GutterRendererQueryDataCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_GutterRendererQueryData :: MonadIO m => GutterRendererQueryDataCallback -> m (GClosure C_GutterRendererQueryDataCallback) +genClosure_GutterRendererQueryData cb = liftIO $ do + let cb' = wrap_GutterRendererQueryDataCallback cb + mk_GutterRendererQueryDataCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `GutterRendererQueryDataCallback` into a `C_GutterRendererQueryDataCallback`. +wrap_GutterRendererQueryDataCallback :: + GutterRendererQueryDataCallback -> + C_GutterRendererQueryDataCallback +wrap_GutterRendererQueryDataCallback _cb _ start end state _ = do + B.ManagedPtr.withTransient Gtk.TextIter.TextIter start $ \start' -> do + B.ManagedPtr.withTransient Gtk.TextIter.TextIter end $ \end' -> do + let state' = wordToGFlags state + _cb start' end' state' + + +{- | +Connect a signal handler for the “@query-data@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' gutterRenderer #queryData callback +@ +-} +onGutterRendererQueryData :: (IsGutterRenderer a, MonadIO m) => a -> GutterRendererQueryDataCallback -> m SignalHandlerId +onGutterRendererQueryData obj cb = liftIO $ do + let cb' = wrap_GutterRendererQueryDataCallback cb + cb'' <- mk_GutterRendererQueryDataCallback cb' + connectSignalFunPtr obj "query-data" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@query-data@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' gutterRenderer #queryData callback +@ +-} +afterGutterRendererQueryData :: (IsGutterRenderer a, MonadIO m) => a -> GutterRendererQueryDataCallback -> m SignalHandlerId +afterGutterRendererQueryData obj cb = liftIO $ do + let cb' = wrap_GutterRendererQueryDataCallback cb + cb'' <- mk_GutterRendererQueryDataCallback cb' + connectSignalFunPtr obj "query-data" cb'' SignalConnectAfter + + +-- signal GutterRenderer::query-tooltip +{- | +The ::query-tooltip signal is emitted when the renderer can +show a tooltip. +-} +type GutterRendererQueryTooltipCallback = + Gtk.TextIter.TextIter + {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter' -} + -> Gdk.Rectangle.Rectangle + {- ^ /@area@/: a 'GI.Gdk.Structs.Rectangle.Rectangle' -} + -> Int32 + {- ^ /@x@/: the x position (in window coordinates) -} + -> Int32 + {- ^ /@y@/: the y position (in window coordinates) -} + -> Gtk.Tooltip.Tooltip + {- ^ /@tooltip@/: a 'GI.Gtk.Objects.Tooltip.Tooltip' -} + -> IO Bool + +-- | A convenience synonym for @`Nothing` :: `Maybe` `GutterRendererQueryTooltipCallback`@. +noGutterRendererQueryTooltipCallback :: Maybe GutterRendererQueryTooltipCallback +noGutterRendererQueryTooltipCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_GutterRendererQueryTooltipCallback = + Ptr () -> -- object + Ptr Gtk.TextIter.TextIter -> + Ptr Gdk.Rectangle.Rectangle -> + Int32 -> + Int32 -> + Ptr Gtk.Tooltip.Tooltip -> + Ptr () -> -- user_data + IO CInt + +-- | Generate a function pointer callable from C code, from a `C_GutterRendererQueryTooltipCallback`. +foreign import ccall "wrapper" + mk_GutterRendererQueryTooltipCallback :: C_GutterRendererQueryTooltipCallback -> IO (FunPtr C_GutterRendererQueryTooltipCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_GutterRendererQueryTooltip :: MonadIO m => GutterRendererQueryTooltipCallback -> m (GClosure C_GutterRendererQueryTooltipCallback) +genClosure_GutterRendererQueryTooltip cb = liftIO $ do + let cb' = wrap_GutterRendererQueryTooltipCallback cb + mk_GutterRendererQueryTooltipCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `GutterRendererQueryTooltipCallback` into a `C_GutterRendererQueryTooltipCallback`. +wrap_GutterRendererQueryTooltipCallback :: + GutterRendererQueryTooltipCallback -> + C_GutterRendererQueryTooltipCallback +wrap_GutterRendererQueryTooltipCallback _cb _ iter area x y tooltip _ = do + B.ManagedPtr.withTransient Gtk.TextIter.TextIter iter $ \iter' -> do + B.ManagedPtr.withTransient Gdk.Rectangle.Rectangle area $ \area' -> do + tooltip' <- (newObject Gtk.Tooltip.Tooltip) tooltip + result <- _cb iter' area' x y tooltip' + let result' = (fromIntegral . fromEnum) result + return result' + + +{- | +Connect a signal handler for the “@query-tooltip@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' gutterRenderer #queryTooltip callback +@ +-} +onGutterRendererQueryTooltip :: (IsGutterRenderer a, MonadIO m) => a -> GutterRendererQueryTooltipCallback -> m SignalHandlerId +onGutterRendererQueryTooltip obj cb = liftIO $ do + let cb' = wrap_GutterRendererQueryTooltipCallback cb + cb'' <- mk_GutterRendererQueryTooltipCallback cb' + connectSignalFunPtr obj "query-tooltip" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@query-tooltip@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' gutterRenderer #queryTooltip callback +@ +-} +afterGutterRendererQueryTooltip :: (IsGutterRenderer a, MonadIO m) => a -> GutterRendererQueryTooltipCallback -> m SignalHandlerId +afterGutterRendererQueryTooltip obj cb = liftIO $ do + let cb' = wrap_GutterRendererQueryTooltipCallback cb + cb'' <- mk_GutterRendererQueryTooltipCallback cb' + connectSignalFunPtr obj "query-tooltip" cb'' SignalConnectAfter + + +-- signal GutterRenderer::queue-draw +{- | +The ::queue-draw signal is emitted when the renderer needs +to be redrawn. Use 'GI.GtkSource.Objects.GutterRenderer.gutterRendererQueueDraw' +to emit this signal from an implementation of the +'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' interface. +-} +type GutterRendererQueueDrawCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `GutterRendererQueueDrawCallback`@. +noGutterRendererQueueDrawCallback :: Maybe GutterRendererQueueDrawCallback +noGutterRendererQueueDrawCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_GutterRendererQueueDrawCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_GutterRendererQueueDrawCallback`. +foreign import ccall "wrapper" + mk_GutterRendererQueueDrawCallback :: C_GutterRendererQueueDrawCallback -> IO (FunPtr C_GutterRendererQueueDrawCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_GutterRendererQueueDraw :: MonadIO m => GutterRendererQueueDrawCallback -> m (GClosure C_GutterRendererQueueDrawCallback) +genClosure_GutterRendererQueueDraw cb = liftIO $ do + let cb' = wrap_GutterRendererQueueDrawCallback cb + mk_GutterRendererQueueDrawCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `GutterRendererQueueDrawCallback` into a `C_GutterRendererQueueDrawCallback`. +wrap_GutterRendererQueueDrawCallback :: + GutterRendererQueueDrawCallback -> + C_GutterRendererQueueDrawCallback +wrap_GutterRendererQueueDrawCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@queue-draw@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' gutterRenderer #queueDraw callback +@ +-} +onGutterRendererQueueDraw :: (IsGutterRenderer a, MonadIO m) => a -> GutterRendererQueueDrawCallback -> m SignalHandlerId +onGutterRendererQueueDraw obj cb = liftIO $ do + let cb' = wrap_GutterRendererQueueDrawCallback cb + cb'' <- mk_GutterRendererQueueDrawCallback cb' + connectSignalFunPtr obj "queue-draw" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@queue-draw@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' gutterRenderer #queueDraw callback +@ +-} +afterGutterRendererQueueDraw :: (IsGutterRenderer a, MonadIO m) => a -> GutterRendererQueueDrawCallback -> m SignalHandlerId +afterGutterRendererQueueDraw obj cb = liftIO $ do + let cb' = wrap_GutterRendererQueueDrawCallback cb + cb'' <- mk_GutterRendererQueueDrawCallback cb' + connectSignalFunPtr obj "queue-draw" cb'' SignalConnectAfter + + +-- VVV Prop "alignment-mode" + -- Type: TInterface (Name {namespace = "GtkSource", name = "GutterRendererAlignmentMode"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@alignment-mode@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' gutterRenderer #alignmentMode +@ +-} +getGutterRendererAlignmentMode :: (MonadIO m, IsGutterRenderer o) => o -> m GtkSource.Enums.GutterRendererAlignmentMode +getGutterRendererAlignmentMode obj = liftIO $ B.Properties.getObjectPropertyEnum obj "alignment-mode" + +{- | +Set the value of the “@alignment-mode@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' gutterRenderer [ #alignmentMode 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setGutterRendererAlignmentMode :: (MonadIO m, IsGutterRenderer o) => o -> GtkSource.Enums.GutterRendererAlignmentMode -> m () +setGutterRendererAlignmentMode obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "alignment-mode" val + +{- | +Construct a `GValueConstruct` with valid value for the “@alignment-mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructGutterRendererAlignmentMode :: (IsGutterRenderer o) => GtkSource.Enums.GutterRendererAlignmentMode -> IO (GValueConstruct o) +constructGutterRendererAlignmentMode val = B.Properties.constructObjectPropertyEnum "alignment-mode" val + +#if ENABLE_OVERLOADING +data GutterRendererAlignmentModePropertyInfo +instance AttrInfo GutterRendererAlignmentModePropertyInfo where + type AttrAllowedOps GutterRendererAlignmentModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint GutterRendererAlignmentModePropertyInfo = (~) GtkSource.Enums.GutterRendererAlignmentMode + type AttrBaseTypeConstraint GutterRendererAlignmentModePropertyInfo = IsGutterRenderer + type AttrGetType GutterRendererAlignmentModePropertyInfo = GtkSource.Enums.GutterRendererAlignmentMode + type AttrLabel GutterRendererAlignmentModePropertyInfo = "alignment-mode" + type AttrOrigin GutterRendererAlignmentModePropertyInfo = GutterRenderer + attrGet _ = getGutterRendererAlignmentMode + attrSet _ = setGutterRendererAlignmentMode + attrConstruct _ = constructGutterRendererAlignmentMode + attrClear _ = undefined +#endif + +-- VVV Prop "background-rgba" + -- Type: TInterface (Name {namespace = "Gdk", name = "RGBA"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@background-rgba@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' gutterRenderer #backgroundRgba +@ +-} +getGutterRendererBackgroundRgba :: (MonadIO m, IsGutterRenderer o) => o -> m (Maybe Gdk.RGBA.RGBA) +getGutterRendererBackgroundRgba obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "background-rgba" Gdk.RGBA.RGBA + +{- | +Set the value of the “@background-rgba@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' gutterRenderer [ #backgroundRgba 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setGutterRendererBackgroundRgba :: (MonadIO m, IsGutterRenderer o) => o -> Gdk.RGBA.RGBA -> m () +setGutterRendererBackgroundRgba obj val = liftIO $ B.Properties.setObjectPropertyBoxed obj "background-rgba" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@background-rgba@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructGutterRendererBackgroundRgba :: (IsGutterRenderer o) => Gdk.RGBA.RGBA -> IO (GValueConstruct o) +constructGutterRendererBackgroundRgba val = B.Properties.constructObjectPropertyBoxed "background-rgba" (Just val) + +{- | +Set the value of the “@background-rgba@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #backgroundRgba +@ +-} +clearGutterRendererBackgroundRgba :: (MonadIO m, IsGutterRenderer o) => o -> m () +clearGutterRendererBackgroundRgba obj = liftIO $ B.Properties.setObjectPropertyBoxed obj "background-rgba" (Nothing :: Maybe Gdk.RGBA.RGBA) + +#if ENABLE_OVERLOADING +data GutterRendererBackgroundRgbaPropertyInfo +instance AttrInfo GutterRendererBackgroundRgbaPropertyInfo where + type AttrAllowedOps GutterRendererBackgroundRgbaPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint GutterRendererBackgroundRgbaPropertyInfo = (~) Gdk.RGBA.RGBA + type AttrBaseTypeConstraint GutterRendererBackgroundRgbaPropertyInfo = IsGutterRenderer + type AttrGetType GutterRendererBackgroundRgbaPropertyInfo = (Maybe Gdk.RGBA.RGBA) + type AttrLabel GutterRendererBackgroundRgbaPropertyInfo = "background-rgba" + type AttrOrigin GutterRendererBackgroundRgbaPropertyInfo = GutterRenderer + attrGet _ = getGutterRendererBackgroundRgba + attrSet _ = setGutterRendererBackgroundRgba + attrConstruct _ = constructGutterRendererBackgroundRgba + attrClear _ = clearGutterRendererBackgroundRgba +#endif + +-- VVV Prop "background-set" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@background-set@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' gutterRenderer #backgroundSet +@ +-} +getGutterRendererBackgroundSet :: (MonadIO m, IsGutterRenderer o) => o -> m Bool +getGutterRendererBackgroundSet obj = liftIO $ B.Properties.getObjectPropertyBool obj "background-set" + +{- | +Set the value of the “@background-set@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' gutterRenderer [ #backgroundSet 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setGutterRendererBackgroundSet :: (MonadIO m, IsGutterRenderer o) => o -> Bool -> m () +setGutterRendererBackgroundSet obj val = liftIO $ B.Properties.setObjectPropertyBool obj "background-set" val + +{- | +Construct a `GValueConstruct` with valid value for the “@background-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructGutterRendererBackgroundSet :: (IsGutterRenderer o) => Bool -> IO (GValueConstruct o) +constructGutterRendererBackgroundSet val = B.Properties.constructObjectPropertyBool "background-set" val + +#if ENABLE_OVERLOADING +data GutterRendererBackgroundSetPropertyInfo +instance AttrInfo GutterRendererBackgroundSetPropertyInfo where + type AttrAllowedOps GutterRendererBackgroundSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint GutterRendererBackgroundSetPropertyInfo = (~) Bool + type AttrBaseTypeConstraint GutterRendererBackgroundSetPropertyInfo = IsGutterRenderer + type AttrGetType GutterRendererBackgroundSetPropertyInfo = Bool + type AttrLabel GutterRendererBackgroundSetPropertyInfo = "background-set" + type AttrOrigin GutterRendererBackgroundSetPropertyInfo = GutterRenderer + attrGet _ = getGutterRendererBackgroundSet + attrSet _ = setGutterRendererBackgroundSet + attrConstruct _ = constructGutterRendererBackgroundSet + attrClear _ = undefined +#endif + +-- VVV Prop "size" + -- Type: TBasicType TInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@size@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' gutterRenderer #size +@ +-} +getGutterRendererSize :: (MonadIO m, IsGutterRenderer o) => o -> m Int32 +getGutterRendererSize obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "size" + +{- | +Set the value of the “@size@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' gutterRenderer [ #size 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setGutterRendererSize :: (MonadIO m, IsGutterRenderer o) => o -> Int32 -> m () +setGutterRendererSize obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "size" val + +{- | +Construct a `GValueConstruct` with valid value for the “@size@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructGutterRendererSize :: (IsGutterRenderer o) => Int32 -> IO (GValueConstruct o) +constructGutterRendererSize val = B.Properties.constructObjectPropertyInt32 "size" val + +#if ENABLE_OVERLOADING +data GutterRendererSizePropertyInfo +instance AttrInfo GutterRendererSizePropertyInfo where + type AttrAllowedOps GutterRendererSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint GutterRendererSizePropertyInfo = (~) Int32 + type AttrBaseTypeConstraint GutterRendererSizePropertyInfo = IsGutterRenderer + type AttrGetType GutterRendererSizePropertyInfo = Int32 + type AttrLabel GutterRendererSizePropertyInfo = "size" + type AttrOrigin GutterRendererSizePropertyInfo = GutterRenderer + attrGet _ = getGutterRendererSize + attrSet _ = setGutterRendererSize + attrConstruct _ = constructGutterRendererSize + attrClear _ = undefined +#endif + +-- VVV Prop "view" + -- Type: TInterface (Name {namespace = "Gtk", name = "TextView"}) + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@view@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' gutterRenderer #view +@ +-} +getGutterRendererView :: (MonadIO m, IsGutterRenderer o) => o -> m Gtk.TextView.TextView +getGutterRendererView obj = liftIO $ checkUnexpectedNothing "getGutterRendererView" $ B.Properties.getObjectPropertyObject obj "view" Gtk.TextView.TextView + +#if ENABLE_OVERLOADING +data GutterRendererViewPropertyInfo +instance AttrInfo GutterRendererViewPropertyInfo where + type AttrAllowedOps GutterRendererViewPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint GutterRendererViewPropertyInfo = (~) () + type AttrBaseTypeConstraint GutterRendererViewPropertyInfo = IsGutterRenderer + type AttrGetType GutterRendererViewPropertyInfo = Gtk.TextView.TextView + type AttrLabel GutterRendererViewPropertyInfo = "view" + type AttrOrigin GutterRendererViewPropertyInfo = GutterRenderer + attrGet _ = getGutterRendererView + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "visible" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@visible@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' gutterRenderer #visible +@ +-} +getGutterRendererVisible :: (MonadIO m, IsGutterRenderer o) => o -> m Bool +getGutterRendererVisible obj = liftIO $ B.Properties.getObjectPropertyBool obj "visible" + +{- | +Set the value of the “@visible@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' gutterRenderer [ #visible 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setGutterRendererVisible :: (MonadIO m, IsGutterRenderer o) => o -> Bool -> m () +setGutterRendererVisible obj val = liftIO $ B.Properties.setObjectPropertyBool obj "visible" val + +{- | +Construct a `GValueConstruct` with valid value for the “@visible@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructGutterRendererVisible :: (IsGutterRenderer o) => Bool -> IO (GValueConstruct o) +constructGutterRendererVisible val = B.Properties.constructObjectPropertyBool "visible" val + +#if ENABLE_OVERLOADING +data GutterRendererVisiblePropertyInfo +instance AttrInfo GutterRendererVisiblePropertyInfo where + type AttrAllowedOps GutterRendererVisiblePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint GutterRendererVisiblePropertyInfo = (~) Bool + type AttrBaseTypeConstraint GutterRendererVisiblePropertyInfo = IsGutterRenderer + type AttrGetType GutterRendererVisiblePropertyInfo = Bool + type AttrLabel GutterRendererVisiblePropertyInfo = "visible" + type AttrOrigin GutterRendererVisiblePropertyInfo = GutterRenderer + attrGet _ = getGutterRendererVisible + attrSet _ = setGutterRendererVisible + attrConstruct _ = constructGutterRendererVisible + attrClear _ = undefined +#endif + +-- VVV Prop "window-type" + -- Type: TInterface (Name {namespace = "Gtk", name = "TextWindowType"}) + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@window-type@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' gutterRenderer #windowType +@ +-} +getGutterRendererWindowType :: (MonadIO m, IsGutterRenderer o) => o -> m Gtk.Enums.TextWindowType +getGutterRendererWindowType obj = liftIO $ B.Properties.getObjectPropertyEnum obj "window-type" + +#if ENABLE_OVERLOADING +data GutterRendererWindowTypePropertyInfo +instance AttrInfo GutterRendererWindowTypePropertyInfo where + type AttrAllowedOps GutterRendererWindowTypePropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint GutterRendererWindowTypePropertyInfo = (~) () + type AttrBaseTypeConstraint GutterRendererWindowTypePropertyInfo = IsGutterRenderer + type AttrGetType GutterRendererWindowTypePropertyInfo = Gtk.Enums.TextWindowType + type AttrLabel GutterRendererWindowTypePropertyInfo = "window-type" + type AttrOrigin GutterRendererWindowTypePropertyInfo = GutterRenderer + attrGet _ = getGutterRendererWindowType + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "xalign" + -- Type: TBasicType TFloat + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@xalign@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' gutterRenderer #xalign +@ +-} +getGutterRendererXalign :: (MonadIO m, IsGutterRenderer o) => o -> m Float +getGutterRendererXalign obj = liftIO $ B.Properties.getObjectPropertyFloat obj "xalign" + +{- | +Set the value of the “@xalign@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' gutterRenderer [ #xalign 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setGutterRendererXalign :: (MonadIO m, IsGutterRenderer o) => o -> Float -> m () +setGutterRendererXalign obj val = liftIO $ B.Properties.setObjectPropertyFloat obj "xalign" val + +{- | +Construct a `GValueConstruct` with valid value for the “@xalign@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructGutterRendererXalign :: (IsGutterRenderer o) => Float -> IO (GValueConstruct o) +constructGutterRendererXalign val = B.Properties.constructObjectPropertyFloat "xalign" val + +#if ENABLE_OVERLOADING +data GutterRendererXalignPropertyInfo +instance AttrInfo GutterRendererXalignPropertyInfo where + type AttrAllowedOps GutterRendererXalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint GutterRendererXalignPropertyInfo = (~) Float + type AttrBaseTypeConstraint GutterRendererXalignPropertyInfo = IsGutterRenderer + type AttrGetType GutterRendererXalignPropertyInfo = Float + type AttrLabel GutterRendererXalignPropertyInfo = "xalign" + type AttrOrigin GutterRendererXalignPropertyInfo = GutterRenderer + attrGet _ = getGutterRendererXalign + attrSet _ = setGutterRendererXalign + attrConstruct _ = constructGutterRendererXalign + attrClear _ = undefined +#endif + +-- VVV Prop "xpad" + -- Type: TBasicType TInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@xpad@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' gutterRenderer #xpad +@ +-} +getGutterRendererXpad :: (MonadIO m, IsGutterRenderer o) => o -> m Int32 +getGutterRendererXpad obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "xpad" + +{- | +Set the value of the “@xpad@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' gutterRenderer [ #xpad 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setGutterRendererXpad :: (MonadIO m, IsGutterRenderer o) => o -> Int32 -> m () +setGutterRendererXpad obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "xpad" val + +{- | +Construct a `GValueConstruct` with valid value for the “@xpad@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructGutterRendererXpad :: (IsGutterRenderer o) => Int32 -> IO (GValueConstruct o) +constructGutterRendererXpad val = B.Properties.constructObjectPropertyInt32 "xpad" val + +#if ENABLE_OVERLOADING +data GutterRendererXpadPropertyInfo +instance AttrInfo GutterRendererXpadPropertyInfo where + type AttrAllowedOps GutterRendererXpadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint GutterRendererXpadPropertyInfo = (~) Int32 + type AttrBaseTypeConstraint GutterRendererXpadPropertyInfo = IsGutterRenderer + type AttrGetType GutterRendererXpadPropertyInfo = Int32 + type AttrLabel GutterRendererXpadPropertyInfo = "xpad" + type AttrOrigin GutterRendererXpadPropertyInfo = GutterRenderer + attrGet _ = getGutterRendererXpad + attrSet _ = setGutterRendererXpad + attrConstruct _ = constructGutterRendererXpad + attrClear _ = undefined +#endif + +-- VVV Prop "yalign" + -- Type: TBasicType TFloat + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@yalign@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' gutterRenderer #yalign +@ +-} +getGutterRendererYalign :: (MonadIO m, IsGutterRenderer o) => o -> m Float +getGutterRendererYalign obj = liftIO $ B.Properties.getObjectPropertyFloat obj "yalign" + +{- | +Set the value of the “@yalign@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' gutterRenderer [ #yalign 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setGutterRendererYalign :: (MonadIO m, IsGutterRenderer o) => o -> Float -> m () +setGutterRendererYalign obj val = liftIO $ B.Properties.setObjectPropertyFloat obj "yalign" val + +{- | +Construct a `GValueConstruct` with valid value for the “@yalign@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructGutterRendererYalign :: (IsGutterRenderer o) => Float -> IO (GValueConstruct o) +constructGutterRendererYalign val = B.Properties.constructObjectPropertyFloat "yalign" val + +#if ENABLE_OVERLOADING +data GutterRendererYalignPropertyInfo +instance AttrInfo GutterRendererYalignPropertyInfo where + type AttrAllowedOps GutterRendererYalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint GutterRendererYalignPropertyInfo = (~) Float + type AttrBaseTypeConstraint GutterRendererYalignPropertyInfo = IsGutterRenderer + type AttrGetType GutterRendererYalignPropertyInfo = Float + type AttrLabel GutterRendererYalignPropertyInfo = "yalign" + type AttrOrigin GutterRendererYalignPropertyInfo = GutterRenderer + attrGet _ = getGutterRendererYalign + attrSet _ = setGutterRendererYalign + attrConstruct _ = constructGutterRendererYalign + attrClear _ = undefined +#endif + +-- VVV Prop "ypad" + -- Type: TBasicType TInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@ypad@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' gutterRenderer #ypad +@ +-} +getGutterRendererYpad :: (MonadIO m, IsGutterRenderer o) => o -> m Int32 +getGutterRendererYpad obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "ypad" + +{- | +Set the value of the “@ypad@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' gutterRenderer [ #ypad 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setGutterRendererYpad :: (MonadIO m, IsGutterRenderer o) => o -> Int32 -> m () +setGutterRendererYpad obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "ypad" val + +{- | +Construct a `GValueConstruct` with valid value for the “@ypad@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructGutterRendererYpad :: (IsGutterRenderer o) => Int32 -> IO (GValueConstruct o) +constructGutterRendererYpad val = B.Properties.constructObjectPropertyInt32 "ypad" val + +#if ENABLE_OVERLOADING +data GutterRendererYpadPropertyInfo +instance AttrInfo GutterRendererYpadPropertyInfo where + type AttrAllowedOps GutterRendererYpadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint GutterRendererYpadPropertyInfo = (~) Int32 + type AttrBaseTypeConstraint GutterRendererYpadPropertyInfo = IsGutterRenderer + type AttrGetType GutterRendererYpadPropertyInfo = Int32 + type AttrLabel GutterRendererYpadPropertyInfo = "ypad" + type AttrOrigin GutterRendererYpadPropertyInfo = GutterRenderer + attrGet _ = getGutterRendererYpad + attrSet _ = setGutterRendererYpad + attrConstruct _ = constructGutterRendererYpad + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList GutterRenderer +type instance O.AttributeList GutterRenderer = GutterRendererAttributeList +type GutterRendererAttributeList = ('[ '("alignmentMode", GutterRendererAlignmentModePropertyInfo), '("backgroundRgba", GutterRendererBackgroundRgbaPropertyInfo), '("backgroundSet", GutterRendererBackgroundSetPropertyInfo), '("size", GutterRendererSizePropertyInfo), '("view", GutterRendererViewPropertyInfo), '("visible", GutterRendererVisiblePropertyInfo), '("windowType", GutterRendererWindowTypePropertyInfo), '("xalign", GutterRendererXalignPropertyInfo), '("xpad", GutterRendererXpadPropertyInfo), '("yalign", GutterRendererYalignPropertyInfo), '("ypad", GutterRendererYpadPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +gutterRendererAlignmentMode :: AttrLabelProxy "alignmentMode" +gutterRendererAlignmentMode = AttrLabelProxy + +gutterRendererBackgroundRgba :: AttrLabelProxy "backgroundRgba" +gutterRendererBackgroundRgba = AttrLabelProxy + +gutterRendererBackgroundSet :: AttrLabelProxy "backgroundSet" +gutterRendererBackgroundSet = AttrLabelProxy + +gutterRendererSize :: AttrLabelProxy "size" +gutterRendererSize = AttrLabelProxy + +gutterRendererView :: AttrLabelProxy "view" +gutterRendererView = AttrLabelProxy + +gutterRendererVisible :: AttrLabelProxy "visible" +gutterRendererVisible = AttrLabelProxy + +gutterRendererWindowType :: AttrLabelProxy "windowType" +gutterRendererWindowType = AttrLabelProxy + +gutterRendererXalign :: AttrLabelProxy "xalign" +gutterRendererXalign = AttrLabelProxy + +gutterRendererXpad :: AttrLabelProxy "xpad" +gutterRendererXpad = AttrLabelProxy + +gutterRendererYalign :: AttrLabelProxy "yalign" +gutterRendererYalign = AttrLabelProxy + +gutterRendererYpad :: AttrLabelProxy "ypad" +gutterRendererYpad = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +data GutterRendererActivateSignalInfo +instance SignalInfo GutterRendererActivateSignalInfo where + type HaskellCallbackType GutterRendererActivateSignalInfo = GutterRendererActivateCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_GutterRendererActivateCallback cb + cb'' <- mk_GutterRendererActivateCallback cb' + connectSignalFunPtr obj "activate" cb'' connectMode + +data GutterRendererQueryActivatableSignalInfo +instance SignalInfo GutterRendererQueryActivatableSignalInfo where + type HaskellCallbackType GutterRendererQueryActivatableSignalInfo = GutterRendererQueryActivatableCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_GutterRendererQueryActivatableCallback cb + cb'' <- mk_GutterRendererQueryActivatableCallback cb' + connectSignalFunPtr obj "query-activatable" cb'' connectMode + +data GutterRendererQueryDataSignalInfo +instance SignalInfo GutterRendererQueryDataSignalInfo where + type HaskellCallbackType GutterRendererQueryDataSignalInfo = GutterRendererQueryDataCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_GutterRendererQueryDataCallback cb + cb'' <- mk_GutterRendererQueryDataCallback cb' + connectSignalFunPtr obj "query-data" cb'' connectMode + +data GutterRendererQueryTooltipSignalInfo +instance SignalInfo GutterRendererQueryTooltipSignalInfo where + type HaskellCallbackType GutterRendererQueryTooltipSignalInfo = GutterRendererQueryTooltipCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_GutterRendererQueryTooltipCallback cb + cb'' <- mk_GutterRendererQueryTooltipCallback cb' + connectSignalFunPtr obj "query-tooltip" cb'' connectMode + +data GutterRendererQueueDrawSignalInfo +instance SignalInfo GutterRendererQueueDrawSignalInfo where + type HaskellCallbackType GutterRendererQueueDrawSignalInfo = GutterRendererQueueDrawCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_GutterRendererQueueDrawCallback cb + cb'' <- mk_GutterRendererQueueDrawCallback cb' + connectSignalFunPtr obj "queue-draw" cb'' connectMode + +type instance O.SignalList GutterRenderer = GutterRendererSignalList +type GutterRendererSignalList = ('[ '("activate", GutterRendererActivateSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("queryActivatable", GutterRendererQueryActivatableSignalInfo), '("queryData", GutterRendererQueryDataSignalInfo), '("queryTooltip", GutterRendererQueryTooltipSignalInfo), '("queueDraw", GutterRendererQueueDrawSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method GutterRenderer::activate +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter at the start of the line where the renderer is activated", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "area", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRectangle of the cell area where the renderer is activated", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gdk", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the event that triggered the activation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_renderer_activate" gtk_source_gutter_renderer_activate :: + Ptr GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}) + Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gdk.Rectangle.Rectangle -> -- area : TInterface (Name {namespace = "Gdk", name = "Rectangle"}) + Ptr Gdk.Event.Event -> -- event : TInterface (Name {namespace = "Gdk", name = "Event"}) + IO () + +{- | +Emits the 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'::@/activate/@ signal of the renderer. This is +called from 'GI.GtkSource.Objects.Gutter.Gutter' and should never have to be called manually. +-} +gutterRendererActivate :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -} + -> Gtk.TextIter.TextIter + {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter' at the start of the line where the renderer is activated -} + -> Gdk.Rectangle.Rectangle + {- ^ /@area@/: a 'GI.Gdk.Structs.Rectangle.Rectangle' of the cell area where the renderer is activated -} + -> Gdk.Event.Event + {- ^ /@event@/: the event that triggered the activation -} + -> m () +gutterRendererActivate renderer iter area event = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + iter' <- unsafeManagedPtrGetPtr iter + area' <- unsafeManagedPtrGetPtr area + event' <- unsafeManagedPtrGetPtr event + gtk_source_gutter_renderer_activate renderer' iter' area' event' + touchManagedPtr renderer + touchManagedPtr iter + touchManagedPtr area + touchManagedPtr event + return () + +#if ENABLE_OVERLOADING +data GutterRendererActivateMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> Gdk.Rectangle.Rectangle -> Gdk.Event.Event -> m ()), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererActivateMethodInfo a signature where + overloadedMethod _ = gutterRendererActivate + +#endif + +-- method GutterRenderer::begin +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cr", argType = TInterface (Name {namespace = "cairo", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #cairo_t", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "background_area", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cell_area", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRectangle", 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_gutter_renderer_begin" gtk_source_gutter_renderer_begin :: + Ptr GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}) + Ptr Cairo.Context.Context -> -- cr : TInterface (Name {namespace = "cairo", name = "Context"}) + Ptr Gdk.Rectangle.Rectangle -> -- background_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"}) + Ptr Gdk.Rectangle.Rectangle -> -- cell_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"}) + Ptr Gtk.TextIter.TextIter -> -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + IO () + +{- | +Called when drawing a region begins. The region to be drawn is indicated +by /@start@/ and /@end@/. The purpose is to allow the implementation to precompute +some state before the draw method is called for each cell. +-} +gutterRendererBegin :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -} + -> Cairo.Context.Context + {- ^ /@cr@/: a 'GI.Cairo.Structs.Context.Context' -} + -> Gdk.Rectangle.Rectangle + {- ^ /@backgroundArea@/: a 'GI.Gdk.Structs.Rectangle.Rectangle' -} + -> Gdk.Rectangle.Rectangle + {- ^ /@cellArea@/: a 'GI.Gdk.Structs.Rectangle.Rectangle' -} + -> Gtk.TextIter.TextIter + {- ^ /@start@/: a 'GI.Gtk.Structs.TextIter.TextIter' -} + -> Gtk.TextIter.TextIter + {- ^ /@end@/: a 'GI.Gtk.Structs.TextIter.TextIter' -} + -> m () +gutterRendererBegin renderer cr backgroundArea cellArea start end = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + cr' <- unsafeManagedPtrGetPtr cr + backgroundArea' <- unsafeManagedPtrGetPtr backgroundArea + cellArea' <- unsafeManagedPtrGetPtr cellArea + start' <- unsafeManagedPtrGetPtr start + end' <- unsafeManagedPtrGetPtr end + gtk_source_gutter_renderer_begin renderer' cr' backgroundArea' cellArea' start' end' + touchManagedPtr renderer + touchManagedPtr cr + touchManagedPtr backgroundArea + touchManagedPtr cellArea + touchManagedPtr start + touchManagedPtr end + return () + +#if ENABLE_OVERLOADING +data GutterRendererBeginMethodInfo +instance (signature ~ (Cairo.Context.Context -> Gdk.Rectangle.Rectangle -> Gdk.Rectangle.Rectangle -> Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> m ()), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererBeginMethodInfo a signature where + overloadedMethod _ = gutterRendererBegin + +#endif + +-- method GutterRenderer::draw +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cr", argType = TInterface (Name {namespace = "cairo", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the cairo render context", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "background_area", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRectangle indicating the total area to be drawn", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cell_area", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRectangle indicating the area to draw content", 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 = "state", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRendererState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRendererState", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_renderer_draw" gtk_source_gutter_renderer_draw :: + Ptr GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}) + Ptr Cairo.Context.Context -> -- cr : TInterface (Name {namespace = "cairo", name = "Context"}) + Ptr Gdk.Rectangle.Rectangle -> -- background_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"}) + Ptr Gdk.Rectangle.Rectangle -> -- cell_area : TInterface (Name {namespace = "Gdk", name = "Rectangle"}) + Ptr Gtk.TextIter.TextIter -> -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + CUInt -> -- state : TInterface (Name {namespace = "GtkSource", name = "GutterRendererState"}) + IO () + +{- | +Main renderering method. Implementations should implement this method to draw +onto the cairo context. The /@backgroundArea@/ indicates the total area of the +cell to be drawn. The /@cellArea@/ indicates the area where content can be +drawn (text, images, etc). + +The /@backgroundArea@/ is the /@cellArea@/ plus the padding on each side (two +times the 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer':@/xpad/@ horizontally and two times the +'GI.GtkSource.Objects.GutterRenderer.GutterRenderer':@/ypad/@ vertically, so that the /@cellArea@/ is centered +inside /@backgroundArea@/). + +The /@state@/ argument indicates the current state of the renderer and should +be taken into account to properly draw the different possible states +(cursor, prelit, selected) if appropriate. +-} +gutterRendererDraw :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -} + -> Cairo.Context.Context + {- ^ /@cr@/: the cairo render context -} + -> Gdk.Rectangle.Rectangle + {- ^ /@backgroundArea@/: a 'GI.Gdk.Structs.Rectangle.Rectangle' indicating the total area to be drawn -} + -> Gdk.Rectangle.Rectangle + {- ^ /@cellArea@/: a 'GI.Gdk.Structs.Rectangle.Rectangle' indicating the area to draw content -} + -> Gtk.TextIter.TextIter + {- ^ /@start@/: a 'GI.Gtk.Structs.TextIter.TextIter' -} + -> Gtk.TextIter.TextIter + {- ^ /@end@/: a 'GI.Gtk.Structs.TextIter.TextIter' -} + -> [GtkSource.Flags.GutterRendererState] + {- ^ /@state@/: a 'GI.GtkSource.Flags.GutterRendererState' -} + -> m () +gutterRendererDraw renderer cr backgroundArea cellArea start end state = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + cr' <- unsafeManagedPtrGetPtr cr + backgroundArea' <- unsafeManagedPtrGetPtr backgroundArea + cellArea' <- unsafeManagedPtrGetPtr cellArea + start' <- unsafeManagedPtrGetPtr start + end' <- unsafeManagedPtrGetPtr end + let state' = gflagsToWord state + gtk_source_gutter_renderer_draw renderer' cr' backgroundArea' cellArea' start' end' state' + touchManagedPtr renderer + touchManagedPtr cr + touchManagedPtr backgroundArea + touchManagedPtr cellArea + touchManagedPtr start + touchManagedPtr end + return () + +#if ENABLE_OVERLOADING +data GutterRendererDrawMethodInfo +instance (signature ~ (Cairo.Context.Context -> Gdk.Rectangle.Rectangle -> Gdk.Rectangle.Rectangle -> Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> [GtkSource.Flags.GutterRendererState] -> m ()), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererDrawMethodInfo a signature where + overloadedMethod _ = gutterRendererDraw + +#endif + +-- method GutterRenderer::end +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_renderer_end" gtk_source_gutter_renderer_end :: + Ptr GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}) + IO () + +{- | +Called when drawing a region of lines has ended. +-} +gutterRendererEnd :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -} + -> m () +gutterRendererEnd renderer = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + gtk_source_gutter_renderer_end renderer' + touchManagedPtr renderer + return () + +#if ENABLE_OVERLOADING +data GutterRendererEndMethodInfo +instance (signature ~ (m ()), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererEndMethodInfo a signature where + overloadedMethod _ = gutterRendererEnd + +#endif + +-- XXX Could not generate method GutterRenderer::get_alignment +-- Error was : Not implemented: "Don't know how to allocate \"xalign\" of type TBasicType TFloat" +#if ENABLE_OVERLOADING +-- XXX: Dummy instance, since code generation failed. +-- Please file a bug at http://github.com/haskell-gi/haskell-gi. +data GutterRendererGetAlignmentMethodInfo +instance (p ~ (), o ~ O.MethodResolutionFailed "getAlignment" GutterRenderer) => O.MethodInfo GutterRendererGetAlignmentMethodInfo o p where + overloadedMethod _ = undefined +#endif + +-- method GutterRenderer::get_alignment_mode +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "GutterRendererAlignmentMode"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_renderer_get_alignment_mode" gtk_source_gutter_renderer_get_alignment_mode :: + Ptr GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}) + IO CUInt + +{- | +Get the alignment mode. The alignment mode describes the manner in which the +renderer is aligned (see :xalign and :yalign). +-} +gutterRendererGetAlignmentMode :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -} + -> m GtkSource.Enums.GutterRendererAlignmentMode + {- ^ __Returns:__ a 'GI.GtkSource.Enums.GutterRendererAlignmentMode' -} +gutterRendererGetAlignmentMode renderer = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + result <- gtk_source_gutter_renderer_get_alignment_mode renderer' + let result' = (toEnum . fromIntegral) result + touchManagedPtr renderer + return result' + +#if ENABLE_OVERLOADING +data GutterRendererGetAlignmentModeMethodInfo +instance (signature ~ (m GtkSource.Enums.GutterRendererAlignmentMode), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererGetAlignmentModeMethodInfo a signature where + overloadedMethod _ = gutterRendererGetAlignmentMode + +#endif + +-- method GutterRenderer::get_background +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return value for a #GdkRGBA", 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_gutter_renderer_get_background" gtk_source_gutter_renderer_get_background :: + Ptr GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}) + Ptr Gdk.RGBA.RGBA -> -- color : TInterface (Name {namespace = "Gdk", name = "RGBA"}) + IO CInt + +{- | +Get the background color of the renderer. +-} +gutterRendererGetBackground :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -} + -> m ((Bool, Gdk.RGBA.RGBA)) + {- ^ __Returns:__ 'True' if the background color is set, 'False' otherwise -} +gutterRendererGetBackground renderer = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + color <- callocBoxedBytes 32 :: IO (Ptr Gdk.RGBA.RGBA) + result <- gtk_source_gutter_renderer_get_background renderer' color + let result' = (/= 0) result + color' <- (wrapBoxed Gdk.RGBA.RGBA) color + touchManagedPtr renderer + return (result', color') + +#if ENABLE_OVERLOADING +data GutterRendererGetBackgroundMethodInfo +instance (signature ~ (m ((Bool, Gdk.RGBA.RGBA))), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererGetBackgroundMethodInfo a signature where + overloadedMethod _ = gutterRendererGetBackground + +#endif + +-- XXX Could not generate method GutterRenderer::get_padding +-- Error was : Not implemented: "Don't know how to allocate \"xpad\" of type TBasicType TInt" +#if ENABLE_OVERLOADING +-- XXX: Dummy instance, since code generation failed. +-- Please file a bug at http://github.com/haskell-gi/haskell-gi. +data GutterRendererGetPaddingMethodInfo +instance (p ~ (), o ~ O.MethodResolutionFailed "getPadding" GutterRenderer) => O.MethodInfo GutterRendererGetPaddingMethodInfo o p where + overloadedMethod _ = undefined +#endif + +-- method GutterRenderer::get_size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_renderer_get_size" gtk_source_gutter_renderer_get_size :: + Ptr GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}) + IO Int32 + +{- | +Get the size of the renderer. +-} +gutterRendererGetSize :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -} + -> m Int32 + {- ^ __Returns:__ the size of the renderer. -} +gutterRendererGetSize renderer = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + result <- gtk_source_gutter_renderer_get_size renderer' + touchManagedPtr renderer + return result + +#if ENABLE_OVERLOADING +data GutterRendererGetSizeMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererGetSizeMethodInfo a signature where + overloadedMethod _ = gutterRendererGetSize + +#endif + +-- method GutterRenderer::get_view +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "TextView"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_renderer_get_view" gtk_source_gutter_renderer_get_view :: + Ptr GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}) + IO (Ptr Gtk.TextView.TextView) + +{- | +Get the view associated to the gutter renderer +-} +gutterRendererGetView :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -} + -> m Gtk.TextView.TextView + {- ^ __Returns:__ a 'GI.Gtk.Objects.TextView.TextView' -} +gutterRendererGetView renderer = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + result <- gtk_source_gutter_renderer_get_view renderer' + checkUnexpectedReturnNULL "gutterRendererGetView" result + result' <- (newObject Gtk.TextView.TextView) result + touchManagedPtr renderer + return result' + +#if ENABLE_OVERLOADING +data GutterRendererGetViewMethodInfo +instance (signature ~ (m Gtk.TextView.TextView), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererGetViewMethodInfo a signature where + overloadedMethod _ = gutterRendererGetView + +#endif + +-- method GutterRenderer::get_visible +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_renderer_get_visible" gtk_source_gutter_renderer_get_visible :: + Ptr GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}) + IO CInt + +{- | +Get whether the gutter renderer is visible. +-} +gutterRendererGetVisible :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -} + -> m Bool + {- ^ __Returns:__ 'True' if the renderer is visible, 'False' otherwise -} +gutterRendererGetVisible renderer = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + result <- gtk_source_gutter_renderer_get_visible renderer' + let result' = (/= 0) result + touchManagedPtr renderer + return result' + +#if ENABLE_OVERLOADING +data GutterRendererGetVisibleMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererGetVisibleMethodInfo a signature where + overloadedMethod _ = gutterRendererGetVisible + +#endif + +-- method GutterRenderer::get_window_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "TextWindowType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_renderer_get_window_type" gtk_source_gutter_renderer_get_window_type :: + Ptr GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}) + IO CUInt + +{- | +Get the 'GI.Gtk.Enums.TextWindowType' associated with the gutter renderer. +-} +gutterRendererGetWindowType :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -} + -> m Gtk.Enums.TextWindowType + {- ^ __Returns:__ a 'GI.Gtk.Enums.TextWindowType' -} +gutterRendererGetWindowType renderer = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + result <- gtk_source_gutter_renderer_get_window_type renderer' + let result' = (toEnum . fromIntegral) result + touchManagedPtr renderer + return result' + +#if ENABLE_OVERLOADING +data GutterRendererGetWindowTypeMethodInfo +instance (signature ~ (m Gtk.Enums.TextWindowType), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererGetWindowTypeMethodInfo a signature where + overloadedMethod _ = gutterRendererGetWindowType + +#endif + +-- method GutterRenderer::query_activatable +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextIter at the start of the line to be activated", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "area", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRectangle of the cell area to be activated", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gdk", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the event that triggered the query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_renderer_query_activatable" gtk_source_gutter_renderer_query_activatable :: + Ptr GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}) + Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gdk.Rectangle.Rectangle -> -- area : TInterface (Name {namespace = "Gdk", name = "Rectangle"}) + Ptr Gdk.Event.Event -> -- event : TInterface (Name {namespace = "Gdk", name = "Event"}) + IO CInt + +{- | +Get whether the renderer is activatable at the location in /@event@/. This is +called from 'GI.GtkSource.Objects.Gutter.Gutter' to determine whether a renderer is activatable +using the mouse pointer. +-} +gutterRendererQueryActivatable :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -} + -> Gtk.TextIter.TextIter + {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter' at the start of the line to be activated -} + -> Gdk.Rectangle.Rectangle + {- ^ /@area@/: a 'GI.Gdk.Structs.Rectangle.Rectangle' of the cell area to be activated -} + -> Gdk.Event.Event + {- ^ /@event@/: the event that triggered the query -} + -> m Bool + {- ^ __Returns:__ 'True' if the renderer can be activated, 'False' otherwise -} +gutterRendererQueryActivatable renderer iter area event = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + iter' <- unsafeManagedPtrGetPtr iter + area' <- unsafeManagedPtrGetPtr area + event' <- unsafeManagedPtrGetPtr event + result <- gtk_source_gutter_renderer_query_activatable renderer' iter' area' event' + let result' = (/= 0) result + touchManagedPtr renderer + touchManagedPtr iter + touchManagedPtr area + touchManagedPtr event + return result' + +#if ENABLE_OVERLOADING +data GutterRendererQueryActivatableMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> Gdk.Rectangle.Rectangle -> Gdk.Event.Event -> m Bool), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererQueryActivatableMethodInfo a signature where + overloadedMethod _ = gutterRendererQueryActivatable + +#endif + +-- method GutterRenderer::query_data +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRenderer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},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 = "state", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRendererState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRendererState.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_renderer_query_data" gtk_source_gutter_renderer_query_data :: + Ptr GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}) + Ptr Gtk.TextIter.TextIter -> -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + CUInt -> -- state : TInterface (Name {namespace = "GtkSource", name = "GutterRendererState"}) + IO () + +{- | +Emit the 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'::@/query-data/@ signal. This function is called +to query for data just before rendering a cell. This is called from the +'GI.GtkSource.Objects.Gutter.Gutter'. Implementations can override the default signal handler or +can connect a signal handler externally to the +'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'::@/query-data/@ signal. +-} +gutterRendererQueryData :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'. -} + -> Gtk.TextIter.TextIter + {- ^ /@start@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} + -> Gtk.TextIter.TextIter + {- ^ /@end@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} + -> [GtkSource.Flags.GutterRendererState] + {- ^ /@state@/: a 'GI.GtkSource.Flags.GutterRendererState'. -} + -> m () +gutterRendererQueryData renderer start end state = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + start' <- unsafeManagedPtrGetPtr start + end' <- unsafeManagedPtrGetPtr end + let state' = gflagsToWord state + gtk_source_gutter_renderer_query_data renderer' start' end' state' + touchManagedPtr renderer + touchManagedPtr start + touchManagedPtr end + return () + +#if ENABLE_OVERLOADING +data GutterRendererQueryDataMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> [GtkSource.Flags.GutterRendererState] -> m ()), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererQueryDataMethodInfo a signature where + overloadedMethod _ = gutterRendererQueryData + +#endif + +-- method GutterRenderer::query_tooltip +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRenderer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},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 = "area", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRectangle.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The x position of the tooltip.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The y position of the tooltip.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tooltip", argType = TInterface (Name {namespace = "Gtk", name = "Tooltip"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTooltip.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_renderer_query_tooltip" gtk_source_gutter_renderer_query_tooltip :: + Ptr GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}) + Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gdk.Rectangle.Rectangle -> -- area : TInterface (Name {namespace = "Gdk", name = "Rectangle"}) + Int32 -> -- x : TBasicType TInt + Int32 -> -- y : TBasicType TInt + Ptr Gtk.Tooltip.Tooltip -> -- tooltip : TInterface (Name {namespace = "Gtk", name = "Tooltip"}) + IO CInt + +{- | +Emits the 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'::@/query-tooltip/@ signal. This function is +called from 'GI.GtkSource.Objects.Gutter.Gutter'. Implementations can override the default signal +handler or can connect to the signal externally. +-} +gutterRendererQueryTooltip :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a, Gtk.Tooltip.IsTooltip b) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'. -} + -> Gtk.TextIter.TextIter + {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -} + -> Gdk.Rectangle.Rectangle + {- ^ /@area@/: a 'GI.Gdk.Structs.Rectangle.Rectangle'. -} + -> Int32 + {- ^ /@x@/: The x position of the tooltip. -} + -> Int32 + {- ^ /@y@/: The y position of the tooltip. -} + -> b + {- ^ /@tooltip@/: a 'GI.Gtk.Objects.Tooltip.Tooltip'. -} + -> m Bool + {- ^ __Returns:__ 'True' if the tooltip has been set, 'False' otherwise -} +gutterRendererQueryTooltip renderer iter area x y tooltip = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + iter' <- unsafeManagedPtrGetPtr iter + area' <- unsafeManagedPtrGetPtr area + tooltip' <- unsafeManagedPtrCastPtr tooltip + result <- gtk_source_gutter_renderer_query_tooltip renderer' iter' area' x y tooltip' + let result' = (/= 0) result + touchManagedPtr renderer + touchManagedPtr iter + touchManagedPtr area + touchManagedPtr tooltip + return result' + +#if ENABLE_OVERLOADING +data GutterRendererQueryTooltipMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> Gdk.Rectangle.Rectangle -> Int32 -> Int32 -> b -> m Bool), MonadIO m, IsGutterRenderer a, Gtk.Tooltip.IsTooltip b) => O.MethodInfo GutterRendererQueryTooltipMethodInfo a signature where + overloadedMethod _ = gutterRendererQueryTooltip + +#endif + +-- method GutterRenderer::queue_draw +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_renderer_queue_draw" gtk_source_gutter_renderer_queue_draw :: + Ptr GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}) + IO () + +{- | +Emits the 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer'::@/queue-draw/@ signal of the renderer. Call +this from an implementation to inform that the renderer has changed such that +it needs to redraw. +-} +gutterRendererQueueDraw :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -} + -> m () +gutterRendererQueueDraw renderer = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + gtk_source_gutter_renderer_queue_draw renderer' + touchManagedPtr renderer + return () + +#if ENABLE_OVERLOADING +data GutterRendererQueueDrawMethodInfo +instance (signature ~ (m ()), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererQueueDrawMethodInfo a signature where + overloadedMethod _ = gutterRendererQueueDraw + +#endif + +-- method GutterRenderer::set_alignment +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the x-alignment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "yalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the y-alignment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_renderer_set_alignment" gtk_source_gutter_renderer_set_alignment :: + Ptr GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}) + CFloat -> -- xalign : TBasicType TFloat + CFloat -> -- yalign : TBasicType TFloat + IO () + +{- | +Set the alignment of the gutter renderer. Both /@xalign@/ and /@yalign@/ can be +-1, which means the values will not be changed (this allows changing only +one of the values). + +/@xalign@/ is the horizontal alignment. Set to 0 for a left alignment. 1 for a +right alignment. And 0.5 for centering the cells. /@yalign@/ is the vertical +alignment. Set to 0 for a top alignment. 1 for a bottom alignment. +-} +gutterRendererSetAlignment :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -} + -> Float + {- ^ /@xalign@/: the x-alignment -} + -> Float + {- ^ /@yalign@/: the y-alignment -} + -> m () +gutterRendererSetAlignment renderer xalign yalign = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + let xalign' = realToFrac xalign + let yalign' = realToFrac yalign + gtk_source_gutter_renderer_set_alignment renderer' xalign' yalign' + touchManagedPtr renderer + return () + +#if ENABLE_OVERLOADING +data GutterRendererSetAlignmentMethodInfo +instance (signature ~ (Float -> Float -> m ()), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererSetAlignmentMethodInfo a signature where + overloadedMethod _ = gutterRendererSetAlignment + +#endif + +-- method GutterRenderer::set_alignment_mode +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRendererAlignmentMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRendererAlignmentMode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_renderer_set_alignment_mode" gtk_source_gutter_renderer_set_alignment_mode :: + Ptr GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}) + CUInt -> -- mode : TInterface (Name {namespace = "GtkSource", name = "GutterRendererAlignmentMode"}) + IO () + +{- | +Set the alignment mode. The alignment mode describes the manner in which the +renderer is aligned (see :xalign and :yalign). +-} +gutterRendererSetAlignmentMode :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -} + -> GtkSource.Enums.GutterRendererAlignmentMode + {- ^ /@mode@/: a 'GI.GtkSource.Enums.GutterRendererAlignmentMode' -} + -> m () +gutterRendererSetAlignmentMode renderer mode = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + let mode' = (fromIntegral . fromEnum) mode + gtk_source_gutter_renderer_set_alignment_mode renderer' mode' + touchManagedPtr renderer + return () + +#if ENABLE_OVERLOADING +data GutterRendererSetAlignmentModeMethodInfo +instance (signature ~ (GtkSource.Enums.GutterRendererAlignmentMode -> m ()), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererSetAlignmentModeMethodInfo a signature where + overloadedMethod _ = gutterRendererSetAlignmentMode + +#endif + +-- method GutterRenderer::set_background +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GdkRGBA 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_gutter_renderer_set_background" gtk_source_gutter_renderer_set_background :: + Ptr GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}) + Ptr Gdk.RGBA.RGBA -> -- color : TInterface (Name {namespace = "Gdk", name = "RGBA"}) + IO () + +{- | +Set the background color of the renderer. If /@color@/ is set to 'Nothing', the +renderer will not have a background color. +-} +gutterRendererSetBackground :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -} + -> Maybe (Gdk.RGBA.RGBA) + {- ^ /@color@/: a 'GI.Gdk.Structs.RGBA.RGBA' or 'Nothing' -} + -> m () +gutterRendererSetBackground renderer color = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + maybeColor <- case color of + Nothing -> return nullPtr + Just jColor -> do + jColor' <- unsafeManagedPtrGetPtr jColor + return jColor' + gtk_source_gutter_renderer_set_background renderer' maybeColor + touchManagedPtr renderer + whenJust color touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data GutterRendererSetBackgroundMethodInfo +instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererSetBackgroundMethodInfo a signature where + overloadedMethod _ = gutterRendererSetBackground + +#endif + +-- method GutterRenderer::set_padding +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "xpad", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the x-padding", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ypad", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the y-padding", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_renderer_set_padding" gtk_source_gutter_renderer_set_padding :: + Ptr GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}) + Int32 -> -- xpad : TBasicType TInt + Int32 -> -- ypad : TBasicType TInt + IO () + +{- | +Set the padding of the gutter renderer. Both /@xpad@/ and /@ypad@/ can be +-1, which means the values will not be changed (this allows changing only +one of the values). + +/@xpad@/ is the left and right padding. /@ypad@/ is the top and bottom padding. +-} +gutterRendererSetPadding :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -} + -> Int32 + {- ^ /@xpad@/: the x-padding -} + -> Int32 + {- ^ /@ypad@/: the y-padding -} + -> m () +gutterRendererSetPadding renderer xpad ypad = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + gtk_source_gutter_renderer_set_padding renderer' xpad ypad + touchManagedPtr renderer + return () + +#if ENABLE_OVERLOADING +data GutterRendererSetPaddingMethodInfo +instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererSetPaddingMethodInfo a signature where + overloadedMethod _ = gutterRendererSetPadding + +#endif + +-- method GutterRenderer::set_size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the size", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_renderer_set_size" gtk_source_gutter_renderer_set_size :: + Ptr GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}) + Int32 -> -- size : TBasicType TInt + IO () + +{- | +Sets the size of the renderer. A value of -1 specifies that the size +is to be determined dynamically. +-} +gutterRendererSetSize :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -} + -> Int32 + {- ^ /@size@/: the size -} + -> m () +gutterRendererSetSize renderer size = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + gtk_source_gutter_renderer_set_size renderer' size + touchManagedPtr renderer + return () + +#if ENABLE_OVERLOADING +data GutterRendererSetSizeMethodInfo +instance (signature ~ (Int32 -> m ()), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererSetSizeMethodInfo a signature where + overloadedMethod _ = gutterRendererSetSize + +#endif + +-- method GutterRenderer::set_visible +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "visible", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the visibility", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_renderer_set_visible" gtk_source_gutter_renderer_set_visible :: + Ptr GutterRenderer -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRenderer"}) + CInt -> -- visible : TBasicType TBoolean + IO () + +{- | +Set whether the gutter renderer is visible. +-} +gutterRendererSetVisible :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRenderer a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -} + -> Bool + {- ^ /@visible@/: the visibility -} + -> m () +gutterRendererSetVisible renderer visible = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + let visible' = (fromIntegral . fromEnum) visible + gtk_source_gutter_renderer_set_visible renderer' visible' + touchManagedPtr renderer + return () + +#if ENABLE_OVERLOADING +data GutterRendererSetVisibleMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsGutterRenderer a) => O.MethodInfo GutterRendererSetVisibleMethodInfo a signature where + overloadedMethod _ = gutterRendererSetVisible + +#endif + + diff --git a/GI/GtkSource/Objects/GutterRenderer.hs-boot b/GI/GtkSource/Objects/GutterRenderer.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/GutterRenderer.hs-boot @@ -0,0 +1,143 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.GutterRenderer 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 GutterRenderer = GutterRenderer (ManagedPtr GutterRenderer) +instance GObject GutterRenderer where +class (GObject o, O.IsDescendantOf GutterRenderer o) => IsGutterRenderer o +instance (GObject o, O.IsDescendantOf GutterRenderer o) => IsGutterRenderer o +instance O.HasParentTypes GutterRenderer +#if ENABLE_OVERLOADING +data GutterRendererAlignmentModePropertyInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererBackgroundRgbaPropertyInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererBackgroundSetPropertyInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererSizePropertyInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererViewPropertyInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererVisiblePropertyInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererWindowTypePropertyInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererXalignPropertyInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererXpadPropertyInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererYalignPropertyInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererYpadPropertyInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererActivateSignalInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererQueryActivatableSignalInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererQueryDataSignalInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererQueryTooltipSignalInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererQueueDrawSignalInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererActivateMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererBeginMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererDrawMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererEndMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererGetAlignmentMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererGetAlignmentModeMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererGetBackgroundMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererGetPaddingMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererGetSizeMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererGetViewMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererGetVisibleMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererGetWindowTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererQueryActivatableMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererQueryDataMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererQueryTooltipMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererQueueDrawMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererSetAlignmentMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererSetAlignmentModeMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererSetBackgroundMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererSetPaddingMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererSetSizeMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererSetVisibleMethodInfo +#endif diff --git a/GI/GtkSource/Objects/GutterRendererPixbuf.hs b/GI/GtkSource/Objects/GutterRendererPixbuf.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/GutterRendererPixbuf.hs @@ -0,0 +1,876 @@ + + +{- | +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.GutterRendererPixbuf + ( + +-- * Exported types + GutterRendererPixbuf(..) , + IsGutterRendererPixbuf , + toGutterRendererPixbuf , + noGutterRendererPixbuf , + + + -- * Methods +-- ** getGicon #method:getGicon# + +#if ENABLE_OVERLOADING + GutterRendererPixbufGetGiconMethodInfo , +#endif + gutterRendererPixbufGetGicon , + + +-- ** getIconName #method:getIconName# + +#if ENABLE_OVERLOADING + GutterRendererPixbufGetIconNameMethodInfo, +#endif + gutterRendererPixbufGetIconName , + + +-- ** getPixbuf #method:getPixbuf# + +#if ENABLE_OVERLOADING + GutterRendererPixbufGetPixbufMethodInfo , +#endif + gutterRendererPixbufGetPixbuf , + + +-- ** getStockId #method:getStockId# + +#if ENABLE_OVERLOADING + GutterRendererPixbufGetStockIdMethodInfo, +#endif + gutterRendererPixbufGetStockId , + + +-- ** new #method:new# + + gutterRendererPixbufNew , + + +-- ** setGicon #method:setGicon# + +#if ENABLE_OVERLOADING + GutterRendererPixbufSetGiconMethodInfo , +#endif + gutterRendererPixbufSetGicon , + + +-- ** setIconName #method:setIconName# + +#if ENABLE_OVERLOADING + GutterRendererPixbufSetIconNameMethodInfo, +#endif + gutterRendererPixbufSetIconName , + + +-- ** setPixbuf #method:setPixbuf# + +#if ENABLE_OVERLOADING + GutterRendererPixbufSetPixbufMethodInfo , +#endif + gutterRendererPixbufSetPixbuf , + + +-- ** setStockId #method:setStockId# + +#if ENABLE_OVERLOADING + GutterRendererPixbufSetStockIdMethodInfo, +#endif + gutterRendererPixbufSetStockId , + + + + + -- * Properties +-- ** gicon #attr:gicon# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + GutterRendererPixbufGiconPropertyInfo , +#endif + clearGutterRendererPixbufGicon , + constructGutterRendererPixbufGicon , + getGutterRendererPixbufGicon , +#if ENABLE_OVERLOADING + gutterRendererPixbufGicon , +#endif + setGutterRendererPixbufGicon , + + +-- ** iconName #attr:iconName# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + GutterRendererPixbufIconNamePropertyInfo, +#endif + clearGutterRendererPixbufIconName , + constructGutterRendererPixbufIconName , + getGutterRendererPixbufIconName , +#if ENABLE_OVERLOADING + gutterRendererPixbufIconName , +#endif + setGutterRendererPixbufIconName , + + +-- ** pixbuf #attr:pixbuf# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + GutterRendererPixbufPixbufPropertyInfo , +#endif + clearGutterRendererPixbufPixbuf , + constructGutterRendererPixbufPixbuf , + getGutterRendererPixbufPixbuf , +#if ENABLE_OVERLOADING + gutterRendererPixbufPixbuf , +#endif + setGutterRendererPixbufPixbuf , + + +-- ** stockId #attr:stockId# +{- | The stock id. +-} +#if ENABLE_OVERLOADING + GutterRendererPixbufStockIdPropertyInfo , +#endif + clearGutterRendererPixbufStockId , + constructGutterRendererPixbufStockId , + getGutterRendererPixbufStockId , +#if ENABLE_OVERLOADING + gutterRendererPixbufStockId , +#endif + setGutterRendererPixbufStockId , + + + + + ) 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 {-# SOURCE #-} qualified GI.GtkSource.Objects.GutterRenderer as GtkSource.GutterRenderer + +-- | Memory-managed wrapper type. +newtype GutterRendererPixbuf = GutterRendererPixbuf (ManagedPtr GutterRendererPixbuf) +foreign import ccall "gtk_source_gutter_renderer_pixbuf_get_type" + c_gtk_source_gutter_renderer_pixbuf_get_type :: IO GType + +instance GObject GutterRendererPixbuf where + gobjectType = c_gtk_source_gutter_renderer_pixbuf_get_type + + +-- | Type class for types which can be safely cast to `GutterRendererPixbuf`, for instance with `toGutterRendererPixbuf`. +class (GObject o, O.IsDescendantOf GutterRendererPixbuf o) => IsGutterRendererPixbuf o +instance (GObject o, O.IsDescendantOf GutterRendererPixbuf o) => IsGutterRendererPixbuf o + +instance O.HasParentTypes GutterRendererPixbuf +type instance O.ParentTypes GutterRendererPixbuf = '[GtkSource.GutterRenderer.GutterRenderer, GObject.Object.Object] + +-- | Cast to `GutterRendererPixbuf`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toGutterRendererPixbuf :: (MonadIO m, IsGutterRendererPixbuf o) => o -> m GutterRendererPixbuf +toGutterRendererPixbuf = liftIO . unsafeCastTo GutterRendererPixbuf + +-- | A convenience alias for `Nothing` :: `Maybe` `GutterRendererPixbuf`. +noGutterRendererPixbuf :: Maybe GutterRendererPixbuf +noGutterRendererPixbuf = Nothing + +#if ENABLE_OVERLOADING +type family ResolveGutterRendererPixbufMethod (t :: Symbol) (o :: *) :: * where + ResolveGutterRendererPixbufMethod "activate" o = GtkSource.GutterRenderer.GutterRendererActivateMethodInfo + ResolveGutterRendererPixbufMethod "begin" o = GtkSource.GutterRenderer.GutterRendererBeginMethodInfo + ResolveGutterRendererPixbufMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveGutterRendererPixbufMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveGutterRendererPixbufMethod "draw" o = GtkSource.GutterRenderer.GutterRendererDrawMethodInfo + ResolveGutterRendererPixbufMethod "end" o = GtkSource.GutterRenderer.GutterRendererEndMethodInfo + ResolveGutterRendererPixbufMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveGutterRendererPixbufMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveGutterRendererPixbufMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveGutterRendererPixbufMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveGutterRendererPixbufMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveGutterRendererPixbufMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveGutterRendererPixbufMethod "queryActivatable" o = GtkSource.GutterRenderer.GutterRendererQueryActivatableMethodInfo + ResolveGutterRendererPixbufMethod "queryData" o = GtkSource.GutterRenderer.GutterRendererQueryDataMethodInfo + ResolveGutterRendererPixbufMethod "queryTooltip" o = GtkSource.GutterRenderer.GutterRendererQueryTooltipMethodInfo + ResolveGutterRendererPixbufMethod "queueDraw" o = GtkSource.GutterRenderer.GutterRendererQueueDrawMethodInfo + ResolveGutterRendererPixbufMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveGutterRendererPixbufMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveGutterRendererPixbufMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveGutterRendererPixbufMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveGutterRendererPixbufMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveGutterRendererPixbufMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveGutterRendererPixbufMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveGutterRendererPixbufMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveGutterRendererPixbufMethod "getAlignment" o = GtkSource.GutterRenderer.GutterRendererGetAlignmentMethodInfo + ResolveGutterRendererPixbufMethod "getAlignmentMode" o = GtkSource.GutterRenderer.GutterRendererGetAlignmentModeMethodInfo + ResolveGutterRendererPixbufMethod "getBackground" o = GtkSource.GutterRenderer.GutterRendererGetBackgroundMethodInfo + ResolveGutterRendererPixbufMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveGutterRendererPixbufMethod "getGicon" o = GutterRendererPixbufGetGiconMethodInfo + ResolveGutterRendererPixbufMethod "getIconName" o = GutterRendererPixbufGetIconNameMethodInfo + ResolveGutterRendererPixbufMethod "getPadding" o = GtkSource.GutterRenderer.GutterRendererGetPaddingMethodInfo + ResolveGutterRendererPixbufMethod "getPixbuf" o = GutterRendererPixbufGetPixbufMethodInfo + ResolveGutterRendererPixbufMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveGutterRendererPixbufMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveGutterRendererPixbufMethod "getSize" o = GtkSource.GutterRenderer.GutterRendererGetSizeMethodInfo + ResolveGutterRendererPixbufMethod "getStockId" o = GutterRendererPixbufGetStockIdMethodInfo + ResolveGutterRendererPixbufMethod "getView" o = GtkSource.GutterRenderer.GutterRendererGetViewMethodInfo + ResolveGutterRendererPixbufMethod "getVisible" o = GtkSource.GutterRenderer.GutterRendererGetVisibleMethodInfo + ResolveGutterRendererPixbufMethod "getWindowType" o = GtkSource.GutterRenderer.GutterRendererGetWindowTypeMethodInfo + ResolveGutterRendererPixbufMethod "setAlignment" o = GtkSource.GutterRenderer.GutterRendererSetAlignmentMethodInfo + ResolveGutterRendererPixbufMethod "setAlignmentMode" o = GtkSource.GutterRenderer.GutterRendererSetAlignmentModeMethodInfo + ResolveGutterRendererPixbufMethod "setBackground" o = GtkSource.GutterRenderer.GutterRendererSetBackgroundMethodInfo + ResolveGutterRendererPixbufMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveGutterRendererPixbufMethod "setGicon" o = GutterRendererPixbufSetGiconMethodInfo + ResolveGutterRendererPixbufMethod "setIconName" o = GutterRendererPixbufSetIconNameMethodInfo + ResolveGutterRendererPixbufMethod "setPadding" o = GtkSource.GutterRenderer.GutterRendererSetPaddingMethodInfo + ResolveGutterRendererPixbufMethod "setPixbuf" o = GutterRendererPixbufSetPixbufMethodInfo + ResolveGutterRendererPixbufMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveGutterRendererPixbufMethod "setSize" o = GtkSource.GutterRenderer.GutterRendererSetSizeMethodInfo + ResolveGutterRendererPixbufMethod "setStockId" o = GutterRendererPixbufSetStockIdMethodInfo + ResolveGutterRendererPixbufMethod "setVisible" o = GtkSource.GutterRenderer.GutterRendererSetVisibleMethodInfo + ResolveGutterRendererPixbufMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveGutterRendererPixbufMethod t GutterRendererPixbuf, O.MethodInfo info GutterRendererPixbuf p) => OL.IsLabel t (GutterRendererPixbuf -> 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 + +-- VVV Prop "gicon" + -- Type: TInterface (Name {namespace = "Gio", name = "Icon"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just True) + +{- | +Get the value of the “@gicon@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' gutterRendererPixbuf #gicon +@ +-} +getGutterRendererPixbufGicon :: (MonadIO m, IsGutterRendererPixbuf o) => o -> m Gio.Icon.Icon +getGutterRendererPixbufGicon obj = liftIO $ checkUnexpectedNothing "getGutterRendererPixbufGicon" $ B.Properties.getObjectPropertyObject obj "gicon" Gio.Icon.Icon + +{- | +Set the value of the “@gicon@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' gutterRendererPixbuf [ #gicon 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setGutterRendererPixbufGicon :: (MonadIO m, IsGutterRendererPixbuf o, Gio.Icon.IsIcon a) => o -> a -> m () +setGutterRendererPixbufGicon obj val = liftIO $ B.Properties.setObjectPropertyObject obj "gicon" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@gicon@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructGutterRendererPixbufGicon :: (IsGutterRendererPixbuf o, Gio.Icon.IsIcon a) => a -> IO (GValueConstruct o) +constructGutterRendererPixbufGicon val = B.Properties.constructObjectPropertyObject "gicon" (Just val) + +{- | +Set the value of the “@gicon@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #gicon +@ +-} +clearGutterRendererPixbufGicon :: (MonadIO m, IsGutterRendererPixbuf o) => o -> m () +clearGutterRendererPixbufGicon obj = liftIO $ B.Properties.setObjectPropertyObject obj "gicon" (Nothing :: Maybe Gio.Icon.Icon) + +#if ENABLE_OVERLOADING +data GutterRendererPixbufGiconPropertyInfo +instance AttrInfo GutterRendererPixbufGiconPropertyInfo where + type AttrAllowedOps GutterRendererPixbufGiconPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint GutterRendererPixbufGiconPropertyInfo = Gio.Icon.IsIcon + type AttrBaseTypeConstraint GutterRendererPixbufGiconPropertyInfo = IsGutterRendererPixbuf + type AttrGetType GutterRendererPixbufGiconPropertyInfo = Gio.Icon.Icon + type AttrLabel GutterRendererPixbufGiconPropertyInfo = "gicon" + type AttrOrigin GutterRendererPixbufGiconPropertyInfo = GutterRendererPixbuf + attrGet _ = getGutterRendererPixbufGicon + attrSet _ = setGutterRendererPixbufGicon + attrConstruct _ = constructGutterRendererPixbufGicon + attrClear _ = clearGutterRendererPixbufGicon +#endif + +-- VVV Prop "icon-name" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just True) + +{- | +Get the value of the “@icon-name@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' gutterRendererPixbuf #iconName +@ +-} +getGutterRendererPixbufIconName :: (MonadIO m, IsGutterRendererPixbuf o) => o -> m T.Text +getGutterRendererPixbufIconName obj = liftIO $ checkUnexpectedNothing "getGutterRendererPixbufIconName" $ B.Properties.getObjectPropertyString obj "icon-name" + +{- | +Set the value of the “@icon-name@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' gutterRendererPixbuf [ #iconName 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setGutterRendererPixbufIconName :: (MonadIO m, IsGutterRendererPixbuf o) => o -> T.Text -> m () +setGutterRendererPixbufIconName obj val = liftIO $ B.Properties.setObjectPropertyString obj "icon-name" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@icon-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructGutterRendererPixbufIconName :: (IsGutterRendererPixbuf o) => T.Text -> IO (GValueConstruct o) +constructGutterRendererPixbufIconName val = B.Properties.constructObjectPropertyString "icon-name" (Just val) + +{- | +Set the value of the “@icon-name@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #iconName +@ +-} +clearGutterRendererPixbufIconName :: (MonadIO m, IsGutterRendererPixbuf o) => o -> m () +clearGutterRendererPixbufIconName obj = liftIO $ B.Properties.setObjectPropertyString obj "icon-name" (Nothing :: Maybe T.Text) + +#if ENABLE_OVERLOADING +data GutterRendererPixbufIconNamePropertyInfo +instance AttrInfo GutterRendererPixbufIconNamePropertyInfo where + type AttrAllowedOps GutterRendererPixbufIconNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint GutterRendererPixbufIconNamePropertyInfo = (~) T.Text + type AttrBaseTypeConstraint GutterRendererPixbufIconNamePropertyInfo = IsGutterRendererPixbuf + type AttrGetType GutterRendererPixbufIconNamePropertyInfo = T.Text + type AttrLabel GutterRendererPixbufIconNamePropertyInfo = "icon-name" + type AttrOrigin GutterRendererPixbufIconNamePropertyInfo = GutterRendererPixbuf + attrGet _ = getGutterRendererPixbufIconName + attrSet _ = setGutterRendererPixbufIconName + attrConstruct _ = constructGutterRendererPixbufIconName + attrClear _ = clearGutterRendererPixbufIconName +#endif + +-- VVV Prop "pixbuf" + -- Type: TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just True) + +{- | +Get the value of the “@pixbuf@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' gutterRendererPixbuf #pixbuf +@ +-} +getGutterRendererPixbufPixbuf :: (MonadIO m, IsGutterRendererPixbuf o) => o -> m GdkPixbuf.Pixbuf.Pixbuf +getGutterRendererPixbufPixbuf obj = liftIO $ checkUnexpectedNothing "getGutterRendererPixbufPixbuf" $ B.Properties.getObjectPropertyObject obj "pixbuf" GdkPixbuf.Pixbuf.Pixbuf + +{- | +Set the value of the “@pixbuf@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' gutterRendererPixbuf [ #pixbuf 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setGutterRendererPixbufPixbuf :: (MonadIO m, IsGutterRendererPixbuf o, GdkPixbuf.Pixbuf.IsPixbuf a) => o -> a -> m () +setGutterRendererPixbufPixbuf obj val = liftIO $ B.Properties.setObjectPropertyObject obj "pixbuf" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@pixbuf@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructGutterRendererPixbufPixbuf :: (IsGutterRendererPixbuf o, GdkPixbuf.Pixbuf.IsPixbuf a) => a -> IO (GValueConstruct o) +constructGutterRendererPixbufPixbuf val = B.Properties.constructObjectPropertyObject "pixbuf" (Just val) + +{- | +Set the value of the “@pixbuf@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #pixbuf +@ +-} +clearGutterRendererPixbufPixbuf :: (MonadIO m, IsGutterRendererPixbuf o) => o -> m () +clearGutterRendererPixbufPixbuf obj = liftIO $ B.Properties.setObjectPropertyObject obj "pixbuf" (Nothing :: Maybe GdkPixbuf.Pixbuf.Pixbuf) + +#if ENABLE_OVERLOADING +data GutterRendererPixbufPixbufPropertyInfo +instance AttrInfo GutterRendererPixbufPixbufPropertyInfo where + type AttrAllowedOps GutterRendererPixbufPixbufPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint GutterRendererPixbufPixbufPropertyInfo = GdkPixbuf.Pixbuf.IsPixbuf + type AttrBaseTypeConstraint GutterRendererPixbufPixbufPropertyInfo = IsGutterRendererPixbuf + type AttrGetType GutterRendererPixbufPixbufPropertyInfo = GdkPixbuf.Pixbuf.Pixbuf + type AttrLabel GutterRendererPixbufPixbufPropertyInfo = "pixbuf" + type AttrOrigin GutterRendererPixbufPixbufPropertyInfo = GutterRendererPixbuf + attrGet _ = getGutterRendererPixbufPixbuf + attrSet _ = setGutterRendererPixbufPixbuf + attrConstruct _ = constructGutterRendererPixbufPixbuf + attrClear _ = clearGutterRendererPixbufPixbuf +#endif + +-- VVV Prop "stock-id" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just True) + +{- | +Get the value of the “@stock-id@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' gutterRendererPixbuf #stockId +@ +-} +getGutterRendererPixbufStockId :: (MonadIO m, IsGutterRendererPixbuf o) => o -> m T.Text +getGutterRendererPixbufStockId obj = liftIO $ checkUnexpectedNothing "getGutterRendererPixbufStockId" $ B.Properties.getObjectPropertyString obj "stock-id" + +{- | +Set the value of the “@stock-id@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' gutterRendererPixbuf [ #stockId 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setGutterRendererPixbufStockId :: (MonadIO m, IsGutterRendererPixbuf o) => o -> T.Text -> m () +setGutterRendererPixbufStockId obj val = liftIO $ B.Properties.setObjectPropertyString obj "stock-id" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@stock-id@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructGutterRendererPixbufStockId :: (IsGutterRendererPixbuf o) => T.Text -> IO (GValueConstruct o) +constructGutterRendererPixbufStockId val = B.Properties.constructObjectPropertyString "stock-id" (Just val) + +{- | +Set the value of the “@stock-id@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #stockId +@ +-} +clearGutterRendererPixbufStockId :: (MonadIO m, IsGutterRendererPixbuf o) => o -> m () +clearGutterRendererPixbufStockId obj = liftIO $ B.Properties.setObjectPropertyString obj "stock-id" (Nothing :: Maybe T.Text) + +#if ENABLE_OVERLOADING +data GutterRendererPixbufStockIdPropertyInfo +instance AttrInfo GutterRendererPixbufStockIdPropertyInfo where + type AttrAllowedOps GutterRendererPixbufStockIdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint GutterRendererPixbufStockIdPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint GutterRendererPixbufStockIdPropertyInfo = IsGutterRendererPixbuf + type AttrGetType GutterRendererPixbufStockIdPropertyInfo = T.Text + type AttrLabel GutterRendererPixbufStockIdPropertyInfo = "stock-id" + type AttrOrigin GutterRendererPixbufStockIdPropertyInfo = GutterRendererPixbuf + attrGet _ = getGutterRendererPixbufStockId + attrSet _ = setGutterRendererPixbufStockId + attrConstruct _ = constructGutterRendererPixbufStockId + attrClear _ = clearGutterRendererPixbufStockId +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList GutterRendererPixbuf +type instance O.AttributeList GutterRendererPixbuf = GutterRendererPixbufAttributeList +type GutterRendererPixbufAttributeList = ('[ '("alignmentMode", GtkSource.GutterRenderer.GutterRendererAlignmentModePropertyInfo), '("backgroundRgba", GtkSource.GutterRenderer.GutterRendererBackgroundRgbaPropertyInfo), '("backgroundSet", GtkSource.GutterRenderer.GutterRendererBackgroundSetPropertyInfo), '("gicon", GutterRendererPixbufGiconPropertyInfo), '("iconName", GutterRendererPixbufIconNamePropertyInfo), '("pixbuf", GutterRendererPixbufPixbufPropertyInfo), '("size", GtkSource.GutterRenderer.GutterRendererSizePropertyInfo), '("stockId", GutterRendererPixbufStockIdPropertyInfo), '("view", GtkSource.GutterRenderer.GutterRendererViewPropertyInfo), '("visible", GtkSource.GutterRenderer.GutterRendererVisiblePropertyInfo), '("windowType", GtkSource.GutterRenderer.GutterRendererWindowTypePropertyInfo), '("xalign", GtkSource.GutterRenderer.GutterRendererXalignPropertyInfo), '("xpad", GtkSource.GutterRenderer.GutterRendererXpadPropertyInfo), '("yalign", GtkSource.GutterRenderer.GutterRendererYalignPropertyInfo), '("ypad", GtkSource.GutterRenderer.GutterRendererYpadPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +gutterRendererPixbufGicon :: AttrLabelProxy "gicon" +gutterRendererPixbufGicon = AttrLabelProxy + +gutterRendererPixbufIconName :: AttrLabelProxy "iconName" +gutterRendererPixbufIconName = AttrLabelProxy + +gutterRendererPixbufPixbuf :: AttrLabelProxy "pixbuf" +gutterRendererPixbufPixbuf = AttrLabelProxy + +gutterRendererPixbufStockId :: AttrLabelProxy "stockId" +gutterRendererPixbufStockId = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList GutterRendererPixbuf = GutterRendererPixbufSignalList +type GutterRendererPixbufSignalList = ('[ '("activate", GtkSource.GutterRenderer.GutterRendererActivateSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("queryActivatable", GtkSource.GutterRenderer.GutterRendererQueryActivatableSignalInfo), '("queryData", GtkSource.GutterRenderer.GutterRendererQueryDataSignalInfo), '("queryTooltip", GtkSource.GutterRenderer.GutterRendererQueryTooltipSignalInfo), '("queueDraw", GtkSource.GutterRenderer.GutterRendererQueueDrawSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method GutterRendererPixbuf::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "GutterRendererPixbuf"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_renderer_pixbuf_new" gtk_source_gutter_renderer_pixbuf_new :: + IO (Ptr GutterRendererPixbuf) + +{- | +Create a new 'GI.GtkSource.Objects.GutterRendererPixbuf.GutterRendererPixbuf'. +-} +gutterRendererPixbufNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m GutterRendererPixbuf + {- ^ __Returns:__ A 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -} +gutterRendererPixbufNew = liftIO $ do + result <- gtk_source_gutter_renderer_pixbuf_new + checkUnexpectedReturnNULL "gutterRendererPixbufNew" result + result' <- (wrapObject GutterRendererPixbuf) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method GutterRendererPixbuf::get_gicon +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRendererPixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRendererPixbuf", 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_gutter_renderer_pixbuf_get_gicon" gtk_source_gutter_renderer_pixbuf_get_gicon :: + Ptr GutterRendererPixbuf -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRendererPixbuf"}) + IO (Ptr Gio.Icon.Icon) + +{- | +Get the gicon of the renderer +-} +gutterRendererPixbufGetGicon :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRendererPixbuf a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRendererPixbuf.GutterRendererPixbuf' -} + -> m Gio.Icon.Icon + {- ^ __Returns:__ a 'GI.Gio.Interfaces.Icon.Icon' -} +gutterRendererPixbufGetGicon renderer = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + result <- gtk_source_gutter_renderer_pixbuf_get_gicon renderer' + checkUnexpectedReturnNULL "gutterRendererPixbufGetGicon" result + result' <- (newObject Gio.Icon.Icon) result + touchManagedPtr renderer + return result' + +#if ENABLE_OVERLOADING +data GutterRendererPixbufGetGiconMethodInfo +instance (signature ~ (m Gio.Icon.Icon), MonadIO m, IsGutterRendererPixbuf a) => O.MethodInfo GutterRendererPixbufGetGiconMethodInfo a signature where + overloadedMethod _ = gutterRendererPixbufGetGicon + +#endif + +-- method GutterRendererPixbuf::get_icon_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRendererPixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, 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_gutter_renderer_pixbuf_get_icon_name" gtk_source_gutter_renderer_pixbuf_get_icon_name :: + Ptr GutterRendererPixbuf -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRendererPixbuf"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +gutterRendererPixbufGetIconName :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRendererPixbuf a) => + a + -> m T.Text +gutterRendererPixbufGetIconName renderer = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + result <- gtk_source_gutter_renderer_pixbuf_get_icon_name renderer' + checkUnexpectedReturnNULL "gutterRendererPixbufGetIconName" result + result' <- cstringToText result + touchManagedPtr renderer + return result' + +#if ENABLE_OVERLOADING +data GutterRendererPixbufGetIconNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsGutterRendererPixbuf a) => O.MethodInfo GutterRendererPixbufGetIconNameMethodInfo a signature where + overloadedMethod _ = gutterRendererPixbufGetIconName + +#endif + +-- method GutterRendererPixbuf::get_pixbuf +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRendererPixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRendererPixbuf", 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_gutter_renderer_pixbuf_get_pixbuf" gtk_source_gutter_renderer_pixbuf_get_pixbuf :: + Ptr GutterRendererPixbuf -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRendererPixbuf"}) + IO (Ptr GdkPixbuf.Pixbuf.Pixbuf) + +{- | +Get the pixbuf of the renderer. +-} +gutterRendererPixbufGetPixbuf :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRendererPixbuf a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRendererPixbuf.GutterRendererPixbuf' -} + -> m GdkPixbuf.Pixbuf.Pixbuf + {- ^ __Returns:__ a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' -} +gutterRendererPixbufGetPixbuf renderer = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + result <- gtk_source_gutter_renderer_pixbuf_get_pixbuf renderer' + checkUnexpectedReturnNULL "gutterRendererPixbufGetPixbuf" result + result' <- (newObject GdkPixbuf.Pixbuf.Pixbuf) result + touchManagedPtr renderer + return result' + +#if ENABLE_OVERLOADING +data GutterRendererPixbufGetPixbufMethodInfo +instance (signature ~ (m GdkPixbuf.Pixbuf.Pixbuf), MonadIO m, IsGutterRendererPixbuf a) => O.MethodInfo GutterRendererPixbufGetPixbufMethodInfo a signature where + overloadedMethod _ = gutterRendererPixbufGetPixbuf + +#endif + +-- method GutterRendererPixbuf::get_stock_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRendererPixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRendererPixbuf", 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_gutter_renderer_pixbuf_get_stock_id" gtk_source_gutter_renderer_pixbuf_get_stock_id :: + Ptr GutterRendererPixbuf -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRendererPixbuf"}) + IO CString + +{-# DEPRECATED gutterRendererPixbufGetStockId ["(Since version 3.10)","Don\\'t use this function."] #-} +{- | +/No description available in the introspection data./ +-} +gutterRendererPixbufGetStockId :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRendererPixbuf a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRendererPixbuf.GutterRendererPixbuf' -} + -> m T.Text + {- ^ __Returns:__ the stock id. -} +gutterRendererPixbufGetStockId renderer = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + result <- gtk_source_gutter_renderer_pixbuf_get_stock_id renderer' + checkUnexpectedReturnNULL "gutterRendererPixbufGetStockId" result + result' <- cstringToText result + touchManagedPtr renderer + return result' + +#if ENABLE_OVERLOADING +data GutterRendererPixbufGetStockIdMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsGutterRendererPixbuf a) => O.MethodInfo GutterRendererPixbufGetStockIdMethodInfo a signature where + overloadedMethod _ = gutterRendererPixbufGetStockId + +#endif + +-- method GutterRendererPixbuf::set_gicon +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRendererPixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRendererPixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "icon", argType = TInterface (Name {namespace = "Gio", name = "Icon"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the icon, 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_gutter_renderer_pixbuf_set_gicon" gtk_source_gutter_renderer_pixbuf_set_gicon :: + Ptr GutterRendererPixbuf -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRendererPixbuf"}) + Ptr Gio.Icon.Icon -> -- icon : TInterface (Name {namespace = "Gio", name = "Icon"}) + IO () + +{- | +/No description available in the introspection data./ +-} +gutterRendererPixbufSetGicon :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRendererPixbuf a, Gio.Icon.IsIcon b) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRendererPixbuf.GutterRendererPixbuf' -} + -> Maybe (b) + {- ^ /@icon@/: the icon, or 'Nothing'. -} + -> m () +gutterRendererPixbufSetGicon renderer icon = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + maybeIcon <- case icon of + Nothing -> return nullPtr + Just jIcon -> do + jIcon' <- unsafeManagedPtrCastPtr jIcon + return jIcon' + gtk_source_gutter_renderer_pixbuf_set_gicon renderer' maybeIcon + touchManagedPtr renderer + whenJust icon touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data GutterRendererPixbufSetGiconMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsGutterRendererPixbuf a, Gio.Icon.IsIcon b) => O.MethodInfo GutterRendererPixbufSetGiconMethodInfo a signature where + overloadedMethod _ = gutterRendererPixbufSetGicon + +#endif + +-- method GutterRendererPixbuf::set_icon_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRendererPixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRendererPixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "icon_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the icon name, 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_gutter_renderer_pixbuf_set_icon_name" gtk_source_gutter_renderer_pixbuf_set_icon_name :: + Ptr GutterRendererPixbuf -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRendererPixbuf"}) + CString -> -- icon_name : TBasicType TUTF8 + IO () + +{- | +/No description available in the introspection data./ +-} +gutterRendererPixbufSetIconName :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRendererPixbuf a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRendererPixbuf.GutterRendererPixbuf' -} + -> Maybe (T.Text) + {- ^ /@iconName@/: the icon name, or 'Nothing'. -} + -> m () +gutterRendererPixbufSetIconName renderer iconName = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + maybeIconName <- case iconName of + Nothing -> return nullPtr + Just jIconName -> do + jIconName' <- textToCString jIconName + return jIconName' + gtk_source_gutter_renderer_pixbuf_set_icon_name renderer' maybeIconName + touchManagedPtr renderer + freeMem maybeIconName + return () + +#if ENABLE_OVERLOADING +data GutterRendererPixbufSetIconNameMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsGutterRendererPixbuf a) => O.MethodInfo GutterRendererPixbufSetIconNameMethodInfo a signature where + overloadedMethod _ = gutterRendererPixbufSetIconName + +#endif + +-- method GutterRendererPixbuf::set_pixbuf +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRendererPixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRendererPixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the pixbuf, 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_gutter_renderer_pixbuf_set_pixbuf" gtk_source_gutter_renderer_pixbuf_set_pixbuf :: + Ptr GutterRendererPixbuf -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRendererPixbuf"}) + Ptr GdkPixbuf.Pixbuf.Pixbuf -> -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}) + IO () + +{- | +/No description available in the introspection data./ +-} +gutterRendererPixbufSetPixbuf :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRendererPixbuf a, GdkPixbuf.Pixbuf.IsPixbuf b) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRendererPixbuf.GutterRendererPixbuf' -} + -> Maybe (b) + {- ^ /@pixbuf@/: the pixbuf, or 'Nothing'. -} + -> m () +gutterRendererPixbufSetPixbuf renderer pixbuf = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + maybePixbuf <- case pixbuf of + Nothing -> return nullPtr + Just jPixbuf -> do + jPixbuf' <- unsafeManagedPtrCastPtr jPixbuf + return jPixbuf' + gtk_source_gutter_renderer_pixbuf_set_pixbuf renderer' maybePixbuf + touchManagedPtr renderer + whenJust pixbuf touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data GutterRendererPixbufSetPixbufMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsGutterRendererPixbuf a, GdkPixbuf.Pixbuf.IsPixbuf b) => O.MethodInfo GutterRendererPixbufSetPixbufMethodInfo a signature where + overloadedMethod _ = gutterRendererPixbufSetPixbuf + +#endif + +-- method GutterRendererPixbuf::set_stock_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRendererPixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRendererPixbuf", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the stock id", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_renderer_pixbuf_set_stock_id" gtk_source_gutter_renderer_pixbuf_set_stock_id :: + Ptr GutterRendererPixbuf -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRendererPixbuf"}) + CString -> -- stock_id : TBasicType TUTF8 + IO () + +{-# DEPRECATED gutterRendererPixbufSetStockId ["(Since version 3.10)","Don\\'t use this function."] #-} +{- | +/No description available in the introspection data./ +-} +gutterRendererPixbufSetStockId :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRendererPixbuf a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRendererPixbuf.GutterRendererPixbuf' -} + -> Maybe (T.Text) + {- ^ /@stockId@/: the stock id -} + -> m () +gutterRendererPixbufSetStockId renderer stockId = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + maybeStockId <- case stockId of + Nothing -> return nullPtr + Just jStockId -> do + jStockId' <- textToCString jStockId + return jStockId' + gtk_source_gutter_renderer_pixbuf_set_stock_id renderer' maybeStockId + touchManagedPtr renderer + freeMem maybeStockId + return () + +#if ENABLE_OVERLOADING +data GutterRendererPixbufSetStockIdMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsGutterRendererPixbuf a) => O.MethodInfo GutterRendererPixbufSetStockIdMethodInfo a signature where + overloadedMethod _ = gutterRendererPixbufSetStockId + +#endif + + diff --git a/GI/GtkSource/Objects/GutterRendererPixbuf.hs-boot b/GI/GtkSource/Objects/GutterRendererPixbuf.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/GutterRendererPixbuf.hs-boot @@ -0,0 +1,65 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.GutterRendererPixbuf 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 GutterRendererPixbuf = GutterRendererPixbuf (ManagedPtr GutterRendererPixbuf) +instance GObject GutterRendererPixbuf where +class (GObject o, O.IsDescendantOf GutterRendererPixbuf o) => IsGutterRendererPixbuf o +instance (GObject o, O.IsDescendantOf GutterRendererPixbuf o) => IsGutterRendererPixbuf o +instance O.HasParentTypes GutterRendererPixbuf +#if ENABLE_OVERLOADING +data GutterRendererPixbufGiconPropertyInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererPixbufIconNamePropertyInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererPixbufPixbufPropertyInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererPixbufStockIdPropertyInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererPixbufGetGiconMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererPixbufGetIconNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererPixbufGetPixbufMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererPixbufGetStockIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererPixbufSetGiconMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererPixbufSetIconNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererPixbufSetPixbufMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererPixbufSetStockIdMethodInfo +#endif diff --git a/GI/GtkSource/Objects/GutterRendererText.hs b/GI/GtkSource/Objects/GutterRendererText.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/GutterRendererText.hs @@ -0,0 +1,542 @@ + + +{- | +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.GutterRendererText + ( + +-- * Exported types + GutterRendererText(..) , + IsGutterRendererText , + toGutterRendererText , + noGutterRendererText , + + + -- * Methods +-- ** measure #method:measure# + +#if ENABLE_OVERLOADING + GutterRendererTextMeasureMethodInfo , +#endif + gutterRendererTextMeasure , + + +-- ** measureMarkup #method:measureMarkup# + +#if ENABLE_OVERLOADING + GutterRendererTextMeasureMarkupMethodInfo, +#endif + gutterRendererTextMeasureMarkup , + + +-- ** new #method:new# + + gutterRendererTextNew , + + +-- ** setMarkup #method:setMarkup# + +#if ENABLE_OVERLOADING + GutterRendererTextSetMarkupMethodInfo , +#endif + gutterRendererTextSetMarkup , + + +-- ** setText #method:setText# + +#if ENABLE_OVERLOADING + GutterRendererTextSetTextMethodInfo , +#endif + gutterRendererTextSetText , + + + + + -- * Properties +-- ** markup #attr:markup# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + GutterRendererTextMarkupPropertyInfo , +#endif + clearGutterRendererTextMarkup , + constructGutterRendererTextMarkup , + getGutterRendererTextMarkup , +#if ENABLE_OVERLOADING + gutterRendererTextMarkup , +#endif + setGutterRendererTextMarkup , + + +-- ** text #attr:text# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + GutterRendererTextTextPropertyInfo , +#endif + clearGutterRendererTextText , + constructGutterRendererTextText , + getGutterRendererTextText , +#if ENABLE_OVERLOADING + gutterRendererTextText , +#endif + setGutterRendererTextText , + + + + + ) 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.GutterRenderer as GtkSource.GutterRenderer + +-- | Memory-managed wrapper type. +newtype GutterRendererText = GutterRendererText (ManagedPtr GutterRendererText) +foreign import ccall "gtk_source_gutter_renderer_text_get_type" + c_gtk_source_gutter_renderer_text_get_type :: IO GType + +instance GObject GutterRendererText where + gobjectType = c_gtk_source_gutter_renderer_text_get_type + + +-- | Type class for types which can be safely cast to `GutterRendererText`, for instance with `toGutterRendererText`. +class (GObject o, O.IsDescendantOf GutterRendererText o) => IsGutterRendererText o +instance (GObject o, O.IsDescendantOf GutterRendererText o) => IsGutterRendererText o + +instance O.HasParentTypes GutterRendererText +type instance O.ParentTypes GutterRendererText = '[GtkSource.GutterRenderer.GutterRenderer, GObject.Object.Object] + +-- | Cast to `GutterRendererText`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toGutterRendererText :: (MonadIO m, IsGutterRendererText o) => o -> m GutterRendererText +toGutterRendererText = liftIO . unsafeCastTo GutterRendererText + +-- | A convenience alias for `Nothing` :: `Maybe` `GutterRendererText`. +noGutterRendererText :: Maybe GutterRendererText +noGutterRendererText = Nothing + +#if ENABLE_OVERLOADING +type family ResolveGutterRendererTextMethod (t :: Symbol) (o :: *) :: * where + ResolveGutterRendererTextMethod "activate" o = GtkSource.GutterRenderer.GutterRendererActivateMethodInfo + ResolveGutterRendererTextMethod "begin" o = GtkSource.GutterRenderer.GutterRendererBeginMethodInfo + ResolveGutterRendererTextMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveGutterRendererTextMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveGutterRendererTextMethod "draw" o = GtkSource.GutterRenderer.GutterRendererDrawMethodInfo + ResolveGutterRendererTextMethod "end" o = GtkSource.GutterRenderer.GutterRendererEndMethodInfo + ResolveGutterRendererTextMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveGutterRendererTextMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveGutterRendererTextMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveGutterRendererTextMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveGutterRendererTextMethod "measure" o = GutterRendererTextMeasureMethodInfo + ResolveGutterRendererTextMethod "measureMarkup" o = GutterRendererTextMeasureMarkupMethodInfo + ResolveGutterRendererTextMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveGutterRendererTextMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveGutterRendererTextMethod "queryActivatable" o = GtkSource.GutterRenderer.GutterRendererQueryActivatableMethodInfo + ResolveGutterRendererTextMethod "queryData" o = GtkSource.GutterRenderer.GutterRendererQueryDataMethodInfo + ResolveGutterRendererTextMethod "queryTooltip" o = GtkSource.GutterRenderer.GutterRendererQueryTooltipMethodInfo + ResolveGutterRendererTextMethod "queueDraw" o = GtkSource.GutterRenderer.GutterRendererQueueDrawMethodInfo + ResolveGutterRendererTextMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveGutterRendererTextMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveGutterRendererTextMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveGutterRendererTextMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveGutterRendererTextMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveGutterRendererTextMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveGutterRendererTextMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveGutterRendererTextMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveGutterRendererTextMethod "getAlignment" o = GtkSource.GutterRenderer.GutterRendererGetAlignmentMethodInfo + ResolveGutterRendererTextMethod "getAlignmentMode" o = GtkSource.GutterRenderer.GutterRendererGetAlignmentModeMethodInfo + ResolveGutterRendererTextMethod "getBackground" o = GtkSource.GutterRenderer.GutterRendererGetBackgroundMethodInfo + ResolveGutterRendererTextMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveGutterRendererTextMethod "getPadding" o = GtkSource.GutterRenderer.GutterRendererGetPaddingMethodInfo + ResolveGutterRendererTextMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveGutterRendererTextMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveGutterRendererTextMethod "getSize" o = GtkSource.GutterRenderer.GutterRendererGetSizeMethodInfo + ResolveGutterRendererTextMethod "getView" o = GtkSource.GutterRenderer.GutterRendererGetViewMethodInfo + ResolveGutterRendererTextMethod "getVisible" o = GtkSource.GutterRenderer.GutterRendererGetVisibleMethodInfo + ResolveGutterRendererTextMethod "getWindowType" o = GtkSource.GutterRenderer.GutterRendererGetWindowTypeMethodInfo + ResolveGutterRendererTextMethod "setAlignment" o = GtkSource.GutterRenderer.GutterRendererSetAlignmentMethodInfo + ResolveGutterRendererTextMethod "setAlignmentMode" o = GtkSource.GutterRenderer.GutterRendererSetAlignmentModeMethodInfo + ResolveGutterRendererTextMethod "setBackground" o = GtkSource.GutterRenderer.GutterRendererSetBackgroundMethodInfo + ResolveGutterRendererTextMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveGutterRendererTextMethod "setMarkup" o = GutterRendererTextSetMarkupMethodInfo + ResolveGutterRendererTextMethod "setPadding" o = GtkSource.GutterRenderer.GutterRendererSetPaddingMethodInfo + ResolveGutterRendererTextMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveGutterRendererTextMethod "setSize" o = GtkSource.GutterRenderer.GutterRendererSetSizeMethodInfo + ResolveGutterRendererTextMethod "setText" o = GutterRendererTextSetTextMethodInfo + ResolveGutterRendererTextMethod "setVisible" o = GtkSource.GutterRenderer.GutterRendererSetVisibleMethodInfo + ResolveGutterRendererTextMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveGutterRendererTextMethod t GutterRendererText, O.MethodInfo info GutterRendererText p) => OL.IsLabel t (GutterRendererText -> 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 + +-- VVV Prop "markup" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@markup@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' gutterRendererText #markup +@ +-} +getGutterRendererTextMarkup :: (MonadIO m, IsGutterRendererText o) => o -> m (Maybe T.Text) +getGutterRendererTextMarkup obj = liftIO $ B.Properties.getObjectPropertyString obj "markup" + +{- | +Set the value of the “@markup@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' gutterRendererText [ #markup 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setGutterRendererTextMarkup :: (MonadIO m, IsGutterRendererText o) => o -> T.Text -> m () +setGutterRendererTextMarkup obj val = liftIO $ B.Properties.setObjectPropertyString obj "markup" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@markup@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructGutterRendererTextMarkup :: (IsGutterRendererText o) => T.Text -> IO (GValueConstruct o) +constructGutterRendererTextMarkup val = B.Properties.constructObjectPropertyString "markup" (Just val) + +{- | +Set the value of the “@markup@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #markup +@ +-} +clearGutterRendererTextMarkup :: (MonadIO m, IsGutterRendererText o) => o -> m () +clearGutterRendererTextMarkup obj = liftIO $ B.Properties.setObjectPropertyString obj "markup" (Nothing :: Maybe T.Text) + +#if ENABLE_OVERLOADING +data GutterRendererTextMarkupPropertyInfo +instance AttrInfo GutterRendererTextMarkupPropertyInfo where + type AttrAllowedOps GutterRendererTextMarkupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint GutterRendererTextMarkupPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint GutterRendererTextMarkupPropertyInfo = IsGutterRendererText + type AttrGetType GutterRendererTextMarkupPropertyInfo = (Maybe T.Text) + type AttrLabel GutterRendererTextMarkupPropertyInfo = "markup" + type AttrOrigin GutterRendererTextMarkupPropertyInfo = GutterRendererText + attrGet _ = getGutterRendererTextMarkup + attrSet _ = setGutterRendererTextMarkup + attrConstruct _ = constructGutterRendererTextMarkup + attrClear _ = clearGutterRendererTextMarkup +#endif + +-- VVV Prop "text" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@text@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' gutterRendererText #text +@ +-} +getGutterRendererTextText :: (MonadIO m, IsGutterRendererText o) => o -> m (Maybe T.Text) +getGutterRendererTextText obj = liftIO $ B.Properties.getObjectPropertyString obj "text" + +{- | +Set the value of the “@text@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' gutterRendererText [ #text 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setGutterRendererTextText :: (MonadIO m, IsGutterRendererText o) => o -> T.Text -> m () +setGutterRendererTextText obj val = liftIO $ B.Properties.setObjectPropertyString obj "text" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@text@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructGutterRendererTextText :: (IsGutterRendererText o) => T.Text -> IO (GValueConstruct o) +constructGutterRendererTextText val = B.Properties.constructObjectPropertyString "text" (Just val) + +{- | +Set the value of the “@text@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #text +@ +-} +clearGutterRendererTextText :: (MonadIO m, IsGutterRendererText o) => o -> m () +clearGutterRendererTextText obj = liftIO $ B.Properties.setObjectPropertyString obj "text" (Nothing :: Maybe T.Text) + +#if ENABLE_OVERLOADING +data GutterRendererTextTextPropertyInfo +instance AttrInfo GutterRendererTextTextPropertyInfo where + type AttrAllowedOps GutterRendererTextTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint GutterRendererTextTextPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint GutterRendererTextTextPropertyInfo = IsGutterRendererText + type AttrGetType GutterRendererTextTextPropertyInfo = (Maybe T.Text) + type AttrLabel GutterRendererTextTextPropertyInfo = "text" + type AttrOrigin GutterRendererTextTextPropertyInfo = GutterRendererText + attrGet _ = getGutterRendererTextText + attrSet _ = setGutterRendererTextText + attrConstruct _ = constructGutterRendererTextText + attrClear _ = clearGutterRendererTextText +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList GutterRendererText +type instance O.AttributeList GutterRendererText = GutterRendererTextAttributeList +type GutterRendererTextAttributeList = ('[ '("alignmentMode", GtkSource.GutterRenderer.GutterRendererAlignmentModePropertyInfo), '("backgroundRgba", GtkSource.GutterRenderer.GutterRendererBackgroundRgbaPropertyInfo), '("backgroundSet", GtkSource.GutterRenderer.GutterRendererBackgroundSetPropertyInfo), '("markup", GutterRendererTextMarkupPropertyInfo), '("size", GtkSource.GutterRenderer.GutterRendererSizePropertyInfo), '("text", GutterRendererTextTextPropertyInfo), '("view", GtkSource.GutterRenderer.GutterRendererViewPropertyInfo), '("visible", GtkSource.GutterRenderer.GutterRendererVisiblePropertyInfo), '("windowType", GtkSource.GutterRenderer.GutterRendererWindowTypePropertyInfo), '("xalign", GtkSource.GutterRenderer.GutterRendererXalignPropertyInfo), '("xpad", GtkSource.GutterRenderer.GutterRendererXpadPropertyInfo), '("yalign", GtkSource.GutterRenderer.GutterRendererYalignPropertyInfo), '("ypad", GtkSource.GutterRenderer.GutterRendererYpadPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +gutterRendererTextMarkup :: AttrLabelProxy "markup" +gutterRendererTextMarkup = AttrLabelProxy + +gutterRendererTextText :: AttrLabelProxy "text" +gutterRendererTextText = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList GutterRendererText = GutterRendererTextSignalList +type GutterRendererTextSignalList = ('[ '("activate", GtkSource.GutterRenderer.GutterRendererActivateSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("queryActivatable", GtkSource.GutterRenderer.GutterRendererQueryActivatableSignalInfo), '("queryData", GtkSource.GutterRenderer.GutterRendererQueryDataSignalInfo), '("queryTooltip", GtkSource.GutterRenderer.GutterRendererQueryTooltipSignalInfo), '("queueDraw", GtkSource.GutterRenderer.GutterRendererQueueDrawSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method GutterRendererText::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "GutterRendererText"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_renderer_text_new" gtk_source_gutter_renderer_text_new :: + IO (Ptr GutterRendererText) + +{- | +Create a new 'GI.GtkSource.Objects.GutterRendererText.GutterRendererText'. +-} +gutterRendererTextNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m GutterRendererText + {- ^ __Returns:__ A 'GI.GtkSource.Objects.GutterRenderer.GutterRenderer' -} +gutterRendererTextNew = liftIO $ do + result <- gtk_source_gutter_renderer_text_new + checkUnexpectedReturnNULL "gutterRendererTextNew" result + result' <- (wrapObject GutterRendererText) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method GutterRendererText::measure +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRendererText"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRendererText.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the text to measure.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the width of the text in pixels,\n or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the height of the text in\n pixels, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_renderer_text_measure" gtk_source_gutter_renderer_text_measure :: + Ptr GutterRendererText -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRendererText"}) + CString -> -- text : TBasicType TUTF8 + Ptr Int32 -> -- width : TBasicType TInt + Ptr Int32 -> -- height : TBasicType TInt + IO () + +{- | +Measures the text provided using the pango layout used by the +'GI.GtkSource.Objects.GutterRendererText.GutterRendererText'. +-} +gutterRendererTextMeasure :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRendererText a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRendererText.GutterRendererText'. -} + -> T.Text + {- ^ /@text@/: the text to measure. -} + -> m ((Int32, Int32)) +gutterRendererTextMeasure renderer text = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + text' <- textToCString text + width <- allocMem :: IO (Ptr Int32) + height <- allocMem :: IO (Ptr Int32) + gtk_source_gutter_renderer_text_measure renderer' text' width height + width' <- peek width + height' <- peek height + touchManagedPtr renderer + freeMem text' + freeMem width + freeMem height + return (width', height') + +#if ENABLE_OVERLOADING +data GutterRendererTextMeasureMethodInfo +instance (signature ~ (T.Text -> m ((Int32, Int32))), MonadIO m, IsGutterRendererText a) => O.MethodInfo GutterRendererTextMeasureMethodInfo a signature where + overloadedMethod _ = gutterRendererTextMeasure + +#endif + +-- method GutterRendererText::measure_markup +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRendererText"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceGutterRendererText.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "markup", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the pango markup to measure.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the width of the text in pixels,\n or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the height of the text in\n pixels, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_renderer_text_measure_markup" gtk_source_gutter_renderer_text_measure_markup :: + Ptr GutterRendererText -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRendererText"}) + CString -> -- markup : TBasicType TUTF8 + Ptr Int32 -> -- width : TBasicType TInt + Ptr Int32 -> -- height : TBasicType TInt + IO () + +{- | +Measures the pango markup provided using the pango layout used by the +'GI.GtkSource.Objects.GutterRendererText.GutterRendererText'. +-} +gutterRendererTextMeasureMarkup :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRendererText a) => + a + {- ^ /@renderer@/: a 'GI.GtkSource.Objects.GutterRendererText.GutterRendererText'. -} + -> T.Text + {- ^ /@markup@/: the pango markup to measure. -} + -> m ((Int32, Int32)) +gutterRendererTextMeasureMarkup renderer markup = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + markup' <- textToCString markup + width <- allocMem :: IO (Ptr Int32) + height <- allocMem :: IO (Ptr Int32) + gtk_source_gutter_renderer_text_measure_markup renderer' markup' width height + width' <- peek width + height' <- peek height + touchManagedPtr renderer + freeMem markup' + freeMem width + freeMem height + return (width', height') + +#if ENABLE_OVERLOADING +data GutterRendererTextMeasureMarkupMethodInfo +instance (signature ~ (T.Text -> m ((Int32, Int32))), MonadIO m, IsGutterRendererText a) => O.MethodInfo GutterRendererTextMeasureMarkupMethodInfo a signature where + overloadedMethod _ = gutterRendererTextMeasureMarkup + +#endif + +-- method GutterRendererText::set_markup +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRendererText"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "markup", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_renderer_text_set_markup" gtk_source_gutter_renderer_text_set_markup :: + Ptr GutterRendererText -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRendererText"}) + CString -> -- markup : TBasicType TUTF8 + Int32 -> -- length : TBasicType TInt + IO () + +{- | +/No description available in the introspection data./ +-} +gutterRendererTextSetMarkup :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRendererText a) => + a + -> T.Text + -> Int32 + -> m () +gutterRendererTextSetMarkup renderer markup length_ = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + markup' <- textToCString markup + gtk_source_gutter_renderer_text_set_markup renderer' markup' length_ + touchManagedPtr renderer + freeMem markup' + return () + +#if ENABLE_OVERLOADING +data GutterRendererTextSetMarkupMethodInfo +instance (signature ~ (T.Text -> Int32 -> m ()), MonadIO m, IsGutterRendererText a) => O.MethodInfo GutterRendererTextSetMarkupMethodInfo a signature where + overloadedMethod _ = gutterRendererTextSetMarkup + +#endif + +-- method GutterRendererText::set_text +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "GtkSource", name = "GutterRendererText"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_gutter_renderer_text_set_text" gtk_source_gutter_renderer_text_set_text :: + Ptr GutterRendererText -> -- renderer : TInterface (Name {namespace = "GtkSource", name = "GutterRendererText"}) + CString -> -- text : TBasicType TUTF8 + Int32 -> -- length : TBasicType TInt + IO () + +{- | +/No description available in the introspection data./ +-} +gutterRendererTextSetText :: + (B.CallStack.HasCallStack, MonadIO m, IsGutterRendererText a) => + a + -> T.Text + -> Int32 + -> m () +gutterRendererTextSetText renderer text length_ = liftIO $ do + renderer' <- unsafeManagedPtrCastPtr renderer + text' <- textToCString text + gtk_source_gutter_renderer_text_set_text renderer' text' length_ + touchManagedPtr renderer + freeMem text' + return () + +#if ENABLE_OVERLOADING +data GutterRendererTextSetTextMethodInfo +instance (signature ~ (T.Text -> Int32 -> m ()), MonadIO m, IsGutterRendererText a) => O.MethodInfo GutterRendererTextSetTextMethodInfo a signature where + overloadedMethod _ = gutterRendererTextSetText + +#endif + + diff --git a/GI/GtkSource/Objects/GutterRendererText.hs-boot b/GI/GtkSource/Objects/GutterRendererText.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/GutterRendererText.hs-boot @@ -0,0 +1,47 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.GutterRendererText 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 GutterRendererText = GutterRendererText (ManagedPtr GutterRendererText) +instance GObject GutterRendererText where +class (GObject o, O.IsDescendantOf GutterRendererText o) => IsGutterRendererText o +instance (GObject o, O.IsDescendantOf GutterRendererText o) => IsGutterRendererText o +instance O.HasParentTypes GutterRendererText +#if ENABLE_OVERLOADING +data GutterRendererTextMarkupPropertyInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererTextTextPropertyInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererTextMeasureMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererTextMeasureMarkupMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererTextSetMarkupMethodInfo +#endif +#if ENABLE_OVERLOADING +data GutterRendererTextSetTextMethodInfo +#endif diff --git a/GI/GtkSource/Objects/Language.hs b/GI/GtkSource/Objects/Language.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/Language.hs @@ -0,0 +1,822 @@ + + +{- | +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.Language + ( + +-- * Exported types + Language(..) , + IsLanguage , + toLanguage , + noLanguage , + + + -- * Methods +-- ** getGlobs #method:getGlobs# + +#if ENABLE_OVERLOADING + LanguageGetGlobsMethodInfo , +#endif + languageGetGlobs , + + +-- ** getHidden #method:getHidden# + +#if ENABLE_OVERLOADING + LanguageGetHiddenMethodInfo , +#endif + languageGetHidden , + + +-- ** getId #method:getId# + +#if ENABLE_OVERLOADING + LanguageGetIdMethodInfo , +#endif + languageGetId , + + +-- ** getMetadata #method:getMetadata# + +#if ENABLE_OVERLOADING + LanguageGetMetadataMethodInfo , +#endif + languageGetMetadata , + + +-- ** getMimeTypes #method:getMimeTypes# + +#if ENABLE_OVERLOADING + LanguageGetMimeTypesMethodInfo , +#endif + languageGetMimeTypes , + + +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + LanguageGetNameMethodInfo , +#endif + languageGetName , + + +-- ** getSection #method:getSection# + +#if ENABLE_OVERLOADING + LanguageGetSectionMethodInfo , +#endif + languageGetSection , + + +-- ** getStyleFallback #method:getStyleFallback# + +#if ENABLE_OVERLOADING + LanguageGetStyleFallbackMethodInfo , +#endif + languageGetStyleFallback , + + +-- ** getStyleIds #method:getStyleIds# + +#if ENABLE_OVERLOADING + LanguageGetStyleIdsMethodInfo , +#endif + languageGetStyleIds , + + +-- ** getStyleName #method:getStyleName# + +#if ENABLE_OVERLOADING + LanguageGetStyleNameMethodInfo , +#endif + languageGetStyleName , + + + + + -- * Properties +-- ** hidden #attr:hidden# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + LanguageHiddenPropertyInfo , +#endif + getLanguageHidden , +#if ENABLE_OVERLOADING + languageHidden , +#endif + + +-- ** id #attr:id# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + LanguageIdPropertyInfo , +#endif + getLanguageId , +#if ENABLE_OVERLOADING + languageId , +#endif + + +-- ** name #attr:name# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + LanguageNamePropertyInfo , +#endif + getLanguageName , +#if ENABLE_OVERLOADING + languageName , +#endif + + +-- ** section #attr:section# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + LanguageSectionPropertyInfo , +#endif + getLanguageSection , +#if ENABLE_OVERLOADING + languageSection , +#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 + +-- | Memory-managed wrapper type. +newtype Language = Language (ManagedPtr Language) +foreign import ccall "gtk_source_language_get_type" + c_gtk_source_language_get_type :: IO GType + +instance GObject Language where + gobjectType = c_gtk_source_language_get_type + + +-- | Type class for types which can be safely cast to `Language`, for instance with `toLanguage`. +class (GObject o, O.IsDescendantOf Language o) => IsLanguage o +instance (GObject o, O.IsDescendantOf Language o) => IsLanguage o + +instance O.HasParentTypes Language +type instance O.ParentTypes Language = '[GObject.Object.Object] + +-- | Cast to `Language`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toLanguage :: (MonadIO m, IsLanguage o) => o -> m Language +toLanguage = liftIO . unsafeCastTo Language + +-- | A convenience alias for `Nothing` :: `Maybe` `Language`. +noLanguage :: Maybe Language +noLanguage = Nothing + +#if ENABLE_OVERLOADING +type family ResolveLanguageMethod (t :: Symbol) (o :: *) :: * where + ResolveLanguageMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveLanguageMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveLanguageMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveLanguageMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveLanguageMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveLanguageMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveLanguageMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveLanguageMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveLanguageMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveLanguageMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveLanguageMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveLanguageMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveLanguageMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveLanguageMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveLanguageMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveLanguageMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveLanguageMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveLanguageMethod "getGlobs" o = LanguageGetGlobsMethodInfo + ResolveLanguageMethod "getHidden" o = LanguageGetHiddenMethodInfo + ResolveLanguageMethod "getId" o = LanguageGetIdMethodInfo + ResolveLanguageMethod "getMetadata" o = LanguageGetMetadataMethodInfo + ResolveLanguageMethod "getMimeTypes" o = LanguageGetMimeTypesMethodInfo + ResolveLanguageMethod "getName" o = LanguageGetNameMethodInfo + ResolveLanguageMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveLanguageMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveLanguageMethod "getSection" o = LanguageGetSectionMethodInfo + ResolveLanguageMethod "getStyleFallback" o = LanguageGetStyleFallbackMethodInfo + ResolveLanguageMethod "getStyleIds" o = LanguageGetStyleIdsMethodInfo + ResolveLanguageMethod "getStyleName" o = LanguageGetStyleNameMethodInfo + ResolveLanguageMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveLanguageMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveLanguageMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveLanguageMethod t Language, O.MethodInfo info Language p) => OL.IsLabel t (Language -> 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 + +-- VVV Prop "hidden" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@hidden@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' language #hidden +@ +-} +getLanguageHidden :: (MonadIO m, IsLanguage o) => o -> m Bool +getLanguageHidden obj = liftIO $ B.Properties.getObjectPropertyBool obj "hidden" + +#if ENABLE_OVERLOADING +data LanguageHiddenPropertyInfo +instance AttrInfo LanguageHiddenPropertyInfo where + type AttrAllowedOps LanguageHiddenPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint LanguageHiddenPropertyInfo = (~) () + type AttrBaseTypeConstraint LanguageHiddenPropertyInfo = IsLanguage + type AttrGetType LanguageHiddenPropertyInfo = Bool + type AttrLabel LanguageHiddenPropertyInfo = "hidden" + type AttrOrigin LanguageHiddenPropertyInfo = Language + attrGet _ = getLanguageHidden + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "id" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@id@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' language #id +@ +-} +getLanguageId :: (MonadIO m, IsLanguage o) => o -> m T.Text +getLanguageId obj = liftIO $ checkUnexpectedNothing "getLanguageId" $ B.Properties.getObjectPropertyString obj "id" + +#if ENABLE_OVERLOADING +data LanguageIdPropertyInfo +instance AttrInfo LanguageIdPropertyInfo where + type AttrAllowedOps LanguageIdPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint LanguageIdPropertyInfo = (~) () + type AttrBaseTypeConstraint LanguageIdPropertyInfo = IsLanguage + type AttrGetType LanguageIdPropertyInfo = T.Text + type AttrLabel LanguageIdPropertyInfo = "id" + type AttrOrigin LanguageIdPropertyInfo = Language + attrGet _ = getLanguageId + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "name" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@name@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' language #name +@ +-} +getLanguageName :: (MonadIO m, IsLanguage o) => o -> m T.Text +getLanguageName obj = liftIO $ checkUnexpectedNothing "getLanguageName" $ B.Properties.getObjectPropertyString obj "name" + +#if ENABLE_OVERLOADING +data LanguageNamePropertyInfo +instance AttrInfo LanguageNamePropertyInfo where + type AttrAllowedOps LanguageNamePropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint LanguageNamePropertyInfo = (~) () + type AttrBaseTypeConstraint LanguageNamePropertyInfo = IsLanguage + type AttrGetType LanguageNamePropertyInfo = T.Text + type AttrLabel LanguageNamePropertyInfo = "name" + type AttrOrigin LanguageNamePropertyInfo = Language + attrGet _ = getLanguageName + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "section" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@section@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' language #section +@ +-} +getLanguageSection :: (MonadIO m, IsLanguage o) => o -> m T.Text +getLanguageSection obj = liftIO $ checkUnexpectedNothing "getLanguageSection" $ B.Properties.getObjectPropertyString obj "section" + +#if ENABLE_OVERLOADING +data LanguageSectionPropertyInfo +instance AttrInfo LanguageSectionPropertyInfo where + type AttrAllowedOps LanguageSectionPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint LanguageSectionPropertyInfo = (~) () + type AttrBaseTypeConstraint LanguageSectionPropertyInfo = IsLanguage + type AttrGetType LanguageSectionPropertyInfo = T.Text + type AttrLabel LanguageSectionPropertyInfo = "section" + type AttrOrigin LanguageSectionPropertyInfo = Language + attrGet _ = getLanguageSection + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Language +type instance O.AttributeList Language = LanguageAttributeList +type LanguageAttributeList = ('[ '("hidden", LanguageHiddenPropertyInfo), '("id", LanguageIdPropertyInfo), '("name", LanguageNamePropertyInfo), '("section", LanguageSectionPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +languageHidden :: AttrLabelProxy "hidden" +languageHidden = AttrLabelProxy + +languageId :: AttrLabelProxy "id" +languageId = AttrLabelProxy + +languageName :: AttrLabelProxy "name" +languageName = AttrLabelProxy + +languageSection :: AttrLabelProxy "section" +languageSection = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Language = LanguageSignalList +type LanguageSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Language::get_globs +-- method type : OrdinaryMethod +-- 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 (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_language_get_globs" gtk_source_language_get_globs :: + Ptr Language -> -- language : TInterface (Name {namespace = "GtkSource", name = "Language"}) + IO (Ptr CString) + +{- | +Returns the globs associated to this language. This is just +an utility wrapper around 'GI.GtkSource.Objects.Language.languageGetMetadata' to +retrieve the \"globs\" metadata property and split it into an array. +-} +languageGetGlobs :: + (B.CallStack.HasCallStack, MonadIO m, IsLanguage a) => + a + {- ^ /@language@/: a 'GI.GtkSource.Objects.Language.Language'. -} + -> m (Maybe [T.Text]) + {- ^ __Returns:__ +a newly-allocated 'Nothing' terminated array containing the globs or 'Nothing' +if no globs are found. +The returned array must be freed with 'GI.GLib.Functions.strfreev'. -} +languageGetGlobs language = liftIO $ do + language' <- unsafeManagedPtrCastPtr language + result <- gtk_source_language_get_globs language' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- unpackZeroTerminatedUTF8CArray result' + mapZeroTerminatedCArray freeMem result' + freeMem result' + return result'' + touchManagedPtr language + return maybeResult + +#if ENABLE_OVERLOADING +data LanguageGetGlobsMethodInfo +instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsLanguage a) => O.MethodInfo LanguageGetGlobsMethodInfo a signature where + overloadedMethod _ = languageGetGlobs + +#endif + +-- method Language::get_hidden +-- method type : OrdinaryMethod +-- 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 (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_language_get_hidden" gtk_source_language_get_hidden :: + Ptr Language -> -- language : TInterface (Name {namespace = "GtkSource", name = "Language"}) + IO CInt + +{- | +Returns whether the language should be hidden from the user. +-} +languageGetHidden :: + (B.CallStack.HasCallStack, MonadIO m, IsLanguage a) => + a + {- ^ /@language@/: a 'GI.GtkSource.Objects.Language.Language' -} + -> m Bool + {- ^ __Returns:__ 'True' if the language should be hidden, 'False' otherwise. -} +languageGetHidden language = liftIO $ do + language' <- unsafeManagedPtrCastPtr language + result <- gtk_source_language_get_hidden language' + let result' = (/= 0) result + touchManagedPtr language + return result' + +#if ENABLE_OVERLOADING +data LanguageGetHiddenMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsLanguage a) => O.MethodInfo LanguageGetHiddenMethodInfo a signature where + overloadedMethod _ = languageGetHidden + +#endif + +-- method Language::get_id +-- method type : OrdinaryMethod +-- 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 (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_language_get_id" gtk_source_language_get_id :: + Ptr Language -> -- language : TInterface (Name {namespace = "GtkSource", name = "Language"}) + IO CString + +{- | +Returns the ID of the language. The ID is not locale-dependent. +The returned string is owned by /@language@/ and should not be freed +or modified. +-} +languageGetId :: + (B.CallStack.HasCallStack, MonadIO m, IsLanguage a) => + a + {- ^ /@language@/: a 'GI.GtkSource.Objects.Language.Language'. -} + -> m T.Text + {- ^ __Returns:__ the ID of /@language@/. -} +languageGetId language = liftIO $ do + language' <- unsafeManagedPtrCastPtr language + result <- gtk_source_language_get_id language' + checkUnexpectedReturnNULL "languageGetId" result + result' <- cstringToText result + touchManagedPtr language + return result' + +#if ENABLE_OVERLOADING +data LanguageGetIdMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsLanguage a) => O.MethodInfo LanguageGetIdMethodInfo a signature where + overloadedMethod _ = languageGetId + +#endif + +-- method Language::get_metadata +-- method type : OrdinaryMethod +-- 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},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "metadata property name.", 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_language_get_metadata" gtk_source_language_get_metadata :: + Ptr Language -> -- language : TInterface (Name {namespace = "GtkSource", name = "Language"}) + CString -> -- name : TBasicType TUTF8 + IO CString + +{- | +/No description available in the introspection data./ +-} +languageGetMetadata :: + (B.CallStack.HasCallStack, MonadIO m, IsLanguage a) => + a + {- ^ /@language@/: a 'GI.GtkSource.Objects.Language.Language'. -} + -> T.Text + {- ^ /@name@/: metadata property name. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ value of property /@name@/ stored in +the metadata of /@language@/ or 'Nothing' if language does not contain the +specified metadata property. +The returned string is owned by /@language@/ and should not be freed +or modified. -} +languageGetMetadata language name = liftIO $ do + language' <- unsafeManagedPtrCastPtr language + name' <- textToCString name + result <- gtk_source_language_get_metadata language' name' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr language + freeMem name' + return maybeResult + +#if ENABLE_OVERLOADING +data LanguageGetMetadataMethodInfo +instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m, IsLanguage a) => O.MethodInfo LanguageGetMetadataMethodInfo a signature where + overloadedMethod _ = languageGetMetadata + +#endif + +-- method Language::get_mime_types +-- method type : OrdinaryMethod +-- 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 (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_language_get_mime_types" gtk_source_language_get_mime_types :: + Ptr Language -> -- language : TInterface (Name {namespace = "GtkSource", name = "Language"}) + IO (Ptr CString) + +{- | +Returns the mime types associated to this language. This is just +an utility wrapper around 'GI.GtkSource.Objects.Language.languageGetMetadata' to +retrieve the \"mimetypes\" metadata property and split it into an +array. +-} +languageGetMimeTypes :: + (B.CallStack.HasCallStack, MonadIO m, IsLanguage a) => + a + {- ^ /@language@/: a 'GI.GtkSource.Objects.Language.Language'. -} + -> m (Maybe [T.Text]) + {- ^ __Returns:__ +a newly-allocated 'Nothing' terminated array containing the mime types +or 'Nothing' if no mime types are found. +The returned array must be freed with 'GI.GLib.Functions.strfreev'. -} +languageGetMimeTypes language = liftIO $ do + language' <- unsafeManagedPtrCastPtr language + result <- gtk_source_language_get_mime_types language' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- unpackZeroTerminatedUTF8CArray result' + mapZeroTerminatedCArray freeMem result' + freeMem result' + return result'' + touchManagedPtr language + return maybeResult + +#if ENABLE_OVERLOADING +data LanguageGetMimeTypesMethodInfo +instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsLanguage a) => O.MethodInfo LanguageGetMimeTypesMethodInfo a signature where + overloadedMethod _ = languageGetMimeTypes + +#endif + +-- method Language::get_name +-- method type : OrdinaryMethod +-- 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 (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_language_get_name" gtk_source_language_get_name :: + Ptr Language -> -- language : TInterface (Name {namespace = "GtkSource", name = "Language"}) + IO CString + +{- | +Returns the localized name of the language. +The returned string is owned by /@language@/ and should not be freed +or modified. +-} +languageGetName :: + (B.CallStack.HasCallStack, MonadIO m, IsLanguage a) => + a + {- ^ /@language@/: a 'GI.GtkSource.Objects.Language.Language'. -} + -> m T.Text + {- ^ __Returns:__ the name of /@language@/. -} +languageGetName language = liftIO $ do + language' <- unsafeManagedPtrCastPtr language + result <- gtk_source_language_get_name language' + checkUnexpectedReturnNULL "languageGetName" result + result' <- cstringToText result + touchManagedPtr language + return result' + +#if ENABLE_OVERLOADING +data LanguageGetNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsLanguage a) => O.MethodInfo LanguageGetNameMethodInfo a signature where + overloadedMethod _ = languageGetName + +#endif + +-- method Language::get_section +-- method type : OrdinaryMethod +-- 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 (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_language_get_section" gtk_source_language_get_section :: + Ptr Language -> -- language : TInterface (Name {namespace = "GtkSource", name = "Language"}) + IO CString + +{- | +Returns the localized section of the language. +Each language belong to a section (ex. HTML belogs to the +Markup section). +The returned string is owned by /@language@/ and should not be freed +or modified. +-} +languageGetSection :: + (B.CallStack.HasCallStack, MonadIO m, IsLanguage a) => + a + {- ^ /@language@/: a 'GI.GtkSource.Objects.Language.Language'. -} + -> m T.Text + {- ^ __Returns:__ the section of /@language@/. -} +languageGetSection language = liftIO $ do + language' <- unsafeManagedPtrCastPtr language + result <- gtk_source_language_get_section language' + checkUnexpectedReturnNULL "languageGetSection" result + result' <- cstringToText result + touchManagedPtr language + return result' + +#if ENABLE_OVERLOADING +data LanguageGetSectionMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsLanguage a) => O.MethodInfo LanguageGetSectionMethodInfo a signature where + overloadedMethod _ = languageGetSection + +#endif + +-- method Language::get_style_fallback +-- method type : OrdinaryMethod +-- 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},Arg {argCName = "style_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a style ID.", 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_language_get_style_fallback" gtk_source_language_get_style_fallback :: + Ptr Language -> -- language : TInterface (Name {namespace = "GtkSource", name = "Language"}) + CString -> -- style_id : TBasicType TUTF8 + IO CString + +{- | +Returns the ID of the style to use if the specified /@styleId@/ +is not present in the current style scheme. + +/Since: 3.4/ +-} +languageGetStyleFallback :: + (B.CallStack.HasCallStack, MonadIO m, IsLanguage a) => + a + {- ^ /@language@/: a 'GI.GtkSource.Objects.Language.Language'. -} + -> T.Text + {- ^ /@styleId@/: a style ID. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the ID of the style to use if the +specified /@styleId@/ is not present in the current style scheme or 'Nothing' +if the style has no fallback defined. +The returned string is owned by the /@language@/ and must not be modified. -} +languageGetStyleFallback language styleId = liftIO $ do + language' <- unsafeManagedPtrCastPtr language + styleId' <- textToCString styleId + result <- gtk_source_language_get_style_fallback language' styleId' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr language + freeMem styleId' + return maybeResult + +#if ENABLE_OVERLOADING +data LanguageGetStyleFallbackMethodInfo +instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m, IsLanguage a) => O.MethodInfo LanguageGetStyleFallbackMethodInfo a signature where + overloadedMethod _ = languageGetStyleFallback + +#endif + +-- method Language::get_style_ids +-- method type : OrdinaryMethod +-- 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 (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_language_get_style_ids" gtk_source_language_get_style_ids :: + Ptr Language -> -- language : TInterface (Name {namespace = "GtkSource", name = "Language"}) + IO (Ptr CString) + +{- | +Returns the ids of the styles defined by this /@language@/. +-} +languageGetStyleIds :: + (B.CallStack.HasCallStack, MonadIO m, IsLanguage a) => + a + {- ^ /@language@/: a 'GI.GtkSource.Objects.Language.Language'. -} + -> m (Maybe [T.Text]) + {- ^ __Returns:__ +a newly-allocated 'Nothing' terminated array containing ids of the +styles defined by this /@language@/ or 'Nothing' if no style is defined. +The returned array must be freed with 'GI.GLib.Functions.strfreev'. -} +languageGetStyleIds language = liftIO $ do + language' <- unsafeManagedPtrCastPtr language + result <- gtk_source_language_get_style_ids language' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- unpackZeroTerminatedUTF8CArray result' + mapZeroTerminatedCArray freeMem result' + freeMem result' + return result'' + touchManagedPtr language + return maybeResult + +#if ENABLE_OVERLOADING +data LanguageGetStyleIdsMethodInfo +instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsLanguage a) => O.MethodInfo LanguageGetStyleIdsMethodInfo a signature where + overloadedMethod _ = languageGetStyleIds + +#endif + +-- method Language::get_style_name +-- method type : OrdinaryMethod +-- 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},Arg {argCName = "style_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a style ID.", 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_language_get_style_name" gtk_source_language_get_style_name :: + Ptr Language -> -- language : TInterface (Name {namespace = "GtkSource", name = "Language"}) + CString -> -- style_id : TBasicType TUTF8 + IO CString + +{- | +Returns the name of the style with ID /@styleId@/ defined by this /@language@/. +-} +languageGetStyleName :: + (B.CallStack.HasCallStack, MonadIO m, IsLanguage a) => + a + {- ^ /@language@/: a 'GI.GtkSource.Objects.Language.Language'. -} + -> T.Text + {- ^ /@styleId@/: a style ID. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the name of the style with ID /@styleId@/ +defined by this /@language@/ or 'Nothing' if the style has no name or there is no +style with ID /@styleId@/ defined by this /@language@/. +The returned string is owned by the /@language@/ and must not be modified. -} +languageGetStyleName language styleId = liftIO $ do + language' <- unsafeManagedPtrCastPtr language + styleId' <- textToCString styleId + result <- gtk_source_language_get_style_name language' styleId' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr language + freeMem styleId' + return maybeResult + +#if ENABLE_OVERLOADING +data LanguageGetStyleNameMethodInfo +instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m, IsLanguage a) => O.MethodInfo LanguageGetStyleNameMethodInfo a signature where + overloadedMethod _ = languageGetStyleName + +#endif + + diff --git a/GI/GtkSource/Objects/Language.hs-boot b/GI/GtkSource/Objects/Language.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/Language.hs-boot @@ -0,0 +1,71 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.Language 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 Language = Language (ManagedPtr Language) +instance GObject Language where +class (GObject o, O.IsDescendantOf Language o) => IsLanguage o +instance (GObject o, O.IsDescendantOf Language o) => IsLanguage o +instance O.HasParentTypes Language +#if ENABLE_OVERLOADING +data LanguageHiddenPropertyInfo +#endif +#if ENABLE_OVERLOADING +data LanguageIdPropertyInfo +#endif +#if ENABLE_OVERLOADING +data LanguageNamePropertyInfo +#endif +#if ENABLE_OVERLOADING +data LanguageSectionPropertyInfo +#endif +#if ENABLE_OVERLOADING +data LanguageGetGlobsMethodInfo +#endif +#if ENABLE_OVERLOADING +data LanguageGetHiddenMethodInfo +#endif +#if ENABLE_OVERLOADING +data LanguageGetIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data LanguageGetMetadataMethodInfo +#endif +#if ENABLE_OVERLOADING +data LanguageGetMimeTypesMethodInfo +#endif +#if ENABLE_OVERLOADING +data LanguageGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data LanguageGetSectionMethodInfo +#endif +#if ENABLE_OVERLOADING +data LanguageGetStyleFallbackMethodInfo +#endif +#if ENABLE_OVERLOADING +data LanguageGetStyleIdsMethodInfo +#endif +#if ENABLE_OVERLOADING +data LanguageGetStyleNameMethodInfo +#endif diff --git a/GI/GtkSource/Objects/LanguageManager.hs b/GI/GtkSource/Objects/LanguageManager.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/LanguageManager.hs @@ -0,0 +1,632 @@ + + +{- | +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.LanguageManager + ( + +-- * Exported types + LanguageManager(..) , + IsLanguageManager , + toLanguageManager , + noLanguageManager , + + + -- * Methods +-- ** getDefault #method:getDefault# + + languageManagerGetDefault , + + +-- ** getLanguage #method:getLanguage# + +#if ENABLE_OVERLOADING + LanguageManagerGetLanguageMethodInfo , +#endif + languageManagerGetLanguage , + + +-- ** getLanguageIds #method:getLanguageIds# + +#if ENABLE_OVERLOADING + LanguageManagerGetLanguageIdsMethodInfo , +#endif + languageManagerGetLanguageIds , + + +-- ** getSearchPath #method:getSearchPath# + +#if ENABLE_OVERLOADING + LanguageManagerGetSearchPathMethodInfo , +#endif + languageManagerGetSearchPath , + + +-- ** guessLanguage #method:guessLanguage# + +#if ENABLE_OVERLOADING + LanguageManagerGuessLanguageMethodInfo , +#endif + languageManagerGuessLanguage , + + +-- ** new #method:new# + + languageManagerNew , + + +-- ** setSearchPath #method:setSearchPath# + +#if ENABLE_OVERLOADING + LanguageManagerSetSearchPathMethodInfo , +#endif + languageManagerSetSearchPath , + + + + + -- * Properties +-- ** languageIds #attr:languageIds# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + LanguageManagerLanguageIdsPropertyInfo , +#endif + getLanguageManagerLanguageIds , +#if ENABLE_OVERLOADING + languageManagerLanguageIds , +#endif + + +-- ** searchPath #attr:searchPath# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + LanguageManagerSearchPathPropertyInfo , +#endif + clearLanguageManagerSearchPath , + constructLanguageManagerSearchPath , + getLanguageManagerSearchPath , +#if ENABLE_OVERLOADING + languageManagerSearchPath , +#endif + setLanguageManagerSearchPath , + + + + + ) 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.Language as GtkSource.Language + +-- | Memory-managed wrapper type. +newtype LanguageManager = LanguageManager (ManagedPtr LanguageManager) +foreign import ccall "gtk_source_language_manager_get_type" + c_gtk_source_language_manager_get_type :: IO GType + +instance GObject LanguageManager where + gobjectType = c_gtk_source_language_manager_get_type + + +-- | Type class for types which can be safely cast to `LanguageManager`, for instance with `toLanguageManager`. +class (GObject o, O.IsDescendantOf LanguageManager o) => IsLanguageManager o +instance (GObject o, O.IsDescendantOf LanguageManager o) => IsLanguageManager o + +instance O.HasParentTypes LanguageManager +type instance O.ParentTypes LanguageManager = '[GObject.Object.Object] + +-- | Cast to `LanguageManager`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toLanguageManager :: (MonadIO m, IsLanguageManager o) => o -> m LanguageManager +toLanguageManager = liftIO . unsafeCastTo LanguageManager + +-- | A convenience alias for `Nothing` :: `Maybe` `LanguageManager`. +noLanguageManager :: Maybe LanguageManager +noLanguageManager = Nothing + +#if ENABLE_OVERLOADING +type family ResolveLanguageManagerMethod (t :: Symbol) (o :: *) :: * where + ResolveLanguageManagerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveLanguageManagerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveLanguageManagerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveLanguageManagerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveLanguageManagerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveLanguageManagerMethod "guessLanguage" o = LanguageManagerGuessLanguageMethodInfo + ResolveLanguageManagerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveLanguageManagerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveLanguageManagerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveLanguageManagerMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveLanguageManagerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveLanguageManagerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveLanguageManagerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveLanguageManagerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveLanguageManagerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveLanguageManagerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveLanguageManagerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveLanguageManagerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveLanguageManagerMethod "getLanguage" o = LanguageManagerGetLanguageMethodInfo + ResolveLanguageManagerMethod "getLanguageIds" o = LanguageManagerGetLanguageIdsMethodInfo + ResolveLanguageManagerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveLanguageManagerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveLanguageManagerMethod "getSearchPath" o = LanguageManagerGetSearchPathMethodInfo + ResolveLanguageManagerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveLanguageManagerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveLanguageManagerMethod "setSearchPath" o = LanguageManagerSetSearchPathMethodInfo + ResolveLanguageManagerMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveLanguageManagerMethod t LanguageManager, O.MethodInfo info LanguageManager p) => OL.IsLabel t (LanguageManager -> 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 + +-- VVV Prop "language-ids" + -- Type: TCArray True (-1) (-1) (TBasicType TUTF8) + -- Flags: [PropertyReadable] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@language-ids@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' languageManager #languageIds +@ +-} +getLanguageManagerLanguageIds :: (MonadIO m, IsLanguageManager o) => o -> m (Maybe [T.Text]) +getLanguageManagerLanguageIds obj = liftIO $ B.Properties.getObjectPropertyStringArray obj "language-ids" + +#if ENABLE_OVERLOADING +data LanguageManagerLanguageIdsPropertyInfo +instance AttrInfo LanguageManagerLanguageIdsPropertyInfo where + type AttrAllowedOps LanguageManagerLanguageIdsPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint LanguageManagerLanguageIdsPropertyInfo = (~) () + type AttrBaseTypeConstraint LanguageManagerLanguageIdsPropertyInfo = IsLanguageManager + type AttrGetType LanguageManagerLanguageIdsPropertyInfo = (Maybe [T.Text]) + type AttrLabel LanguageManagerLanguageIdsPropertyInfo = "language-ids" + type AttrOrigin LanguageManagerLanguageIdsPropertyInfo = LanguageManager + attrGet _ = getLanguageManagerLanguageIds + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "search-path" + -- Type: TCArray True (-1) (-1) (TBasicType TUTF8) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just True) + +{- | +Get the value of the “@search-path@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' languageManager #searchPath +@ +-} +getLanguageManagerSearchPath :: (MonadIO m, IsLanguageManager o) => o -> m [T.Text] +getLanguageManagerSearchPath obj = liftIO $ checkUnexpectedNothing "getLanguageManagerSearchPath" $ B.Properties.getObjectPropertyStringArray obj "search-path" + +{- | +Set the value of the “@search-path@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' languageManager [ #searchPath 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setLanguageManagerSearchPath :: (MonadIO m, IsLanguageManager o) => o -> [T.Text] -> m () +setLanguageManagerSearchPath obj val = liftIO $ B.Properties.setObjectPropertyStringArray obj "search-path" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@search-path@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructLanguageManagerSearchPath :: (IsLanguageManager o) => [T.Text] -> IO (GValueConstruct o) +constructLanguageManagerSearchPath val = B.Properties.constructObjectPropertyStringArray "search-path" (Just val) + +{- | +Set the value of the “@search-path@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #searchPath +@ +-} +clearLanguageManagerSearchPath :: (MonadIO m, IsLanguageManager o) => o -> m () +clearLanguageManagerSearchPath obj = liftIO $ B.Properties.setObjectPropertyStringArray obj "search-path" (Nothing :: Maybe [T.Text]) + +#if ENABLE_OVERLOADING +data LanguageManagerSearchPathPropertyInfo +instance AttrInfo LanguageManagerSearchPathPropertyInfo where + type AttrAllowedOps LanguageManagerSearchPathPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint LanguageManagerSearchPathPropertyInfo = (~) [T.Text] + type AttrBaseTypeConstraint LanguageManagerSearchPathPropertyInfo = IsLanguageManager + type AttrGetType LanguageManagerSearchPathPropertyInfo = [T.Text] + type AttrLabel LanguageManagerSearchPathPropertyInfo = "search-path" + type AttrOrigin LanguageManagerSearchPathPropertyInfo = LanguageManager + attrGet _ = getLanguageManagerSearchPath + attrSet _ = setLanguageManagerSearchPath + attrConstruct _ = constructLanguageManagerSearchPath + attrClear _ = clearLanguageManagerSearchPath +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList LanguageManager +type instance O.AttributeList LanguageManager = LanguageManagerAttributeList +type LanguageManagerAttributeList = ('[ '("languageIds", LanguageManagerLanguageIdsPropertyInfo), '("searchPath", LanguageManagerSearchPathPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +languageManagerLanguageIds :: AttrLabelProxy "languageIds" +languageManagerLanguageIds = AttrLabelProxy + +languageManagerSearchPath :: AttrLabelProxy "searchPath" +languageManagerSearchPath = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList LanguageManager = LanguageManagerSignalList +type LanguageManagerSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method LanguageManager::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "LanguageManager"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_language_manager_new" gtk_source_language_manager_new :: + IO (Ptr LanguageManager) + +{- | +Creates a new language manager. If you do not need more than one language +manager or a private language manager instance then use +'GI.GtkSource.Objects.LanguageManager.languageManagerGetDefault' instead. +-} +languageManagerNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m LanguageManager + {- ^ __Returns:__ a new 'GI.GtkSource.Objects.LanguageManager.LanguageManager'. -} +languageManagerNew = liftIO $ do + result <- gtk_source_language_manager_new + checkUnexpectedReturnNULL "languageManagerNew" result + result' <- (wrapObject LanguageManager) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method LanguageManager::get_language +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "lm", argType = TInterface (Name {namespace = "GtkSource", name = "LanguageManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceLanguageManager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a language id.", 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_language_manager_get_language" gtk_source_language_manager_get_language :: + Ptr LanguageManager -> -- lm : TInterface (Name {namespace = "GtkSource", name = "LanguageManager"}) + CString -> -- id : TBasicType TUTF8 + IO (Ptr GtkSource.Language.Language) + +{- | +Gets the 'GI.GtkSource.Objects.Language.Language' identified by the given /@id@/ in the language +manager. +-} +languageManagerGetLanguage :: + (B.CallStack.HasCallStack, MonadIO m, IsLanguageManager a) => + a + {- ^ /@lm@/: a 'GI.GtkSource.Objects.LanguageManager.LanguageManager'. -} + -> T.Text + {- ^ /@id@/: a language id. -} + -> m (Maybe GtkSource.Language.Language) + {- ^ __Returns:__ a 'GI.GtkSource.Objects.Language.Language', or 'Nothing' +if there is no language identified by the given /@id@/. Return value is +owned by /@lm@/ and should not be freed. -} +languageManagerGetLanguage lm id = liftIO $ do + lm' <- unsafeManagedPtrCastPtr lm + id' <- textToCString id + result <- gtk_source_language_manager_get_language lm' id' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject GtkSource.Language.Language) result' + return result'' + touchManagedPtr lm + freeMem id' + return maybeResult + +#if ENABLE_OVERLOADING +data LanguageManagerGetLanguageMethodInfo +instance (signature ~ (T.Text -> m (Maybe GtkSource.Language.Language)), MonadIO m, IsLanguageManager a) => O.MethodInfo LanguageManagerGetLanguageMethodInfo a signature where + overloadedMethod _ = languageManagerGetLanguage + +#endif + +-- method LanguageManager::get_language_ids +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "lm", argType = TInterface (Name {namespace = "GtkSource", name = "LanguageManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceLanguageManager.", 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_language_manager_get_language_ids" gtk_source_language_manager_get_language_ids :: + Ptr LanguageManager -> -- lm : TInterface (Name {namespace = "GtkSource", name = "LanguageManager"}) + IO (Ptr CString) + +{- | +Returns the ids of the available languages. +-} +languageManagerGetLanguageIds :: + (B.CallStack.HasCallStack, MonadIO m, IsLanguageManager a) => + a + {- ^ /@lm@/: a 'GI.GtkSource.Objects.LanguageManager.LanguageManager'. -} + -> m (Maybe [T.Text]) + {- ^ __Returns:__ +a 'Nothing'-terminated array of strings containing the ids of the available +languages or 'Nothing' if no language is available. +The array is sorted alphabetically according to the language name. +The array is owned by /@lm@/ and must not be modified. -} +languageManagerGetLanguageIds lm = liftIO $ do + lm' <- unsafeManagedPtrCastPtr lm + result <- gtk_source_language_manager_get_language_ids lm' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- unpackZeroTerminatedUTF8CArray result' + return result'' + touchManagedPtr lm + return maybeResult + +#if ENABLE_OVERLOADING +data LanguageManagerGetLanguageIdsMethodInfo +instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsLanguageManager a) => O.MethodInfo LanguageManagerGetLanguageIdsMethodInfo a signature where + overloadedMethod _ = languageManagerGetLanguageIds + +#endif + +-- method LanguageManager::get_search_path +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "lm", argType = TInterface (Name {namespace = "GtkSource", name = "LanguageManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceLanguageManager.", 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_language_manager_get_search_path" gtk_source_language_manager_get_search_path :: + Ptr LanguageManager -> -- lm : TInterface (Name {namespace = "GtkSource", name = "LanguageManager"}) + IO (Ptr CString) + +{- | +Gets the list directories where /@lm@/ looks for language files. +-} +languageManagerGetSearchPath :: + (B.CallStack.HasCallStack, MonadIO m, IsLanguageManager a) => + a + {- ^ /@lm@/: a 'GI.GtkSource.Objects.LanguageManager.LanguageManager'. -} + -> m [T.Text] + {- ^ __Returns:__ 'Nothing'-terminated array +containg a list of language files directories. +The array is owned by /@lm@/ and must not be modified. -} +languageManagerGetSearchPath lm = liftIO $ do + lm' <- unsafeManagedPtrCastPtr lm + result <- gtk_source_language_manager_get_search_path lm' + checkUnexpectedReturnNULL "languageManagerGetSearchPath" result + result' <- unpackZeroTerminatedUTF8CArray result + touchManagedPtr lm + return result' + +#if ENABLE_OVERLOADING +data LanguageManagerGetSearchPathMethodInfo +instance (signature ~ (m [T.Text]), MonadIO m, IsLanguageManager a) => O.MethodInfo LanguageManagerGetSearchPathMethodInfo a signature where + overloadedMethod _ = languageManagerGetSearchPath + +#endif + +-- method LanguageManager::guess_language +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "lm", argType = TInterface (Name {namespace = "GtkSource", name = "LanguageManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceLanguageManager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a filename in Glib filename encoding, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "content_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a content type (as in GIO API), or %NULL.", 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_language_manager_guess_language" gtk_source_language_manager_guess_language :: + Ptr LanguageManager -> -- lm : TInterface (Name {namespace = "GtkSource", name = "LanguageManager"}) + CString -> -- filename : TBasicType TUTF8 + CString -> -- content_type : TBasicType TUTF8 + IO (Ptr GtkSource.Language.Language) + +{- | +Picks a 'GI.GtkSource.Objects.Language.Language' for given file name and content type, +according to the information in lang files. Either /@filename@/ or +/@contentType@/ may be 'Nothing'. This function can be used as follows: + +\\ + GtkSourceLanguage *lang; + lang = gtk_source_language_manager_guess_language (filename, NULL); + gtk_source_buffer_set_language (buffer, lang); +\<\/programlisting>\<\/informalexample> + +or + +\\ + GtkSourceLanguage *lang = NULL; + gboolean result_uncertain; + gchar *content_type; + + content_type = g_content_type_guess (filename, NULL, 0, &result_uncertain); + if (result_uncertain) + { + g_free (content_type); + content_type = NULL; + } + + lang = gtk_source_language_manager_guess_language (manager, filename, content_type); + gtk_source_buffer_set_language (buffer, lang); + + g_free (content_type); +\<\/programlisting>\<\/informalexample> + +etc. Use 'GI.GtkSource.Objects.Language.languageGetMimeTypes' and 'GI.GtkSource.Objects.Language.languageGetGlobs' +if you need full control over file -> language mapping. + +/Since: 2.4/ +-} +languageManagerGuessLanguage :: + (B.CallStack.HasCallStack, MonadIO m, IsLanguageManager a) => + a + {- ^ /@lm@/: a 'GI.GtkSource.Objects.LanguageManager.LanguageManager'. -} + -> Maybe (T.Text) + {- ^ /@filename@/: a filename in Glib filename encoding, or 'Nothing'. -} + -> Maybe (T.Text) + {- ^ /@contentType@/: a content type (as in GIO API), or 'Nothing'. -} + -> m (Maybe GtkSource.Language.Language) + {- ^ __Returns:__ a 'GI.GtkSource.Objects.Language.Language', or 'Nothing' if there +is no suitable language for given /@filename@/ and\/or /@contentType@/. Return +value is owned by /@lm@/ and should not be freed. -} +languageManagerGuessLanguage lm filename contentType = liftIO $ do + lm' <- unsafeManagedPtrCastPtr lm + maybeFilename <- case filename of + Nothing -> return nullPtr + Just jFilename -> do + jFilename' <- textToCString jFilename + return jFilename' + maybeContentType <- case contentType of + Nothing -> return nullPtr + Just jContentType -> do + jContentType' <- textToCString jContentType + return jContentType' + result <- gtk_source_language_manager_guess_language lm' maybeFilename maybeContentType + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject GtkSource.Language.Language) result' + return result'' + touchManagedPtr lm + freeMem maybeFilename + freeMem maybeContentType + return maybeResult + +#if ENABLE_OVERLOADING +data LanguageManagerGuessLanguageMethodInfo +instance (signature ~ (Maybe (T.Text) -> Maybe (T.Text) -> m (Maybe GtkSource.Language.Language)), MonadIO m, IsLanguageManager a) => O.MethodInfo LanguageManagerGuessLanguageMethodInfo a signature where + overloadedMethod _ = languageManagerGuessLanguage + +#endif + +-- method LanguageManager::set_search_path +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "lm", argType = TInterface (Name {namespace = "GtkSource", name = "LanguageManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceLanguageManager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dirs", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "\na %NULL-terminated array of strings 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_language_manager_set_search_path" gtk_source_language_manager_set_search_path :: + Ptr LanguageManager -> -- lm : TInterface (Name {namespace = "GtkSource", name = "LanguageManager"}) + Ptr CString -> -- dirs : TCArray True (-1) (-1) (TBasicType TUTF8) + IO () + +{- | +Sets the list of directories where the /@lm@/ looks for +language files. +If /@dirs@/ is 'Nothing', the search path is reset to default. + +\ + \ + At the moment this function can be called only before the + language files are loaded for the first time. In practice + to set a custom search path for a 'GI.GtkSource.Objects.LanguageManager.LanguageManager', + you have to call this function right after creating it. + \<\/para> +\<\/note> +-} +languageManagerSetSearchPath :: + (B.CallStack.HasCallStack, MonadIO m, IsLanguageManager a) => + a + {- ^ /@lm@/: a 'GI.GtkSource.Objects.LanguageManager.LanguageManager'. -} + -> Maybe ([T.Text]) + {- ^ /@dirs@/: +a 'Nothing'-terminated array of strings or 'Nothing'. -} + -> m () +languageManagerSetSearchPath lm dirs = liftIO $ do + lm' <- unsafeManagedPtrCastPtr lm + maybeDirs <- case dirs of + Nothing -> return nullPtr + Just jDirs -> do + jDirs' <- packZeroTerminatedUTF8CArray jDirs + return jDirs' + gtk_source_language_manager_set_search_path lm' maybeDirs + touchManagedPtr lm + mapZeroTerminatedCArray freeMem maybeDirs + freeMem maybeDirs + return () + +#if ENABLE_OVERLOADING +data LanguageManagerSetSearchPathMethodInfo +instance (signature ~ (Maybe ([T.Text]) -> m ()), MonadIO m, IsLanguageManager a) => O.MethodInfo LanguageManagerSetSearchPathMethodInfo a signature where + overloadedMethod _ = languageManagerSetSearchPath + +#endif + +-- method LanguageManager::get_default +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "LanguageManager"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_language_manager_get_default" gtk_source_language_manager_get_default :: + IO (Ptr LanguageManager) + +{- | +Returns the default 'GI.GtkSource.Objects.LanguageManager.LanguageManager' instance. +-} +languageManagerGetDefault :: + (B.CallStack.HasCallStack, MonadIO m) => + m LanguageManager + {- ^ __Returns:__ a 'GI.GtkSource.Objects.LanguageManager.LanguageManager'. +Return value is owned by GtkSourceView library and must not be unref\'ed. -} +languageManagerGetDefault = liftIO $ do + result <- gtk_source_language_manager_get_default + checkUnexpectedReturnNULL "languageManagerGetDefault" result + result' <- (newObject LanguageManager) result + return result' + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/GtkSource/Objects/LanguageManager.hs-boot b/GI/GtkSource/Objects/LanguageManager.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/LanguageManager.hs-boot @@ -0,0 +1,50 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.LanguageManager 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 LanguageManager = LanguageManager (ManagedPtr LanguageManager) +instance GObject LanguageManager where +class (GObject o, O.IsDescendantOf LanguageManager o) => IsLanguageManager o +instance (GObject o, O.IsDescendantOf LanguageManager o) => IsLanguageManager o +instance O.HasParentTypes LanguageManager +#if ENABLE_OVERLOADING +data LanguageManagerLanguageIdsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data LanguageManagerSearchPathPropertyInfo +#endif +#if ENABLE_OVERLOADING +data LanguageManagerGetLanguageMethodInfo +#endif +#if ENABLE_OVERLOADING +data LanguageManagerGetLanguageIdsMethodInfo +#endif +#if ENABLE_OVERLOADING +data LanguageManagerGetSearchPathMethodInfo +#endif +#if ENABLE_OVERLOADING +data LanguageManagerGuessLanguageMethodInfo +#endif +#if ENABLE_OVERLOADING +data LanguageManagerSetSearchPathMethodInfo +#endif diff --git a/GI/GtkSource/Objects/Map.hs b/GI/GtkSource/Objects/Map.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/Map.hs @@ -0,0 +1,817 @@ + + +{- | +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.Map + ( + +-- * Exported types + Map(..) , + IsMap , + toMap , + noMap , + + + -- * Methods +-- ** getView #method:getView# + +#if ENABLE_OVERLOADING + MapGetViewMethodInfo , +#endif + mapGetView , + + +-- ** new #method:new# + + mapNew , + + +-- ** setView #method:setView# + +#if ENABLE_OVERLOADING + MapSetViewMethodInfo , +#endif + mapSetView , + + + + + -- * Properties +-- ** fontDesc #attr:fontDesc# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + MapFontDescPropertyInfo , +#endif + clearMapFontDesc , + constructMapFontDesc , + getMapFontDesc , +#if ENABLE_OVERLOADING + mapFontDesc , +#endif + setMapFontDesc , + + +-- ** view #attr:view# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + MapViewPropertyInfo , +#endif + constructMapView , + getMapView , +#if ENABLE_OVERLOADING + mapView , +#endif + setMapView , + + + + + ) 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.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable +import qualified GI.Gtk.Interfaces.Scrollable as Gtk.Scrollable +import qualified GI.Gtk.Objects.Container as Gtk.Container +import qualified GI.Gtk.Objects.TextView as Gtk.TextView +import qualified GI.Gtk.Objects.Widget as Gtk.Widget +import {-# SOURCE #-} qualified GI.GtkSource.Objects.View as GtkSource.View +import qualified GI.Pango.Structs.FontDescription as Pango.FontDescription + +-- | Memory-managed wrapper type. +newtype Map = Map (ManagedPtr Map) +foreign import ccall "gtk_source_map_get_type" + c_gtk_source_map_get_type :: IO GType + +instance GObject Map where + gobjectType = c_gtk_source_map_get_type + + +-- | Type class for types which can be safely cast to `Map`, for instance with `toMap`. +class (GObject o, O.IsDescendantOf Map o) => IsMap o +instance (GObject o, O.IsDescendantOf Map o) => IsMap o + +instance O.HasParentTypes Map +type instance O.ParentTypes Map = '[GtkSource.View.View, Gtk.TextView.TextView, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable, Gtk.Scrollable.Scrollable] + +-- | Cast to `Map`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toMap :: (MonadIO m, IsMap o) => o -> m Map +toMap = liftIO . unsafeCastTo Map + +-- | A convenience alias for `Nothing` :: `Maybe` `Map`. +noMap :: Maybe Map +noMap = Nothing + +#if ENABLE_OVERLOADING +type family ResolveMapMethod (t :: Symbol) (o :: *) :: * where + ResolveMapMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo + ResolveMapMethod "add" o = Gtk.Container.ContainerAddMethodInfo + ResolveMapMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo + ResolveMapMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo + ResolveMapMethod "addChildAtAnchor" o = Gtk.TextView.TextViewAddChildAtAnchorMethodInfo + ResolveMapMethod "addChildInWindow" o = Gtk.TextView.TextViewAddChildInWindowMethodInfo + ResolveMapMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo + ResolveMapMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo + ResolveMapMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo + ResolveMapMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo + ResolveMapMethod "backwardDisplayLine" o = Gtk.TextView.TextViewBackwardDisplayLineMethodInfo + ResolveMapMethod "backwardDisplayLineStart" o = Gtk.TextView.TextViewBackwardDisplayLineStartMethodInfo + ResolveMapMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveMapMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveMapMethod "bufferToWindowCoords" o = Gtk.TextView.TextViewBufferToWindowCoordsMethodInfo + ResolveMapMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo + ResolveMapMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo + ResolveMapMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo + ResolveMapMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo + ResolveMapMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo + ResolveMapMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo + ResolveMapMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo + ResolveMapMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo + ResolveMapMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo + ResolveMapMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo + ResolveMapMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo + ResolveMapMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo + ResolveMapMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo + ResolveMapMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo + ResolveMapMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo + ResolveMapMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo + ResolveMapMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo + ResolveMapMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo + ResolveMapMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo + ResolveMapMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo + ResolveMapMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo + ResolveMapMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo + ResolveMapMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo + ResolveMapMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo + ResolveMapMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo + ResolveMapMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo + ResolveMapMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo + ResolveMapMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo + ResolveMapMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo + ResolveMapMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo + ResolveMapMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo + ResolveMapMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo + ResolveMapMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo + ResolveMapMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo + ResolveMapMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo + ResolveMapMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo + ResolveMapMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo + ResolveMapMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo + ResolveMapMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo + ResolveMapMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo + ResolveMapMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo + ResolveMapMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo + ResolveMapMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo + ResolveMapMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo + ResolveMapMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo + ResolveMapMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo + ResolveMapMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo + ResolveMapMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo + ResolveMapMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo + ResolveMapMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo + ResolveMapMethod "event" o = Gtk.Widget.WidgetEventMethodInfo + ResolveMapMethod "forall" o = Gtk.Container.ContainerForallMethodInfo + ResolveMapMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveMapMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo + ResolveMapMethod "forwardDisplayLine" o = Gtk.TextView.TextViewForwardDisplayLineMethodInfo + ResolveMapMethod "forwardDisplayLineEnd" o = Gtk.TextView.TextViewForwardDisplayLineEndMethodInfo + ResolveMapMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo + ResolveMapMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveMapMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveMapMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo + ResolveMapMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo + ResolveMapMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo + ResolveMapMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo + ResolveMapMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo + ResolveMapMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo + ResolveMapMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo + ResolveMapMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo + ResolveMapMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo + ResolveMapMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo + ResolveMapMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo + ResolveMapMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo + ResolveMapMethod "imContextFilterKeypress" o = Gtk.TextView.TextViewImContextFilterKeypressMethodInfo + ResolveMapMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo + ResolveMapMethod "indentLines" o = GtkSource.View.ViewIndentLinesMethodInfo + ResolveMapMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo + ResolveMapMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo + ResolveMapMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo + ResolveMapMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo + ResolveMapMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo + ResolveMapMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo + ResolveMapMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo + ResolveMapMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveMapMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo + ResolveMapMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo + ResolveMapMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo + ResolveMapMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo + ResolveMapMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo + ResolveMapMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo + ResolveMapMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo + ResolveMapMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo + ResolveMapMethod "map" o = Gtk.Widget.WidgetMapMethodInfo + ResolveMapMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo + ResolveMapMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo + ResolveMapMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo + ResolveMapMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo + ResolveMapMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo + ResolveMapMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo + ResolveMapMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo + ResolveMapMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo + ResolveMapMethod "moveChild" o = Gtk.TextView.TextViewMoveChildMethodInfo + ResolveMapMethod "moveMarkOnscreen" o = Gtk.TextView.TextViewMoveMarkOnscreenMethodInfo + ResolveMapMethod "moveVisually" o = Gtk.TextView.TextViewMoveVisuallyMethodInfo + ResolveMapMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveMapMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveMapMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo + ResolveMapMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo + ResolveMapMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo + ResolveMapMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo + ResolveMapMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo + ResolveMapMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo + ResolveMapMethod "path" o = Gtk.Widget.WidgetPathMethodInfo + ResolveMapMethod "placeCursorOnscreen" o = Gtk.TextView.TextViewPlaceCursorOnscreenMethodInfo + ResolveMapMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo + ResolveMapMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo + ResolveMapMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo + ResolveMapMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo + ResolveMapMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo + ResolveMapMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo + ResolveMapMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo + ResolveMapMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo + ResolveMapMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo + ResolveMapMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveMapMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveMapMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo + ResolveMapMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo + ResolveMapMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo + ResolveMapMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo + ResolveMapMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo + ResolveMapMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo + ResolveMapMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo + ResolveMapMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo + ResolveMapMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo + ResolveMapMethod "resetCursorBlink" o = Gtk.TextView.TextViewResetCursorBlinkMethodInfo + ResolveMapMethod "resetImContext" o = Gtk.TextView.TextViewResetImContextMethodInfo + ResolveMapMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo + ResolveMapMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo + ResolveMapMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo + ResolveMapMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveMapMethod "scrollMarkOnscreen" o = Gtk.TextView.TextViewScrollMarkOnscreenMethodInfo + ResolveMapMethod "scrollToIter" o = Gtk.TextView.TextViewScrollToIterMethodInfo + ResolveMapMethod "scrollToMark" o = Gtk.TextView.TextViewScrollToMarkMethodInfo + ResolveMapMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo + ResolveMapMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo + ResolveMapMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo + ResolveMapMethod "show" o = Gtk.Widget.WidgetShowMethodInfo + ResolveMapMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo + ResolveMapMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo + ResolveMapMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo + ResolveMapMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo + ResolveMapMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo + ResolveMapMethod "startsDisplayLine" o = Gtk.TextView.TextViewStartsDisplayLineMethodInfo + ResolveMapMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveMapMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveMapMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo + ResolveMapMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo + ResolveMapMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo + ResolveMapMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveMapMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo + ResolveMapMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo + ResolveMapMethod "unindentLines" o = GtkSource.View.ViewUnindentLinesMethodInfo + ResolveMapMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo + ResolveMapMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo + ResolveMapMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo + ResolveMapMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveMapMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo + ResolveMapMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo + ResolveMapMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo + ResolveMapMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveMapMethod "windowToBufferCoords" o = Gtk.TextView.TextViewWindowToBufferCoordsMethodInfo + ResolveMapMethod "getAcceptsTab" o = Gtk.TextView.TextViewGetAcceptsTabMethodInfo + ResolveMapMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo + ResolveMapMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo + ResolveMapMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo + ResolveMapMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo + ResolveMapMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo + ResolveMapMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo + ResolveMapMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo + ResolveMapMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo + ResolveMapMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo + ResolveMapMethod "getAutoIndent" o = GtkSource.View.ViewGetAutoIndentMethodInfo + ResolveMapMethod "getBackgroundPattern" o = GtkSource.View.ViewGetBackgroundPatternMethodInfo + ResolveMapMethod "getBorder" o = Gtk.Scrollable.ScrollableGetBorderMethodInfo + ResolveMapMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo + ResolveMapMethod "getBorderWindowSize" o = Gtk.TextView.TextViewGetBorderWindowSizeMethodInfo + ResolveMapMethod "getBottomMargin" o = Gtk.TextView.TextViewGetBottomMarginMethodInfo + ResolveMapMethod "getBuffer" o = Gtk.TextView.TextViewGetBufferMethodInfo + ResolveMapMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo + ResolveMapMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo + ResolveMapMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo + ResolveMapMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo + ResolveMapMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo + ResolveMapMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo + ResolveMapMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo + ResolveMapMethod "getCompletion" o = GtkSource.View.ViewGetCompletionMethodInfo + ResolveMapMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo + ResolveMapMethod "getCursorLocations" o = Gtk.TextView.TextViewGetCursorLocationsMethodInfo + ResolveMapMethod "getCursorVisible" o = Gtk.TextView.TextViewGetCursorVisibleMethodInfo + ResolveMapMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveMapMethod "getDefaultAttributes" o = Gtk.TextView.TextViewGetDefaultAttributesMethodInfo + ResolveMapMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo + ResolveMapMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo + ResolveMapMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo + ResolveMapMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo + ResolveMapMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo + ResolveMapMethod "getDrawSpaces" o = GtkSource.View.ViewGetDrawSpacesMethodInfo + ResolveMapMethod "getEditable" o = Gtk.TextView.TextViewGetEditableMethodInfo + ResolveMapMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo + ResolveMapMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo + ResolveMapMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo + ResolveMapMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo + ResolveMapMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo + ResolveMapMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo + ResolveMapMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo + ResolveMapMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo + ResolveMapMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo + ResolveMapMethod "getGutter" o = GtkSource.View.ViewGetGutterMethodInfo + ResolveMapMethod "getHadjustment" o = Gtk.TextView.TextViewGetHadjustmentMethodInfo + ResolveMapMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo + ResolveMapMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo + ResolveMapMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo + ResolveMapMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo + ResolveMapMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo + ResolveMapMethod "getHighlightCurrentLine" o = GtkSource.View.ViewGetHighlightCurrentLineMethodInfo + ResolveMapMethod "getHscrollPolicy" o = Gtk.Scrollable.ScrollableGetHscrollPolicyMethodInfo + ResolveMapMethod "getIndent" o = Gtk.TextView.TextViewGetIndentMethodInfo + ResolveMapMethod "getIndentOnTab" o = GtkSource.View.ViewGetIndentOnTabMethodInfo + ResolveMapMethod "getIndentWidth" o = GtkSource.View.ViewGetIndentWidthMethodInfo + ResolveMapMethod "getInputHints" o = Gtk.TextView.TextViewGetInputHintsMethodInfo + ResolveMapMethod "getInputPurpose" o = Gtk.TextView.TextViewGetInputPurposeMethodInfo + ResolveMapMethod "getInsertSpacesInsteadOfTabs" o = GtkSource.View.ViewGetInsertSpacesInsteadOfTabsMethodInfo + ResolveMapMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo + ResolveMapMethod "getIterAtLocation" o = Gtk.TextView.TextViewGetIterAtLocationMethodInfo + ResolveMapMethod "getIterAtPosition" o = Gtk.TextView.TextViewGetIterAtPositionMethodInfo + ResolveMapMethod "getIterLocation" o = Gtk.TextView.TextViewGetIterLocationMethodInfo + ResolveMapMethod "getJustification" o = Gtk.TextView.TextViewGetJustificationMethodInfo + ResolveMapMethod "getLeftMargin" o = Gtk.TextView.TextViewGetLeftMarginMethodInfo + ResolveMapMethod "getLineAtY" o = Gtk.TextView.TextViewGetLineAtYMethodInfo + ResolveMapMethod "getLineYrange" o = Gtk.TextView.TextViewGetLineYrangeMethodInfo + ResolveMapMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo + ResolveMapMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo + ResolveMapMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo + ResolveMapMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo + ResolveMapMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo + ResolveMapMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo + ResolveMapMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo + ResolveMapMethod "getMarkAttributes" o = GtkSource.View.ViewGetMarkAttributesMethodInfo + ResolveMapMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo + ResolveMapMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo + ResolveMapMethod "getMonospace" o = Gtk.TextView.TextViewGetMonospaceMethodInfo + ResolveMapMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo + ResolveMapMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo + ResolveMapMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo + ResolveMapMethod "getOverwrite" o = Gtk.TextView.TextViewGetOverwriteMethodInfo + ResolveMapMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo + ResolveMapMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo + ResolveMapMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo + ResolveMapMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo + ResolveMapMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo + ResolveMapMethod "getPixelsAboveLines" o = Gtk.TextView.TextViewGetPixelsAboveLinesMethodInfo + ResolveMapMethod "getPixelsBelowLines" o = Gtk.TextView.TextViewGetPixelsBelowLinesMethodInfo + ResolveMapMethod "getPixelsInsideWrap" o = Gtk.TextView.TextViewGetPixelsInsideWrapMethodInfo + ResolveMapMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo + ResolveMapMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo + ResolveMapMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo + ResolveMapMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo + ResolveMapMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo + ResolveMapMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo + ResolveMapMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo + ResolveMapMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveMapMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveMapMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo + ResolveMapMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo + ResolveMapMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo + ResolveMapMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo + ResolveMapMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo + ResolveMapMethod "getRightMargin" o = Gtk.TextView.TextViewGetRightMarginMethodInfo + ResolveMapMethod "getRightMarginPosition" o = GtkSource.View.ViewGetRightMarginPositionMethodInfo + ResolveMapMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo + ResolveMapMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo + ResolveMapMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo + ResolveMapMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo + ResolveMapMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo + ResolveMapMethod "getShowLineMarks" o = GtkSource.View.ViewGetShowLineMarksMethodInfo + ResolveMapMethod "getShowLineNumbers" o = GtkSource.View.ViewGetShowLineNumbersMethodInfo + ResolveMapMethod "getShowRightMargin" o = GtkSource.View.ViewGetShowRightMarginMethodInfo + ResolveMapMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo + ResolveMapMethod "getSmartBackspace" o = GtkSource.View.ViewGetSmartBackspaceMethodInfo + ResolveMapMethod "getSmartHomeEnd" o = GtkSource.View.ViewGetSmartHomeEndMethodInfo + ResolveMapMethod "getSpaceDrawer" o = GtkSource.View.ViewGetSpaceDrawerMethodInfo + ResolveMapMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo + ResolveMapMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo + ResolveMapMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo + ResolveMapMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo + ResolveMapMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo + ResolveMapMethod "getTabWidth" o = GtkSource.View.ViewGetTabWidthMethodInfo + ResolveMapMethod "getTabs" o = Gtk.TextView.TextViewGetTabsMethodInfo + ResolveMapMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo + ResolveMapMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo + ResolveMapMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo + ResolveMapMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo + ResolveMapMethod "getTopMargin" o = Gtk.TextView.TextViewGetTopMarginMethodInfo + ResolveMapMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo + ResolveMapMethod "getVadjustment" o = Gtk.TextView.TextViewGetVadjustmentMethodInfo + ResolveMapMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo + ResolveMapMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo + ResolveMapMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo + ResolveMapMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo + ResolveMapMethod "getView" o = MapGetViewMethodInfo + ResolveMapMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo + ResolveMapMethod "getVisibleRect" o = Gtk.TextView.TextViewGetVisibleRectMethodInfo + ResolveMapMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo + ResolveMapMethod "getVisualColumn" o = GtkSource.View.ViewGetVisualColumnMethodInfo + ResolveMapMethod "getVscrollPolicy" o = Gtk.Scrollable.ScrollableGetVscrollPolicyMethodInfo + ResolveMapMethod "getWindow" o = Gtk.TextView.TextViewGetWindowMethodInfo + ResolveMapMethod "getWindowType" o = Gtk.TextView.TextViewGetWindowTypeMethodInfo + ResolveMapMethod "getWrapMode" o = Gtk.TextView.TextViewGetWrapModeMethodInfo + ResolveMapMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo + ResolveMapMethod "setAcceptsTab" o = Gtk.TextView.TextViewSetAcceptsTabMethodInfo + ResolveMapMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo + ResolveMapMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo + ResolveMapMethod "setAutoIndent" o = GtkSource.View.ViewSetAutoIndentMethodInfo + ResolveMapMethod "setBackgroundPattern" o = GtkSource.View.ViewSetBackgroundPatternMethodInfo + ResolveMapMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo + ResolveMapMethod "setBorderWindowSize" o = Gtk.TextView.TextViewSetBorderWindowSizeMethodInfo + ResolveMapMethod "setBottomMargin" o = Gtk.TextView.TextViewSetBottomMarginMethodInfo + ResolveMapMethod "setBuffer" o = Gtk.TextView.TextViewSetBufferMethodInfo + ResolveMapMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo + ResolveMapMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo + ResolveMapMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo + ResolveMapMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo + ResolveMapMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo + ResolveMapMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo + ResolveMapMethod "setCursorVisible" o = Gtk.TextView.TextViewSetCursorVisibleMethodInfo + ResolveMapMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveMapMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo + ResolveMapMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo + ResolveMapMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo + ResolveMapMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo + ResolveMapMethod "setDrawSpaces" o = GtkSource.View.ViewSetDrawSpacesMethodInfo + ResolveMapMethod "setEditable" o = Gtk.TextView.TextViewSetEditableMethodInfo + ResolveMapMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo + ResolveMapMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo + ResolveMapMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo + ResolveMapMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo + ResolveMapMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo + ResolveMapMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo + ResolveMapMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo + ResolveMapMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo + ResolveMapMethod "setHadjustment" o = Gtk.Scrollable.ScrollableSetHadjustmentMethodInfo + ResolveMapMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo + ResolveMapMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo + ResolveMapMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo + ResolveMapMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo + ResolveMapMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo + ResolveMapMethod "setHighlightCurrentLine" o = GtkSource.View.ViewSetHighlightCurrentLineMethodInfo + ResolveMapMethod "setHscrollPolicy" o = Gtk.Scrollable.ScrollableSetHscrollPolicyMethodInfo + ResolveMapMethod "setIndent" o = Gtk.TextView.TextViewSetIndentMethodInfo + ResolveMapMethod "setIndentOnTab" o = GtkSource.View.ViewSetIndentOnTabMethodInfo + ResolveMapMethod "setIndentWidth" o = GtkSource.View.ViewSetIndentWidthMethodInfo + ResolveMapMethod "setInputHints" o = Gtk.TextView.TextViewSetInputHintsMethodInfo + ResolveMapMethod "setInputPurpose" o = Gtk.TextView.TextViewSetInputPurposeMethodInfo + ResolveMapMethod "setInsertSpacesInsteadOfTabs" o = GtkSource.View.ViewSetInsertSpacesInsteadOfTabsMethodInfo + ResolveMapMethod "setJustification" o = Gtk.TextView.TextViewSetJustificationMethodInfo + ResolveMapMethod "setLeftMargin" o = Gtk.TextView.TextViewSetLeftMarginMethodInfo + ResolveMapMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo + ResolveMapMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo + ResolveMapMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo + ResolveMapMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo + ResolveMapMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo + ResolveMapMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo + ResolveMapMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo + ResolveMapMethod "setMarkAttributes" o = GtkSource.View.ViewSetMarkAttributesMethodInfo + ResolveMapMethod "setMonospace" o = Gtk.TextView.TextViewSetMonospaceMethodInfo + ResolveMapMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo + ResolveMapMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo + ResolveMapMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo + ResolveMapMethod "setOverwrite" o = Gtk.TextView.TextViewSetOverwriteMethodInfo + ResolveMapMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo + ResolveMapMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo + ResolveMapMethod "setPixelsAboveLines" o = Gtk.TextView.TextViewSetPixelsAboveLinesMethodInfo + ResolveMapMethod "setPixelsBelowLines" o = Gtk.TextView.TextViewSetPixelsBelowLinesMethodInfo + ResolveMapMethod "setPixelsInsideWrap" o = Gtk.TextView.TextViewSetPixelsInsideWrapMethodInfo + ResolveMapMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveMapMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo + ResolveMapMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo + ResolveMapMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo + ResolveMapMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo + ResolveMapMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo + ResolveMapMethod "setRightMargin" o = Gtk.TextView.TextViewSetRightMarginMethodInfo + ResolveMapMethod "setRightMarginPosition" o = GtkSource.View.ViewSetRightMarginPositionMethodInfo + ResolveMapMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo + ResolveMapMethod "setShowLineMarks" o = GtkSource.View.ViewSetShowLineMarksMethodInfo + ResolveMapMethod "setShowLineNumbers" o = GtkSource.View.ViewSetShowLineNumbersMethodInfo + ResolveMapMethod "setShowRightMargin" o = GtkSource.View.ViewSetShowRightMarginMethodInfo + ResolveMapMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo + ResolveMapMethod "setSmartBackspace" o = GtkSource.View.ViewSetSmartBackspaceMethodInfo + ResolveMapMethod "setSmartHomeEnd" o = GtkSource.View.ViewSetSmartHomeEndMethodInfo + ResolveMapMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo + ResolveMapMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo + ResolveMapMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo + ResolveMapMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo + ResolveMapMethod "setTabWidth" o = GtkSource.View.ViewSetTabWidthMethodInfo + ResolveMapMethod "setTabs" o = Gtk.TextView.TextViewSetTabsMethodInfo + ResolveMapMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo + ResolveMapMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo + ResolveMapMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo + ResolveMapMethod "setTopMargin" o = Gtk.TextView.TextViewSetTopMarginMethodInfo + ResolveMapMethod "setVadjustment" o = Gtk.Scrollable.ScrollableSetVadjustmentMethodInfo + ResolveMapMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo + ResolveMapMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo + ResolveMapMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo + ResolveMapMethod "setView" o = MapSetViewMethodInfo + ResolveMapMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo + ResolveMapMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo + ResolveMapMethod "setVscrollPolicy" o = Gtk.Scrollable.ScrollableSetVscrollPolicyMethodInfo + ResolveMapMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo + ResolveMapMethod "setWrapMode" o = Gtk.TextView.TextViewSetWrapModeMethodInfo + ResolveMapMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveMapMethod t Map, O.MethodInfo info Map p) => OL.IsLabel t (Map -> 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 + +-- VVV Prop "font-desc" + -- Type: TInterface (Name {namespace = "Pango", name = "FontDescription"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@font-desc@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' map #fontDesc +@ +-} +getMapFontDesc :: (MonadIO m, IsMap o) => o -> m (Maybe Pango.FontDescription.FontDescription) +getMapFontDesc obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "font-desc" Pango.FontDescription.FontDescription + +{- | +Set the value of the “@font-desc@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' map [ #fontDesc 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setMapFontDesc :: (MonadIO m, IsMap o) => o -> Pango.FontDescription.FontDescription -> m () +setMapFontDesc obj val = liftIO $ B.Properties.setObjectPropertyBoxed obj "font-desc" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@font-desc@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructMapFontDesc :: (IsMap o) => Pango.FontDescription.FontDescription -> IO (GValueConstruct o) +constructMapFontDesc val = B.Properties.constructObjectPropertyBoxed "font-desc" (Just val) + +{- | +Set the value of the “@font-desc@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #fontDesc +@ +-} +clearMapFontDesc :: (MonadIO m, IsMap o) => o -> m () +clearMapFontDesc obj = liftIO $ B.Properties.setObjectPropertyBoxed obj "font-desc" (Nothing :: Maybe Pango.FontDescription.FontDescription) + +#if ENABLE_OVERLOADING +data MapFontDescPropertyInfo +instance AttrInfo MapFontDescPropertyInfo where + type AttrAllowedOps MapFontDescPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint MapFontDescPropertyInfo = (~) Pango.FontDescription.FontDescription + type AttrBaseTypeConstraint MapFontDescPropertyInfo = IsMap + type AttrGetType MapFontDescPropertyInfo = (Maybe Pango.FontDescription.FontDescription) + type AttrLabel MapFontDescPropertyInfo = "font-desc" + type AttrOrigin MapFontDescPropertyInfo = Map + attrGet _ = getMapFontDesc + attrSet _ = setMapFontDesc + attrConstruct _ = constructMapFontDesc + attrClear _ = clearMapFontDesc +#endif + +-- VVV Prop "view" + -- Type: TInterface (Name {namespace = "GtkSource", name = "View"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just True,Just False) + +{- | +Get the value of the “@view@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' map #view +@ +-} +getMapView :: (MonadIO m, IsMap o) => o -> m (Maybe GtkSource.View.View) +getMapView obj = liftIO $ B.Properties.getObjectPropertyObject obj "view" GtkSource.View.View + +{- | +Set the value of the “@view@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' map [ #view 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setMapView :: (MonadIO m, IsMap o, GtkSource.View.IsView a) => o -> a -> m () +setMapView obj val = liftIO $ B.Properties.setObjectPropertyObject obj "view" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@view@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructMapView :: (IsMap o, GtkSource.View.IsView a) => a -> IO (GValueConstruct o) +constructMapView val = B.Properties.constructObjectPropertyObject "view" (Just val) + +#if ENABLE_OVERLOADING +data MapViewPropertyInfo +instance AttrInfo MapViewPropertyInfo where + type AttrAllowedOps MapViewPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint MapViewPropertyInfo = GtkSource.View.IsView + type AttrBaseTypeConstraint MapViewPropertyInfo = IsMap + type AttrGetType MapViewPropertyInfo = (Maybe GtkSource.View.View) + type AttrLabel MapViewPropertyInfo = "view" + type AttrOrigin MapViewPropertyInfo = Map + attrGet _ = getMapView + attrSet _ = setMapView + attrConstruct _ = constructMapView + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Map +type instance O.AttributeList Map = MapAttributeList +type MapAttributeList = ('[ '("acceptsTab", Gtk.TextView.TextViewAcceptsTabPropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("autoIndent", GtkSource.View.ViewAutoIndentPropertyInfo), '("backgroundPattern", GtkSource.View.ViewBackgroundPatternPropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("bottomMargin", Gtk.TextView.TextViewBottomMarginPropertyInfo), '("buffer", Gtk.TextView.TextViewBufferPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("completion", GtkSource.View.ViewCompletionPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("cursorVisible", Gtk.TextView.TextViewCursorVisiblePropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("drawSpaces", GtkSource.View.ViewDrawSpacesPropertyInfo), '("editable", Gtk.TextView.TextViewEditablePropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("fontDesc", MapFontDescPropertyInfo), '("hadjustment", Gtk.Scrollable.ScrollableHadjustmentPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("highlightCurrentLine", GtkSource.View.ViewHighlightCurrentLinePropertyInfo), '("hscrollPolicy", Gtk.Scrollable.ScrollableHscrollPolicyPropertyInfo), '("imModule", Gtk.TextView.TextViewImModulePropertyInfo), '("indent", Gtk.TextView.TextViewIndentPropertyInfo), '("indentOnTab", GtkSource.View.ViewIndentOnTabPropertyInfo), '("indentWidth", GtkSource.View.ViewIndentWidthPropertyInfo), '("inputHints", Gtk.TextView.TextViewInputHintsPropertyInfo), '("inputPurpose", Gtk.TextView.TextViewInputPurposePropertyInfo), '("insertSpacesInsteadOfTabs", GtkSource.View.ViewInsertSpacesInsteadOfTabsPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("justification", Gtk.TextView.TextViewJustificationPropertyInfo), '("leftMargin", Gtk.TextView.TextViewLeftMarginPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("monospace", Gtk.TextView.TextViewMonospacePropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overwrite", Gtk.TextView.TextViewOverwritePropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("pixelsAboveLines", Gtk.TextView.TextViewPixelsAboveLinesPropertyInfo), '("pixelsBelowLines", Gtk.TextView.TextViewPixelsBelowLinesPropertyInfo), '("pixelsInsideWrap", Gtk.TextView.TextViewPixelsInsideWrapPropertyInfo), '("populateAll", Gtk.TextView.TextViewPopulateAllPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("rightMargin", Gtk.TextView.TextViewRightMarginPropertyInfo), '("rightMarginPosition", GtkSource.View.ViewRightMarginPositionPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("showLineMarks", GtkSource.View.ViewShowLineMarksPropertyInfo), '("showLineNumbers", GtkSource.View.ViewShowLineNumbersPropertyInfo), '("showRightMargin", GtkSource.View.ViewShowRightMarginPropertyInfo), '("smartBackspace", GtkSource.View.ViewSmartBackspacePropertyInfo), '("smartHomeEnd", GtkSource.View.ViewSmartHomeEndPropertyInfo), '("spaceDrawer", GtkSource.View.ViewSpaceDrawerPropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("tabWidth", GtkSource.View.ViewTabWidthPropertyInfo), '("tabs", Gtk.TextView.TextViewTabsPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("topMargin", Gtk.TextView.TextViewTopMarginPropertyInfo), '("vadjustment", Gtk.Scrollable.ScrollableVadjustmentPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("view", MapViewPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("vscrollPolicy", Gtk.Scrollable.ScrollableVscrollPolicyPropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo), '("wrapMode", Gtk.TextView.TextViewWrapModePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +mapFontDesc :: AttrLabelProxy "fontDesc" +mapFontDesc = AttrLabelProxy + +mapView :: AttrLabelProxy "view" +mapView = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Map = MapSignalList +type MapSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("backspace", Gtk.TextView.TextViewBackspaceSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("changeCase", GtkSource.View.ViewChangeCaseSignalInfo), '("changeNumber", GtkSource.View.ViewChangeNumberSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("copyClipboard", Gtk.TextView.TextViewCopyClipboardSignalInfo), '("cutClipboard", Gtk.TextView.TextViewCutClipboardSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("deleteFromCursor", Gtk.TextView.TextViewDeleteFromCursorSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("extendSelection", Gtk.TextView.TextViewExtendSelectionSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("insertAtCursor", Gtk.TextView.TextViewInsertAtCursorSignalInfo), '("insertEmoji", Gtk.TextView.TextViewInsertEmojiSignalInfo), '("joinLines", GtkSource.View.ViewJoinLinesSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("lineMarkActivated", GtkSource.View.ViewLineMarkActivatedSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveCursor", Gtk.TextView.TextViewMoveCursorSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("moveLines", GtkSource.View.ViewMoveLinesSignalInfo), '("moveToMatchingBracket", GtkSource.View.ViewMoveToMatchingBracketSignalInfo), '("moveViewport", Gtk.TextView.TextViewMoveViewportSignalInfo), '("moveWords", GtkSource.View.ViewMoveWordsSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("pasteClipboard", Gtk.TextView.TextViewPasteClipboardSignalInfo), '("populatePopup", Gtk.TextView.TextViewPopulatePopupSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("preeditChanged", Gtk.TextView.TextViewPreeditChangedSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("redo", GtkSource.View.ViewRedoSignalInfo), '("remove", Gtk.Container.ContainerRemoveSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectAll", Gtk.TextView.TextViewSelectAllSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("setAnchor", Gtk.TextView.TextViewSetAnchorSignalInfo), '("setFocusChild", Gtk.Container.ContainerSetFocusChildSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showCompletion", GtkSource.View.ViewShowCompletionSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("smartHomeEnd", GtkSource.View.ViewSmartHomeEndSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("toggleCursorVisible", Gtk.TextView.TextViewToggleCursorVisibleSignalInfo), '("toggleOverwrite", Gtk.TextView.TextViewToggleOverwriteSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("undo", GtkSource.View.ViewUndoSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Map::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Map"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_map_new" gtk_source_map_new :: + IO (Ptr Map) + +{- | +Creates a new 'GI.GtkSource.Objects.Map.Map'. + +/Since: 3.18/ +-} +mapNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m Map + {- ^ __Returns:__ a new 'GI.GtkSource.Objects.Map.Map'. -} +mapNew = liftIO $ do + result <- gtk_source_map_new + checkUnexpectedReturnNULL "mapNew" result + result' <- (newObject Map) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Map::get_view +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "map", argType = TInterface (Name {namespace = "GtkSource", name = "Map"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceMap.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "View"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_map_get_view" gtk_source_map_get_view :: + Ptr Map -> -- map : TInterface (Name {namespace = "GtkSource", name = "Map"}) + IO (Ptr GtkSource.View.View) + +{- | +Gets the 'GI.GtkSource.Objects.Map.Map':@/view/@ property, which is the view this widget is mapping. + +/Since: 3.18/ +-} +mapGetView :: + (B.CallStack.HasCallStack, MonadIO m, IsMap a) => + a + {- ^ /@map@/: a 'GI.GtkSource.Objects.Map.Map'. -} + -> m (Maybe GtkSource.View.View) + {- ^ __Returns:__ a 'GI.GtkSource.Objects.View.View' or 'Nothing'. -} +mapGetView map_ = liftIO $ do + map_' <- unsafeManagedPtrCastPtr map_ + result <- gtk_source_map_get_view map_' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject GtkSource.View.View) result' + return result'' + touchManagedPtr map_ + return maybeResult + +#if ENABLE_OVERLOADING +data MapGetViewMethodInfo +instance (signature ~ (m (Maybe GtkSource.View.View)), MonadIO m, IsMap a) => O.MethodInfo MapGetViewMethodInfo a signature where + overloadedMethod _ = mapGetView + +#endif + +-- method Map::set_view +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "map", argType = TInterface (Name {namespace = "GtkSource", name = "Map"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceMap", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView", 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_map_set_view" gtk_source_map_set_view :: + Ptr Map -> -- map : TInterface (Name {namespace = "GtkSource", name = "Map"}) + Ptr GtkSource.View.View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + IO () + +{- | +Sets the view that /@map@/ will be doing the mapping to. + +/Since: 3.18/ +-} +mapSetView :: + (B.CallStack.HasCallStack, MonadIO m, IsMap a, GtkSource.View.IsView b) => + a + {- ^ /@map@/: a 'GI.GtkSource.Objects.Map.Map' -} + -> b + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View' -} + -> m () +mapSetView map_ view = liftIO $ do + map_' <- unsafeManagedPtrCastPtr map_ + view' <- unsafeManagedPtrCastPtr view + gtk_source_map_set_view map_' view' + touchManagedPtr map_ + touchManagedPtr view + return () + +#if ENABLE_OVERLOADING +data MapSetViewMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsMap a, GtkSource.View.IsView b) => O.MethodInfo MapSetViewMethodInfo a signature where + overloadedMethod _ = mapSetView + +#endif + + diff --git a/GI/GtkSource/Objects/Map.hs-boot b/GI/GtkSource/Objects/Map.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/Map.hs-boot @@ -0,0 +1,41 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.Map 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 Map = Map (ManagedPtr Map) +instance GObject Map where +class (GObject o, O.IsDescendantOf Map o) => IsMap o +instance (GObject o, O.IsDescendantOf Map o) => IsMap o +instance O.HasParentTypes Map +#if ENABLE_OVERLOADING +data MapFontDescPropertyInfo +#endif +#if ENABLE_OVERLOADING +data MapViewPropertyInfo +#endif +#if ENABLE_OVERLOADING +data MapGetViewMethodInfo +#endif +#if ENABLE_OVERLOADING +data MapSetViewMethodInfo +#endif diff --git a/GI/GtkSource/Objects/Mark.hs b/GI/GtkSource/Objects/Mark.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/Mark.hs @@ -0,0 +1,402 @@ + + +{- | +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.Mark + ( + +-- * Exported types + Mark(..) , + IsMark , + toMark , + noMark , + + + -- * Methods +-- ** getCategory #method:getCategory# + +#if ENABLE_OVERLOADING + MarkGetCategoryMethodInfo , +#endif + markGetCategory , + + +-- ** new #method:new# + + markNew , + + +-- ** next #method:next# + +#if ENABLE_OVERLOADING + MarkNextMethodInfo , +#endif + markNext , + + +-- ** prev #method:prev# + +#if ENABLE_OVERLOADING + MarkPrevMethodInfo , +#endif + markPrev , + + + + + -- * Properties +-- ** category #attr:category# +{- | The category of the 'GI.GtkSource.Objects.Mark.Mark', classifies the mark and controls +which pixbuf is used and with which priority it is drawn. +-} +#if ENABLE_OVERLOADING + MarkCategoryPropertyInfo , +#endif + constructMarkCategory , + getMarkCategory , +#if ENABLE_OVERLOADING + markCategory , +#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 qualified GI.Gtk.Objects.TextMark as Gtk.TextMark + +-- | Memory-managed wrapper type. +newtype Mark = Mark (ManagedPtr Mark) +foreign import ccall "gtk_source_mark_get_type" + c_gtk_source_mark_get_type :: IO GType + +instance GObject Mark where + gobjectType = c_gtk_source_mark_get_type + + +-- | Type class for types which can be safely cast to `Mark`, for instance with `toMark`. +class (GObject o, O.IsDescendantOf Mark o) => IsMark o +instance (GObject o, O.IsDescendantOf Mark o) => IsMark o + +instance O.HasParentTypes Mark +type instance O.ParentTypes Mark = '[Gtk.TextMark.TextMark, GObject.Object.Object] + +-- | Cast to `Mark`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toMark :: (MonadIO m, IsMark o) => o -> m Mark +toMark = liftIO . unsafeCastTo Mark + +-- | A convenience alias for `Nothing` :: `Maybe` `Mark`. +noMark :: Maybe Mark +noMark = Nothing + +#if ENABLE_OVERLOADING +type family ResolveMarkMethod (t :: Symbol) (o :: *) :: * where + ResolveMarkMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveMarkMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveMarkMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveMarkMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveMarkMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveMarkMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveMarkMethod "next" o = MarkNextMethodInfo + ResolveMarkMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveMarkMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveMarkMethod "prev" o = MarkPrevMethodInfo + ResolveMarkMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveMarkMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveMarkMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveMarkMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveMarkMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveMarkMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveMarkMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveMarkMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveMarkMethod "getBuffer" o = Gtk.TextMark.TextMarkGetBufferMethodInfo + ResolveMarkMethod "getCategory" o = MarkGetCategoryMethodInfo + ResolveMarkMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveMarkMethod "getDeleted" o = Gtk.TextMark.TextMarkGetDeletedMethodInfo + ResolveMarkMethod "getLeftGravity" o = Gtk.TextMark.TextMarkGetLeftGravityMethodInfo + ResolveMarkMethod "getName" o = Gtk.TextMark.TextMarkGetNameMethodInfo + ResolveMarkMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveMarkMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveMarkMethod "getVisible" o = Gtk.TextMark.TextMarkGetVisibleMethodInfo + ResolveMarkMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveMarkMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveMarkMethod "setVisible" o = Gtk.TextMark.TextMarkSetVisibleMethodInfo + ResolveMarkMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveMarkMethod t Mark, O.MethodInfo info Mark p) => OL.IsLabel t (Mark -> 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 + +-- VVV Prop "category" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@category@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' mark #category +@ +-} +getMarkCategory :: (MonadIO m, IsMark o) => o -> m T.Text +getMarkCategory obj = liftIO $ checkUnexpectedNothing "getMarkCategory" $ B.Properties.getObjectPropertyString obj "category" + +{- | +Construct a `GValueConstruct` with valid value for the “@category@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructMarkCategory :: (IsMark o) => T.Text -> IO (GValueConstruct o) +constructMarkCategory val = B.Properties.constructObjectPropertyString "category" (Just val) + +#if ENABLE_OVERLOADING +data MarkCategoryPropertyInfo +instance AttrInfo MarkCategoryPropertyInfo where + type AttrAllowedOps MarkCategoryPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint MarkCategoryPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint MarkCategoryPropertyInfo = IsMark + type AttrGetType MarkCategoryPropertyInfo = T.Text + type AttrLabel MarkCategoryPropertyInfo = "category" + type AttrOrigin MarkCategoryPropertyInfo = Mark + attrGet _ = getMarkCategory + attrSet _ = undefined + attrConstruct _ = constructMarkCategory + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Mark +type instance O.AttributeList Mark = MarkAttributeList +type MarkAttributeList = ('[ '("category", MarkCategoryPropertyInfo), '("leftGravity", Gtk.TextMark.TextMarkLeftGravityPropertyInfo), '("name", Gtk.TextMark.TextMarkNamePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +markCategory :: AttrLabelProxy "category" +markCategory = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Mark = MarkSignalList +type MarkSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Mark::new +-- method type : Constructor +-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of the #GtkSourceMark, can be NULL when not using a name", 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 "is used to classify marks according to common characteristics\n(e.g. all the marks representing a bookmark could belong to the \"bookmark\"\ncategory, or all the marks representing a compilation error could belong to\n\"error\" category).", 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_mark_new" gtk_source_mark_new :: + CString -> -- name : TBasicType TUTF8 + CString -> -- category : TBasicType TUTF8 + IO (Ptr Mark) + +{- | +Creates a text mark. Add it to a buffer using 'GI.Gtk.Objects.TextBuffer.textBufferAddMark'. +If name is NULL, the mark is anonymous; otherwise, the mark can be retrieved +by name using 'GI.Gtk.Objects.TextBuffer.textBufferGetMark'. +Normally marks are created using the utility function +'GI.GtkSource.Objects.Buffer.bufferCreateSourceMark'. + +/Since: 2.2/ +-} +markNew :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@name@/: Name of the 'GI.GtkSource.Objects.Mark.Mark', can be NULL when not using a name -} + -> T.Text + {- ^ /@category@/: is used to classify marks according to common characteristics +(e.g. all the marks representing a bookmark could belong to the \"bookmark\" +category, or all the marks representing a compilation error could belong to +\"error\" category). -} + -> m Mark + {- ^ __Returns:__ a new 'GI.GtkSource.Objects.Mark.Mark' that can be added using 'GI.Gtk.Objects.TextBuffer.textBufferAddMark'. -} +markNew name category = liftIO $ do + name' <- textToCString name + category' <- textToCString category + result <- gtk_source_mark_new name' category' + checkUnexpectedReturnNULL "markNew" result + result' <- (wrapObject Mark) result + freeMem name' + freeMem category' + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Mark::get_category +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "mark", argType = TInterface (Name {namespace = "GtkSource", name = "Mark"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceMark.", 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_mark_get_category" gtk_source_mark_get_category :: + Ptr Mark -> -- mark : TInterface (Name {namespace = "GtkSource", name = "Mark"}) + IO CString + +{- | +Returns the mark category. + +/Since: 2.2/ +-} +markGetCategory :: + (B.CallStack.HasCallStack, MonadIO m, IsMark a) => + a + {- ^ /@mark@/: a 'GI.GtkSource.Objects.Mark.Mark'. -} + -> m T.Text + {- ^ __Returns:__ the category of the 'GI.GtkSource.Objects.Mark.Mark'. -} +markGetCategory mark = liftIO $ do + mark' <- unsafeManagedPtrCastPtr mark + result <- gtk_source_mark_get_category mark' + checkUnexpectedReturnNULL "markGetCategory" result + result' <- cstringToText result + touchManagedPtr mark + return result' + +#if ENABLE_OVERLOADING +data MarkGetCategoryMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsMark a) => O.MethodInfo MarkGetCategoryMethodInfo a signature where + overloadedMethod _ = markGetCategory + +#endif + +-- method Mark::next +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "mark", argType = TInterface (Name {namespace = "GtkSource", name = "Mark"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceMark.", 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 "a string specifying the mark category, or %NULL.", 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_mark_next" gtk_source_mark_next :: + Ptr Mark -> -- mark : TInterface (Name {namespace = "GtkSource", name = "Mark"}) + CString -> -- category : TBasicType TUTF8 + IO (Ptr Mark) + +{- | +Returns the next 'GI.GtkSource.Objects.Mark.Mark' in the buffer or 'Nothing' if the mark +was not added to a buffer. If there is no next mark, 'Nothing' will be returned. + +If /@category@/ is 'Nothing', looks for marks of any category. + +/Since: 2.2/ +-} +markNext :: + (B.CallStack.HasCallStack, MonadIO m, IsMark a) => + a + {- ^ /@mark@/: a 'GI.GtkSource.Objects.Mark.Mark'. -} + -> Maybe (T.Text) + {- ^ /@category@/: a string specifying the mark category, or 'Nothing'. -} + -> m (Maybe Mark) + {- ^ __Returns:__ the next 'GI.GtkSource.Objects.Mark.Mark', or 'Nothing'. -} +markNext mark category = liftIO $ do + mark' <- unsafeManagedPtrCastPtr mark + maybeCategory <- case category of + Nothing -> return nullPtr + Just jCategory -> do + jCategory' <- textToCString jCategory + return jCategory' + result <- gtk_source_mark_next mark' maybeCategory + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject Mark) result' + return result'' + touchManagedPtr mark + freeMem maybeCategory + return maybeResult + +#if ENABLE_OVERLOADING +data MarkNextMethodInfo +instance (signature ~ (Maybe (T.Text) -> m (Maybe Mark)), MonadIO m, IsMark a) => O.MethodInfo MarkNextMethodInfo a signature where + overloadedMethod _ = markNext + +#endif + +-- method Mark::prev +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "mark", argType = TInterface (Name {namespace = "GtkSource", name = "Mark"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceMark.", 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 specifying the mark category, or %NULL.", 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_mark_prev" gtk_source_mark_prev :: + Ptr Mark -> -- mark : TInterface (Name {namespace = "GtkSource", name = "Mark"}) + CString -> -- category : TBasicType TUTF8 + IO (Ptr Mark) + +{- | +Returns the previous 'GI.GtkSource.Objects.Mark.Mark' in the buffer or 'Nothing' if the mark +was not added to a buffer. If there is no previous mark, 'Nothing' is returned. + +If /@category@/ is 'Nothing', looks for marks of any category + +/Since: 2.2/ +-} +markPrev :: + (B.CallStack.HasCallStack, MonadIO m, IsMark a) => + a + {- ^ /@mark@/: a 'GI.GtkSource.Objects.Mark.Mark'. -} + -> T.Text + {- ^ /@category@/: a string specifying the mark category, or 'Nothing'. -} + -> m (Maybe Mark) + {- ^ __Returns:__ the previous 'GI.GtkSource.Objects.Mark.Mark', or 'Nothing'. -} +markPrev mark category = liftIO $ do + mark' <- unsafeManagedPtrCastPtr mark + category' <- textToCString category + result <- gtk_source_mark_prev mark' category' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject Mark) result' + return result'' + touchManagedPtr mark + freeMem category' + return maybeResult + +#if ENABLE_OVERLOADING +data MarkPrevMethodInfo +instance (signature ~ (T.Text -> m (Maybe Mark)), MonadIO m, IsMark a) => O.MethodInfo MarkPrevMethodInfo a signature where + overloadedMethod _ = markPrev + +#endif + + diff --git a/GI/GtkSource/Objects/Mark.hs-boot b/GI/GtkSource/Objects/Mark.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/Mark.hs-boot @@ -0,0 +1,41 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.Mark 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 Mark = Mark (ManagedPtr Mark) +instance GObject Mark where +class (GObject o, O.IsDescendantOf Mark o) => IsMark o +instance (GObject o, O.IsDescendantOf Mark o) => IsMark o +instance O.HasParentTypes Mark +#if ENABLE_OVERLOADING +data MarkCategoryPropertyInfo +#endif +#if ENABLE_OVERLOADING +data MarkGetCategoryMethodInfo +#endif +#if ENABLE_OVERLOADING +data MarkNextMethodInfo +#endif +#if ENABLE_OVERLOADING +data MarkPrevMethodInfo +#endif diff --git a/GI/GtkSource/Objects/MarkAttributes.hs b/GI/GtkSource/Objects/MarkAttributes.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/MarkAttributes.hs @@ -0,0 +1,1324 @@ + + +{- | +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.MarkAttributes + ( + +-- * Exported types + MarkAttributes(..) , + IsMarkAttributes , + toMarkAttributes , + noMarkAttributes , + + + -- * Methods +-- ** getBackground #method:getBackground# + +#if ENABLE_OVERLOADING + MarkAttributesGetBackgroundMethodInfo , +#endif + markAttributesGetBackground , + + +-- ** getGicon #method:getGicon# + +#if ENABLE_OVERLOADING + MarkAttributesGetGiconMethodInfo , +#endif + markAttributesGetGicon , + + +-- ** getIconName #method:getIconName# + +#if ENABLE_OVERLOADING + MarkAttributesGetIconNameMethodInfo , +#endif + markAttributesGetIconName , + + +-- ** getPixbuf #method:getPixbuf# + +#if ENABLE_OVERLOADING + MarkAttributesGetPixbufMethodInfo , +#endif + markAttributesGetPixbuf , + + +-- ** getStockId #method:getStockId# + +#if ENABLE_OVERLOADING + MarkAttributesGetStockIdMethodInfo , +#endif + markAttributesGetStockId , + + +-- ** getTooltipMarkup #method:getTooltipMarkup# + +#if ENABLE_OVERLOADING + MarkAttributesGetTooltipMarkupMethodInfo, +#endif + markAttributesGetTooltipMarkup , + + +-- ** getTooltipText #method:getTooltipText# + +#if ENABLE_OVERLOADING + MarkAttributesGetTooltipTextMethodInfo , +#endif + markAttributesGetTooltipText , + + +-- ** new #method:new# + + markAttributesNew , + + +-- ** renderIcon #method:renderIcon# + +#if ENABLE_OVERLOADING + MarkAttributesRenderIconMethodInfo , +#endif + markAttributesRenderIcon , + + +-- ** setBackground #method:setBackground# + +#if ENABLE_OVERLOADING + MarkAttributesSetBackgroundMethodInfo , +#endif + markAttributesSetBackground , + + +-- ** setGicon #method:setGicon# + +#if ENABLE_OVERLOADING + MarkAttributesSetGiconMethodInfo , +#endif + markAttributesSetGicon , + + +-- ** setIconName #method:setIconName# + +#if ENABLE_OVERLOADING + MarkAttributesSetIconNameMethodInfo , +#endif + markAttributesSetIconName , + + +-- ** setPixbuf #method:setPixbuf# + +#if ENABLE_OVERLOADING + MarkAttributesSetPixbufMethodInfo , +#endif + markAttributesSetPixbuf , + + +-- ** setStockId #method:setStockId# + +#if ENABLE_OVERLOADING + MarkAttributesSetStockIdMethodInfo , +#endif + markAttributesSetStockId , + + + + + -- * Properties +-- ** background #attr:background# +{- | A color used for background of a line. +-} +#if ENABLE_OVERLOADING + MarkAttributesBackgroundPropertyInfo , +#endif + constructMarkAttributesBackground , + getMarkAttributesBackground , +#if ENABLE_OVERLOADING + markAttributesBackground , +#endif + setMarkAttributesBackground , + + +-- ** gicon #attr:gicon# +{- | A 'GI.Gio.Interfaces.Icon.Icon' that may be a base of a rendered icon. +-} +#if ENABLE_OVERLOADING + MarkAttributesGiconPropertyInfo , +#endif + constructMarkAttributesGicon , + getMarkAttributesGicon , +#if ENABLE_OVERLOADING + markAttributesGicon , +#endif + setMarkAttributesGicon , + + +-- ** iconName #attr:iconName# +{- | An icon name that may be a base of a rendered icon. +-} +#if ENABLE_OVERLOADING + MarkAttributesIconNamePropertyInfo , +#endif + constructMarkAttributesIconName , + getMarkAttributesIconName , +#if ENABLE_OVERLOADING + markAttributesIconName , +#endif + setMarkAttributesIconName , + + +-- ** pixbuf #attr:pixbuf# +{- | A 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' that may be a base of a rendered icon. +-} +#if ENABLE_OVERLOADING + MarkAttributesPixbufPropertyInfo , +#endif + constructMarkAttributesPixbuf , + getMarkAttributesPixbuf , +#if ENABLE_OVERLOADING + markAttributesPixbuf , +#endif + setMarkAttributesPixbuf , + + +-- ** stockId #attr:stockId# +{- | A stock id that may be a base of a rendered icon. +-} +#if ENABLE_OVERLOADING + MarkAttributesStockIdPropertyInfo , +#endif + constructMarkAttributesStockId , + getMarkAttributesStockId , +#if ENABLE_OVERLOADING + markAttributesStockId , +#endif + setMarkAttributesStockId , + + + + + -- * Signals +-- ** queryTooltipMarkup #signal:queryTooltipMarkup# + + C_MarkAttributesQueryTooltipMarkupCallback, + MarkAttributesQueryTooltipMarkupCallback, +#if ENABLE_OVERLOADING + MarkAttributesQueryTooltipMarkupSignalInfo, +#endif + afterMarkAttributesQueryTooltipMarkup , + genClosure_MarkAttributesQueryTooltipMarkup, + mk_MarkAttributesQueryTooltipMarkupCallback, + noMarkAttributesQueryTooltipMarkupCallback, + onMarkAttributesQueryTooltipMarkup , + wrap_MarkAttributesQueryTooltipMarkupCallback, + + +-- ** queryTooltipText #signal:queryTooltipText# + + C_MarkAttributesQueryTooltipTextCallback, + MarkAttributesQueryTooltipTextCallback , +#if ENABLE_OVERLOADING + MarkAttributesQueryTooltipTextSignalInfo, +#endif + afterMarkAttributesQueryTooltipText , + genClosure_MarkAttributesQueryTooltipText, + mk_MarkAttributesQueryTooltipTextCallback, + noMarkAttributesQueryTooltipTextCallback, + onMarkAttributesQueryTooltipText , + wrap_MarkAttributesQueryTooltipTextCallback, + + + + + ) 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.Gdk.Structs.RGBA as Gdk.RGBA +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 {-# SOURCE #-} qualified GI.GtkSource.Objects.Mark as GtkSource.Mark + +-- | Memory-managed wrapper type. +newtype MarkAttributes = MarkAttributes (ManagedPtr MarkAttributes) +foreign import ccall "gtk_source_mark_attributes_get_type" + c_gtk_source_mark_attributes_get_type :: IO GType + +instance GObject MarkAttributes where + gobjectType = c_gtk_source_mark_attributes_get_type + + +-- | Type class for types which can be safely cast to `MarkAttributes`, for instance with `toMarkAttributes`. +class (GObject o, O.IsDescendantOf MarkAttributes o) => IsMarkAttributes o +instance (GObject o, O.IsDescendantOf MarkAttributes o) => IsMarkAttributes o + +instance O.HasParentTypes MarkAttributes +type instance O.ParentTypes MarkAttributes = '[GObject.Object.Object] + +-- | Cast to `MarkAttributes`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toMarkAttributes :: (MonadIO m, IsMarkAttributes o) => o -> m MarkAttributes +toMarkAttributes = liftIO . unsafeCastTo MarkAttributes + +-- | A convenience alias for `Nothing` :: `Maybe` `MarkAttributes`. +noMarkAttributes :: Maybe MarkAttributes +noMarkAttributes = Nothing + +#if ENABLE_OVERLOADING +type family ResolveMarkAttributesMethod (t :: Symbol) (o :: *) :: * where + ResolveMarkAttributesMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveMarkAttributesMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveMarkAttributesMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveMarkAttributesMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveMarkAttributesMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveMarkAttributesMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveMarkAttributesMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveMarkAttributesMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveMarkAttributesMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveMarkAttributesMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveMarkAttributesMethod "renderIcon" o = MarkAttributesRenderIconMethodInfo + ResolveMarkAttributesMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveMarkAttributesMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveMarkAttributesMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveMarkAttributesMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveMarkAttributesMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveMarkAttributesMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveMarkAttributesMethod "getBackground" o = MarkAttributesGetBackgroundMethodInfo + ResolveMarkAttributesMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveMarkAttributesMethod "getGicon" o = MarkAttributesGetGiconMethodInfo + ResolveMarkAttributesMethod "getIconName" o = MarkAttributesGetIconNameMethodInfo + ResolveMarkAttributesMethod "getPixbuf" o = MarkAttributesGetPixbufMethodInfo + ResolveMarkAttributesMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveMarkAttributesMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveMarkAttributesMethod "getStockId" o = MarkAttributesGetStockIdMethodInfo + ResolveMarkAttributesMethod "getTooltipMarkup" o = MarkAttributesGetTooltipMarkupMethodInfo + ResolveMarkAttributesMethod "getTooltipText" o = MarkAttributesGetTooltipTextMethodInfo + ResolveMarkAttributesMethod "setBackground" o = MarkAttributesSetBackgroundMethodInfo + ResolveMarkAttributesMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveMarkAttributesMethod "setGicon" o = MarkAttributesSetGiconMethodInfo + ResolveMarkAttributesMethod "setIconName" o = MarkAttributesSetIconNameMethodInfo + ResolveMarkAttributesMethod "setPixbuf" o = MarkAttributesSetPixbufMethodInfo + ResolveMarkAttributesMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveMarkAttributesMethod "setStockId" o = MarkAttributesSetStockIdMethodInfo + ResolveMarkAttributesMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveMarkAttributesMethod t MarkAttributes, O.MethodInfo info MarkAttributes p) => OL.IsLabel t (MarkAttributes -> 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 MarkAttributes::query-tooltip-markup +{- | +The code should connect to this signal to provide a tooltip for given +/@mark@/. The tooltip can contain a markup. +-} +type MarkAttributesQueryTooltipMarkupCallback = + GtkSource.Mark.Mark + {- ^ /@mark@/: The 'GI.GtkSource.Objects.Mark.Mark'. -} + -> IO T.Text + {- ^ __Returns:__ A tooltip. The string should be freed with +'GI.GLib.Functions.free' when done with it. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `MarkAttributesQueryTooltipMarkupCallback`@. +noMarkAttributesQueryTooltipMarkupCallback :: Maybe MarkAttributesQueryTooltipMarkupCallback +noMarkAttributesQueryTooltipMarkupCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_MarkAttributesQueryTooltipMarkupCallback = + Ptr () -> -- object + Ptr GtkSource.Mark.Mark -> + Ptr () -> -- user_data + IO CString + +-- | Generate a function pointer callable from C code, from a `C_MarkAttributesQueryTooltipMarkupCallback`. +foreign import ccall "wrapper" + mk_MarkAttributesQueryTooltipMarkupCallback :: C_MarkAttributesQueryTooltipMarkupCallback -> IO (FunPtr C_MarkAttributesQueryTooltipMarkupCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_MarkAttributesQueryTooltipMarkup :: MonadIO m => MarkAttributesQueryTooltipMarkupCallback -> m (GClosure C_MarkAttributesQueryTooltipMarkupCallback) +genClosure_MarkAttributesQueryTooltipMarkup cb = liftIO $ do + let cb' = wrap_MarkAttributesQueryTooltipMarkupCallback cb + mk_MarkAttributesQueryTooltipMarkupCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `MarkAttributesQueryTooltipMarkupCallback` into a `C_MarkAttributesQueryTooltipMarkupCallback`. +wrap_MarkAttributesQueryTooltipMarkupCallback :: + MarkAttributesQueryTooltipMarkupCallback -> + C_MarkAttributesQueryTooltipMarkupCallback +wrap_MarkAttributesQueryTooltipMarkupCallback _cb _ mark _ = do + mark' <- (newObject GtkSource.Mark.Mark) mark + result <- _cb mark' + result' <- textToCString result + return result' + + +{- | +Connect a signal handler for the “@query-tooltip-markup@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' markAttributes #queryTooltipMarkup callback +@ +-} +onMarkAttributesQueryTooltipMarkup :: (IsMarkAttributes a, MonadIO m) => a -> MarkAttributesQueryTooltipMarkupCallback -> m SignalHandlerId +onMarkAttributesQueryTooltipMarkup obj cb = liftIO $ do + let cb' = wrap_MarkAttributesQueryTooltipMarkupCallback cb + cb'' <- mk_MarkAttributesQueryTooltipMarkupCallback cb' + connectSignalFunPtr obj "query-tooltip-markup" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@query-tooltip-markup@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' markAttributes #queryTooltipMarkup callback +@ +-} +afterMarkAttributesQueryTooltipMarkup :: (IsMarkAttributes a, MonadIO m) => a -> MarkAttributesQueryTooltipMarkupCallback -> m SignalHandlerId +afterMarkAttributesQueryTooltipMarkup obj cb = liftIO $ do + let cb' = wrap_MarkAttributesQueryTooltipMarkupCallback cb + cb'' <- mk_MarkAttributesQueryTooltipMarkupCallback cb' + connectSignalFunPtr obj "query-tooltip-markup" cb'' SignalConnectAfter + + +-- signal MarkAttributes::query-tooltip-text +{- | +The code should connect to this signal to provide a tooltip for given +/@mark@/. The tooltip should be just a plain text. +-} +type MarkAttributesQueryTooltipTextCallback = + GtkSource.Mark.Mark + {- ^ /@mark@/: The 'GI.GtkSource.Objects.Mark.Mark'. -} + -> IO T.Text + {- ^ __Returns:__ A tooltip. The string should be freed with +'GI.GLib.Functions.free' when done with it. -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `MarkAttributesQueryTooltipTextCallback`@. +noMarkAttributesQueryTooltipTextCallback :: Maybe MarkAttributesQueryTooltipTextCallback +noMarkAttributesQueryTooltipTextCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_MarkAttributesQueryTooltipTextCallback = + Ptr () -> -- object + Ptr GtkSource.Mark.Mark -> + Ptr () -> -- user_data + IO CString + +-- | Generate a function pointer callable from C code, from a `C_MarkAttributesQueryTooltipTextCallback`. +foreign import ccall "wrapper" + mk_MarkAttributesQueryTooltipTextCallback :: C_MarkAttributesQueryTooltipTextCallback -> IO (FunPtr C_MarkAttributesQueryTooltipTextCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_MarkAttributesQueryTooltipText :: MonadIO m => MarkAttributesQueryTooltipTextCallback -> m (GClosure C_MarkAttributesQueryTooltipTextCallback) +genClosure_MarkAttributesQueryTooltipText cb = liftIO $ do + let cb' = wrap_MarkAttributesQueryTooltipTextCallback cb + mk_MarkAttributesQueryTooltipTextCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `MarkAttributesQueryTooltipTextCallback` into a `C_MarkAttributesQueryTooltipTextCallback`. +wrap_MarkAttributesQueryTooltipTextCallback :: + MarkAttributesQueryTooltipTextCallback -> + C_MarkAttributesQueryTooltipTextCallback +wrap_MarkAttributesQueryTooltipTextCallback _cb _ mark _ = do + mark' <- (newObject GtkSource.Mark.Mark) mark + result <- _cb mark' + result' <- textToCString result + return result' + + +{- | +Connect a signal handler for the “@query-tooltip-text@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' markAttributes #queryTooltipText callback +@ +-} +onMarkAttributesQueryTooltipText :: (IsMarkAttributes a, MonadIO m) => a -> MarkAttributesQueryTooltipTextCallback -> m SignalHandlerId +onMarkAttributesQueryTooltipText obj cb = liftIO $ do + let cb' = wrap_MarkAttributesQueryTooltipTextCallback cb + cb'' <- mk_MarkAttributesQueryTooltipTextCallback cb' + connectSignalFunPtr obj "query-tooltip-text" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@query-tooltip-text@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' markAttributes #queryTooltipText callback +@ +-} +afterMarkAttributesQueryTooltipText :: (IsMarkAttributes a, MonadIO m) => a -> MarkAttributesQueryTooltipTextCallback -> m SignalHandlerId +afterMarkAttributesQueryTooltipText obj cb = liftIO $ do + let cb' = wrap_MarkAttributesQueryTooltipTextCallback cb + cb'' <- mk_MarkAttributesQueryTooltipTextCallback cb' + connectSignalFunPtr obj "query-tooltip-text" cb'' SignalConnectAfter + + +-- VVV Prop "background" + -- Type: TInterface (Name {namespace = "Gdk", name = "RGBA"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Just False) + +{- | +Get the value of the “@background@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' markAttributes #background +@ +-} +getMarkAttributesBackground :: (MonadIO m, IsMarkAttributes o) => o -> m (Maybe Gdk.RGBA.RGBA) +getMarkAttributesBackground obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "background" Gdk.RGBA.RGBA + +{- | +Set the value of the “@background@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' markAttributes [ #background 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setMarkAttributesBackground :: (MonadIO m, IsMarkAttributes o) => o -> Gdk.RGBA.RGBA -> m () +setMarkAttributesBackground obj val = liftIO $ B.Properties.setObjectPropertyBoxed obj "background" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@background@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructMarkAttributesBackground :: (IsMarkAttributes o) => Gdk.RGBA.RGBA -> IO (GValueConstruct o) +constructMarkAttributesBackground val = B.Properties.constructObjectPropertyBoxed "background" (Just val) + +#if ENABLE_OVERLOADING +data MarkAttributesBackgroundPropertyInfo +instance AttrInfo MarkAttributesBackgroundPropertyInfo where + type AttrAllowedOps MarkAttributesBackgroundPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint MarkAttributesBackgroundPropertyInfo = (~) Gdk.RGBA.RGBA + type AttrBaseTypeConstraint MarkAttributesBackgroundPropertyInfo = IsMarkAttributes + type AttrGetType MarkAttributesBackgroundPropertyInfo = (Maybe Gdk.RGBA.RGBA) + type AttrLabel MarkAttributesBackgroundPropertyInfo = "background" + type AttrOrigin MarkAttributesBackgroundPropertyInfo = MarkAttributes + attrGet _ = getMarkAttributesBackground + attrSet _ = setMarkAttributesBackground + attrConstruct _ = constructMarkAttributesBackground + attrClear _ = undefined +#endif + +-- VVV Prop "gicon" + -- Type: TInterface (Name {namespace = "Gio", name = "Icon"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@gicon@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' markAttributes #gicon +@ +-} +getMarkAttributesGicon :: (MonadIO m, IsMarkAttributes o) => o -> m Gio.Icon.Icon +getMarkAttributesGicon obj = liftIO $ checkUnexpectedNothing "getMarkAttributesGicon" $ B.Properties.getObjectPropertyObject obj "gicon" Gio.Icon.Icon + +{- | +Set the value of the “@gicon@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' markAttributes [ #gicon 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setMarkAttributesGicon :: (MonadIO m, IsMarkAttributes o, Gio.Icon.IsIcon a) => o -> a -> m () +setMarkAttributesGicon obj val = liftIO $ B.Properties.setObjectPropertyObject obj "gicon" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@gicon@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructMarkAttributesGicon :: (IsMarkAttributes o, Gio.Icon.IsIcon a) => a -> IO (GValueConstruct o) +constructMarkAttributesGicon val = B.Properties.constructObjectPropertyObject "gicon" (Just val) + +#if ENABLE_OVERLOADING +data MarkAttributesGiconPropertyInfo +instance AttrInfo MarkAttributesGiconPropertyInfo where + type AttrAllowedOps MarkAttributesGiconPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint MarkAttributesGiconPropertyInfo = Gio.Icon.IsIcon + type AttrBaseTypeConstraint MarkAttributesGiconPropertyInfo = IsMarkAttributes + type AttrGetType MarkAttributesGiconPropertyInfo = Gio.Icon.Icon + type AttrLabel MarkAttributesGiconPropertyInfo = "gicon" + type AttrOrigin MarkAttributesGiconPropertyInfo = MarkAttributes + attrGet _ = getMarkAttributesGicon + attrSet _ = setMarkAttributesGicon + attrConstruct _ = constructMarkAttributesGicon + attrClear _ = undefined +#endif + +-- VVV Prop "icon-name" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@icon-name@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' markAttributes #iconName +@ +-} +getMarkAttributesIconName :: (MonadIO m, IsMarkAttributes o) => o -> m T.Text +getMarkAttributesIconName obj = liftIO $ checkUnexpectedNothing "getMarkAttributesIconName" $ B.Properties.getObjectPropertyString obj "icon-name" + +{- | +Set the value of the “@icon-name@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' markAttributes [ #iconName 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setMarkAttributesIconName :: (MonadIO m, IsMarkAttributes o) => o -> T.Text -> m () +setMarkAttributesIconName obj val = liftIO $ B.Properties.setObjectPropertyString obj "icon-name" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@icon-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructMarkAttributesIconName :: (IsMarkAttributes o) => T.Text -> IO (GValueConstruct o) +constructMarkAttributesIconName val = B.Properties.constructObjectPropertyString "icon-name" (Just val) + +#if ENABLE_OVERLOADING +data MarkAttributesIconNamePropertyInfo +instance AttrInfo MarkAttributesIconNamePropertyInfo where + type AttrAllowedOps MarkAttributesIconNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint MarkAttributesIconNamePropertyInfo = (~) T.Text + type AttrBaseTypeConstraint MarkAttributesIconNamePropertyInfo = IsMarkAttributes + type AttrGetType MarkAttributesIconNamePropertyInfo = T.Text + type AttrLabel MarkAttributesIconNamePropertyInfo = "icon-name" + type AttrOrigin MarkAttributesIconNamePropertyInfo = MarkAttributes + attrGet _ = getMarkAttributesIconName + attrSet _ = setMarkAttributesIconName + attrConstruct _ = constructMarkAttributesIconName + attrClear _ = undefined +#endif + +-- VVV Prop "pixbuf" + -- Type: TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@pixbuf@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' markAttributes #pixbuf +@ +-} +getMarkAttributesPixbuf :: (MonadIO m, IsMarkAttributes o) => o -> m GdkPixbuf.Pixbuf.Pixbuf +getMarkAttributesPixbuf obj = liftIO $ checkUnexpectedNothing "getMarkAttributesPixbuf" $ B.Properties.getObjectPropertyObject obj "pixbuf" GdkPixbuf.Pixbuf.Pixbuf + +{- | +Set the value of the “@pixbuf@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' markAttributes [ #pixbuf 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setMarkAttributesPixbuf :: (MonadIO m, IsMarkAttributes o, GdkPixbuf.Pixbuf.IsPixbuf a) => o -> a -> m () +setMarkAttributesPixbuf obj val = liftIO $ B.Properties.setObjectPropertyObject obj "pixbuf" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@pixbuf@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructMarkAttributesPixbuf :: (IsMarkAttributes o, GdkPixbuf.Pixbuf.IsPixbuf a) => a -> IO (GValueConstruct o) +constructMarkAttributesPixbuf val = B.Properties.constructObjectPropertyObject "pixbuf" (Just val) + +#if ENABLE_OVERLOADING +data MarkAttributesPixbufPropertyInfo +instance AttrInfo MarkAttributesPixbufPropertyInfo where + type AttrAllowedOps MarkAttributesPixbufPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint MarkAttributesPixbufPropertyInfo = GdkPixbuf.Pixbuf.IsPixbuf + type AttrBaseTypeConstraint MarkAttributesPixbufPropertyInfo = IsMarkAttributes + type AttrGetType MarkAttributesPixbufPropertyInfo = GdkPixbuf.Pixbuf.Pixbuf + type AttrLabel MarkAttributesPixbufPropertyInfo = "pixbuf" + type AttrOrigin MarkAttributesPixbufPropertyInfo = MarkAttributes + attrGet _ = getMarkAttributesPixbuf + attrSet _ = setMarkAttributesPixbuf + attrConstruct _ = constructMarkAttributesPixbuf + attrClear _ = undefined +#endif + +-- VVV Prop "stock-id" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@stock-id@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' markAttributes #stockId +@ +-} +getMarkAttributesStockId :: (MonadIO m, IsMarkAttributes o) => o -> m T.Text +getMarkAttributesStockId obj = liftIO $ checkUnexpectedNothing "getMarkAttributesStockId" $ B.Properties.getObjectPropertyString obj "stock-id" + +{- | +Set the value of the “@stock-id@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' markAttributes [ #stockId 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setMarkAttributesStockId :: (MonadIO m, IsMarkAttributes o) => o -> T.Text -> m () +setMarkAttributesStockId obj val = liftIO $ B.Properties.setObjectPropertyString obj "stock-id" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@stock-id@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructMarkAttributesStockId :: (IsMarkAttributes o) => T.Text -> IO (GValueConstruct o) +constructMarkAttributesStockId val = B.Properties.constructObjectPropertyString "stock-id" (Just val) + +#if ENABLE_OVERLOADING +data MarkAttributesStockIdPropertyInfo +instance AttrInfo MarkAttributesStockIdPropertyInfo where + type AttrAllowedOps MarkAttributesStockIdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint MarkAttributesStockIdPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint MarkAttributesStockIdPropertyInfo = IsMarkAttributes + type AttrGetType MarkAttributesStockIdPropertyInfo = T.Text + type AttrLabel MarkAttributesStockIdPropertyInfo = "stock-id" + type AttrOrigin MarkAttributesStockIdPropertyInfo = MarkAttributes + attrGet _ = getMarkAttributesStockId + attrSet _ = setMarkAttributesStockId + attrConstruct _ = constructMarkAttributesStockId + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList MarkAttributes +type instance O.AttributeList MarkAttributes = MarkAttributesAttributeList +type MarkAttributesAttributeList = ('[ '("background", MarkAttributesBackgroundPropertyInfo), '("gicon", MarkAttributesGiconPropertyInfo), '("iconName", MarkAttributesIconNamePropertyInfo), '("pixbuf", MarkAttributesPixbufPropertyInfo), '("stockId", MarkAttributesStockIdPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +markAttributesBackground :: AttrLabelProxy "background" +markAttributesBackground = AttrLabelProxy + +markAttributesGicon :: AttrLabelProxy "gicon" +markAttributesGicon = AttrLabelProxy + +markAttributesIconName :: AttrLabelProxy "iconName" +markAttributesIconName = AttrLabelProxy + +markAttributesPixbuf :: AttrLabelProxy "pixbuf" +markAttributesPixbuf = AttrLabelProxy + +markAttributesStockId :: AttrLabelProxy "stockId" +markAttributesStockId = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +data MarkAttributesQueryTooltipMarkupSignalInfo +instance SignalInfo MarkAttributesQueryTooltipMarkupSignalInfo where + type HaskellCallbackType MarkAttributesQueryTooltipMarkupSignalInfo = MarkAttributesQueryTooltipMarkupCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_MarkAttributesQueryTooltipMarkupCallback cb + cb'' <- mk_MarkAttributesQueryTooltipMarkupCallback cb' + connectSignalFunPtr obj "query-tooltip-markup" cb'' connectMode + +data MarkAttributesQueryTooltipTextSignalInfo +instance SignalInfo MarkAttributesQueryTooltipTextSignalInfo where + type HaskellCallbackType MarkAttributesQueryTooltipTextSignalInfo = MarkAttributesQueryTooltipTextCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_MarkAttributesQueryTooltipTextCallback cb + cb'' <- mk_MarkAttributesQueryTooltipTextCallback cb' + connectSignalFunPtr obj "query-tooltip-text" cb'' connectMode + +type instance O.SignalList MarkAttributes = MarkAttributesSignalList +type MarkAttributesSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo), '("queryTooltipMarkup", MarkAttributesQueryTooltipMarkupSignalInfo), '("queryTooltipText", MarkAttributesQueryTooltipTextSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method MarkAttributes::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_mark_attributes_new" gtk_source_mark_attributes_new :: + IO (Ptr MarkAttributes) + +{- | +Creates a new source mark attributes. +-} +markAttributesNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m MarkAttributes + {- ^ __Returns:__ a new source mark attributes. -} +markAttributesNew = liftIO $ do + result <- gtk_source_mark_attributes_new + checkUnexpectedReturnNULL "markAttributesNew" result + result' <- (wrapObject MarkAttributes) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method MarkAttributes::get_background +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "attributes", argType = TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceMarkAttributes.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "background", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRGBA.", 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_mark_attributes_get_background" gtk_source_mark_attributes_get_background :: + Ptr MarkAttributes -> -- attributes : TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}) + Ptr Gdk.RGBA.RGBA -> -- background : TInterface (Name {namespace = "Gdk", name = "RGBA"}) + IO CInt + +{- | +Stores background color in /@background@/. +-} +markAttributesGetBackground :: + (B.CallStack.HasCallStack, MonadIO m, IsMarkAttributes a) => + a + {- ^ /@attributes@/: a 'GI.GtkSource.Objects.MarkAttributes.MarkAttributes'. -} + -> m ((Bool, Gdk.RGBA.RGBA)) + {- ^ __Returns:__ whether background color for /@attributes@/ was set. -} +markAttributesGetBackground attributes = liftIO $ do + attributes' <- unsafeManagedPtrCastPtr attributes + background <- callocBoxedBytes 32 :: IO (Ptr Gdk.RGBA.RGBA) + result <- gtk_source_mark_attributes_get_background attributes' background + let result' = (/= 0) result + background' <- (wrapBoxed Gdk.RGBA.RGBA) background + touchManagedPtr attributes + return (result', background') + +#if ENABLE_OVERLOADING +data MarkAttributesGetBackgroundMethodInfo +instance (signature ~ (m ((Bool, Gdk.RGBA.RGBA))), MonadIO m, IsMarkAttributes a) => O.MethodInfo MarkAttributesGetBackgroundMethodInfo a signature where + overloadedMethod _ = markAttributesGetBackground + +#endif + +-- method MarkAttributes::get_gicon +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "attributes", argType = TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceMarkAttributes.", 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_mark_attributes_get_gicon" gtk_source_mark_attributes_get_gicon :: + Ptr MarkAttributes -> -- attributes : TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}) + IO (Ptr Gio.Icon.Icon) + +{- | +Gets a 'GI.Gio.Interfaces.Icon.Icon' to be used as a base for rendered icon. Note that the icon can +be 'Nothing' if it wasn\'t set earlier. +-} +markAttributesGetGicon :: + (B.CallStack.HasCallStack, MonadIO m, IsMarkAttributes a) => + a + {- ^ /@attributes@/: a 'GI.GtkSource.Objects.MarkAttributes.MarkAttributes'. -} + -> m Gio.Icon.Icon + {- ^ __Returns:__ An icon. The icon belongs to /@attributes@/ and should +not be unreffed. -} +markAttributesGetGicon attributes = liftIO $ do + attributes' <- unsafeManagedPtrCastPtr attributes + result <- gtk_source_mark_attributes_get_gicon attributes' + checkUnexpectedReturnNULL "markAttributesGetGicon" result + result' <- (newObject Gio.Icon.Icon) result + touchManagedPtr attributes + return result' + +#if ENABLE_OVERLOADING +data MarkAttributesGetGiconMethodInfo +instance (signature ~ (m Gio.Icon.Icon), MonadIO m, IsMarkAttributes a) => O.MethodInfo MarkAttributesGetGiconMethodInfo a signature where + overloadedMethod _ = markAttributesGetGicon + +#endif + +-- method MarkAttributes::get_icon_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "attributes", argType = TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceMarkAttributes.", 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_mark_attributes_get_icon_name" gtk_source_mark_attributes_get_icon_name :: + Ptr MarkAttributes -> -- attributes : TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}) + IO CString + +{- | +Gets a name of an icon to be used as a base for rendered icon. Note that the +icon name can be 'Nothing' if it wasn\'t set earlier. +-} +markAttributesGetIconName :: + (B.CallStack.HasCallStack, MonadIO m, IsMarkAttributes a) => + a + {- ^ /@attributes@/: a 'GI.GtkSource.Objects.MarkAttributes.MarkAttributes'. -} + -> m T.Text + {- ^ __Returns:__ An icon name. The string belongs to /@attributes@/ and +should not be freed. -} +markAttributesGetIconName attributes = liftIO $ do + attributes' <- unsafeManagedPtrCastPtr attributes + result <- gtk_source_mark_attributes_get_icon_name attributes' + checkUnexpectedReturnNULL "markAttributesGetIconName" result + result' <- cstringToText result + touchManagedPtr attributes + return result' + +#if ENABLE_OVERLOADING +data MarkAttributesGetIconNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsMarkAttributes a) => O.MethodInfo MarkAttributesGetIconNameMethodInfo a signature where + overloadedMethod _ = markAttributesGetIconName + +#endif + +-- method MarkAttributes::get_pixbuf +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "attributes", argType = TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceMarkAttributes.", 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_mark_attributes_get_pixbuf" gtk_source_mark_attributes_get_pixbuf :: + Ptr MarkAttributes -> -- attributes : TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}) + IO (Ptr GdkPixbuf.Pixbuf.Pixbuf) + +{- | +Gets a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' to be used as a base for rendered icon. Note that the +pixbuf can be 'Nothing' if it wasn\'t set earlier. +-} +markAttributesGetPixbuf :: + (B.CallStack.HasCallStack, MonadIO m, IsMarkAttributes a) => + a + {- ^ /@attributes@/: a 'GI.GtkSource.Objects.MarkAttributes.MarkAttributes'. -} + -> m GdkPixbuf.Pixbuf.Pixbuf + {- ^ __Returns:__ A pixbuf. The pixbuf belongs to /@attributes@/ and +should not be unreffed. -} +markAttributesGetPixbuf attributes = liftIO $ do + attributes' <- unsafeManagedPtrCastPtr attributes + result <- gtk_source_mark_attributes_get_pixbuf attributes' + checkUnexpectedReturnNULL "markAttributesGetPixbuf" result + result' <- (newObject GdkPixbuf.Pixbuf.Pixbuf) result + touchManagedPtr attributes + return result' + +#if ENABLE_OVERLOADING +data MarkAttributesGetPixbufMethodInfo +instance (signature ~ (m GdkPixbuf.Pixbuf.Pixbuf), MonadIO m, IsMarkAttributes a) => O.MethodInfo MarkAttributesGetPixbufMethodInfo a signature where + overloadedMethod _ = markAttributesGetPixbuf + +#endif + +-- method MarkAttributes::get_stock_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "attributes", argType = TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceMarkAttributes.", 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_mark_attributes_get_stock_id" gtk_source_mark_attributes_get_stock_id :: + Ptr MarkAttributes -> -- attributes : TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}) + IO CString + +{-# DEPRECATED markAttributesGetStockId ["(Since version 3.10)","Don\\'t use this function."] #-} +{- | +Gets a stock id of an icon used by this attributes. Note that the stock id can +be 'Nothing' if it wasn\'t set earlier. +-} +markAttributesGetStockId :: + (B.CallStack.HasCallStack, MonadIO m, IsMarkAttributes a) => + a + {- ^ /@attributes@/: a 'GI.GtkSource.Objects.MarkAttributes.MarkAttributes'. -} + -> m T.Text + {- ^ __Returns:__ Stock id. Returned string is owned by /@attributes@/ and +shouldn\'t be freed. -} +markAttributesGetStockId attributes = liftIO $ do + attributes' <- unsafeManagedPtrCastPtr attributes + result <- gtk_source_mark_attributes_get_stock_id attributes' + checkUnexpectedReturnNULL "markAttributesGetStockId" result + result' <- cstringToText result + touchManagedPtr attributes + return result' + +#if ENABLE_OVERLOADING +data MarkAttributesGetStockIdMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsMarkAttributes a) => O.MethodInfo MarkAttributesGetStockIdMethodInfo a signature where + overloadedMethod _ = markAttributesGetStockId + +#endif + +-- method MarkAttributes::get_tooltip_markup +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "attributes", argType = TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceMarkAttributes.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mark", argType = TInterface (Name {namespace = "GtkSource", name = "Mark"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceMark.", 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_mark_attributes_get_tooltip_markup" gtk_source_mark_attributes_get_tooltip_markup :: + Ptr MarkAttributes -> -- attributes : TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}) + Ptr GtkSource.Mark.Mark -> -- mark : TInterface (Name {namespace = "GtkSource", name = "Mark"}) + IO CString + +{- | +Queries for a tooltip by emitting +a 'GI.GtkSource.Objects.MarkAttributes.MarkAttributes'::@/query-tooltip-markup/@ signal. The tooltip may contain +a markup. +-} +markAttributesGetTooltipMarkup :: + (B.CallStack.HasCallStack, MonadIO m, IsMarkAttributes a, GtkSource.Mark.IsMark b) => + a + {- ^ /@attributes@/: a 'GI.GtkSource.Objects.MarkAttributes.MarkAttributes'. -} + -> b + {- ^ /@mark@/: a 'GI.GtkSource.Objects.Mark.Mark'. -} + -> m T.Text + {- ^ __Returns:__ A tooltip. The returned string should be freed by +using 'GI.GLib.Functions.free' when done with it. -} +markAttributesGetTooltipMarkup attributes mark = liftIO $ do + attributes' <- unsafeManagedPtrCastPtr attributes + mark' <- unsafeManagedPtrCastPtr mark + result <- gtk_source_mark_attributes_get_tooltip_markup attributes' mark' + checkUnexpectedReturnNULL "markAttributesGetTooltipMarkup" result + result' <- cstringToText result + freeMem result + touchManagedPtr attributes + touchManagedPtr mark + return result' + +#if ENABLE_OVERLOADING +data MarkAttributesGetTooltipMarkupMethodInfo +instance (signature ~ (b -> m T.Text), MonadIO m, IsMarkAttributes a, GtkSource.Mark.IsMark b) => O.MethodInfo MarkAttributesGetTooltipMarkupMethodInfo a signature where + overloadedMethod _ = markAttributesGetTooltipMarkup + +#endif + +-- method MarkAttributes::get_tooltip_text +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "attributes", argType = TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceMarkAttributes.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mark", argType = TInterface (Name {namespace = "GtkSource", name = "Mark"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceMark.", 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_mark_attributes_get_tooltip_text" gtk_source_mark_attributes_get_tooltip_text :: + Ptr MarkAttributes -> -- attributes : TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}) + Ptr GtkSource.Mark.Mark -> -- mark : TInterface (Name {namespace = "GtkSource", name = "Mark"}) + IO CString + +{- | +Queries for a tooltip by emitting +a 'GI.GtkSource.Objects.MarkAttributes.MarkAttributes'::@/query-tooltip-text/@ signal. The tooltip is a plain +text. +-} +markAttributesGetTooltipText :: + (B.CallStack.HasCallStack, MonadIO m, IsMarkAttributes a, GtkSource.Mark.IsMark b) => + a + {- ^ /@attributes@/: a 'GI.GtkSource.Objects.MarkAttributes.MarkAttributes'. -} + -> b + {- ^ /@mark@/: a 'GI.GtkSource.Objects.Mark.Mark'. -} + -> m T.Text + {- ^ __Returns:__ A tooltip. The returned string should be freed by +using 'GI.GLib.Functions.free' when done with it. -} +markAttributesGetTooltipText attributes mark = liftIO $ do + attributes' <- unsafeManagedPtrCastPtr attributes + mark' <- unsafeManagedPtrCastPtr mark + result <- gtk_source_mark_attributes_get_tooltip_text attributes' mark' + checkUnexpectedReturnNULL "markAttributesGetTooltipText" result + result' <- cstringToText result + freeMem result + touchManagedPtr attributes + touchManagedPtr mark + return result' + +#if ENABLE_OVERLOADING +data MarkAttributesGetTooltipTextMethodInfo +instance (signature ~ (b -> m T.Text), MonadIO m, IsMarkAttributes a, GtkSource.Mark.IsMark b) => O.MethodInfo MarkAttributesGetTooltipTextMethodInfo a signature where + overloadedMethod _ = markAttributesGetTooltipText + +#endif + +-- method MarkAttributes::render_icon +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "attributes", argType = TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceMarkAttributes.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "widget of which style settings may be used.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "size of the rendered icon.", 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_mark_attributes_render_icon" gtk_source_mark_attributes_render_icon :: + Ptr MarkAttributes -> -- attributes : TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}) + Ptr Gtk.Widget.Widget -> -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"}) + Int32 -> -- size : TBasicType TInt + IO (Ptr GdkPixbuf.Pixbuf.Pixbuf) + +{- | +Renders an icon of given size. The base of the icon is set by the last call +to one of: 'GI.GtkSource.Objects.MarkAttributes.markAttributesSetPixbuf', +'GI.GtkSource.Objects.MarkAttributes.markAttributesSetGicon', +'GI.GtkSource.Objects.MarkAttributes.markAttributesSetIconName' or +'GI.GtkSource.Objects.MarkAttributes.markAttributesSetStockId'. /@size@/ cannot be lower than 1. +-} +markAttributesRenderIcon :: + (B.CallStack.HasCallStack, MonadIO m, IsMarkAttributes a, Gtk.Widget.IsWidget b) => + a + {- ^ /@attributes@/: a 'GI.GtkSource.Objects.MarkAttributes.MarkAttributes'. -} + -> b + {- ^ /@widget@/: widget of which style settings may be used. -} + -> Int32 + {- ^ /@size@/: size of the rendered icon. -} + -> m GdkPixbuf.Pixbuf.Pixbuf + {- ^ __Returns:__ A rendered pixbuf. The pixbuf belongs to /@attributes@/ +and should not be unreffed. -} +markAttributesRenderIcon attributes widget size = liftIO $ do + attributes' <- unsafeManagedPtrCastPtr attributes + widget' <- unsafeManagedPtrCastPtr widget + result <- gtk_source_mark_attributes_render_icon attributes' widget' size + checkUnexpectedReturnNULL "markAttributesRenderIcon" result + result' <- (newObject GdkPixbuf.Pixbuf.Pixbuf) result + touchManagedPtr attributes + touchManagedPtr widget + return result' + +#if ENABLE_OVERLOADING +data MarkAttributesRenderIconMethodInfo +instance (signature ~ (b -> Int32 -> m GdkPixbuf.Pixbuf.Pixbuf), MonadIO m, IsMarkAttributes a, Gtk.Widget.IsWidget b) => O.MethodInfo MarkAttributesRenderIconMethodInfo a signature where + overloadedMethod _ = markAttributesRenderIcon + +#endif + +-- method MarkAttributes::set_background +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "attributes", argType = TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceMarkAttributes.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "background", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRGBA.", 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_mark_attributes_set_background" gtk_source_mark_attributes_set_background :: + Ptr MarkAttributes -> -- attributes : TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}) + Ptr Gdk.RGBA.RGBA -> -- background : TInterface (Name {namespace = "Gdk", name = "RGBA"}) + IO () + +{- | +Sets background color to the one given in /@background@/. +-} +markAttributesSetBackground :: + (B.CallStack.HasCallStack, MonadIO m, IsMarkAttributes a) => + a + {- ^ /@attributes@/: a 'GI.GtkSource.Objects.MarkAttributes.MarkAttributes'. -} + -> Gdk.RGBA.RGBA + {- ^ /@background@/: a 'GI.Gdk.Structs.RGBA.RGBA'. -} + -> m () +markAttributesSetBackground attributes background = liftIO $ do + attributes' <- unsafeManagedPtrCastPtr attributes + background' <- unsafeManagedPtrGetPtr background + gtk_source_mark_attributes_set_background attributes' background' + touchManagedPtr attributes + touchManagedPtr background + return () + +#if ENABLE_OVERLOADING +data MarkAttributesSetBackgroundMethodInfo +instance (signature ~ (Gdk.RGBA.RGBA -> m ()), MonadIO m, IsMarkAttributes a) => O.MethodInfo MarkAttributesSetBackgroundMethodInfo a signature where + overloadedMethod _ = markAttributesSetBackground + +#endif + +-- method MarkAttributes::set_gicon +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "attributes", argType = TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceMarkAttributes.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gicon", argType = TInterface (Name {namespace = "Gio", name = "Icon"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIcon to be used.", 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_mark_attributes_set_gicon" gtk_source_mark_attributes_set_gicon :: + Ptr MarkAttributes -> -- attributes : TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}) + Ptr Gio.Icon.Icon -> -- gicon : TInterface (Name {namespace = "Gio", name = "Icon"}) + IO () + +{- | +Sets an icon to be used as a base for rendered icon. +-} +markAttributesSetGicon :: + (B.CallStack.HasCallStack, MonadIO m, IsMarkAttributes a, Gio.Icon.IsIcon b) => + a + {- ^ /@attributes@/: a 'GI.GtkSource.Objects.MarkAttributes.MarkAttributes'. -} + -> b + {- ^ /@gicon@/: a 'GI.Gio.Interfaces.Icon.Icon' to be used. -} + -> m () +markAttributesSetGicon attributes gicon = liftIO $ do + attributes' <- unsafeManagedPtrCastPtr attributes + gicon' <- unsafeManagedPtrCastPtr gicon + gtk_source_mark_attributes_set_gicon attributes' gicon' + touchManagedPtr attributes + touchManagedPtr gicon + return () + +#if ENABLE_OVERLOADING +data MarkAttributesSetGiconMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsMarkAttributes a, Gio.Icon.IsIcon b) => O.MethodInfo MarkAttributesSetGiconMethodInfo a signature where + overloadedMethod _ = markAttributesSetGicon + +#endif + +-- method MarkAttributes::set_icon_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "attributes", argType = TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceMarkAttributes.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "icon_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of an icon to be used.", 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_mark_attributes_set_icon_name" gtk_source_mark_attributes_set_icon_name :: + Ptr MarkAttributes -> -- attributes : TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}) + CString -> -- icon_name : TBasicType TUTF8 + IO () + +{- | +Sets a name of an icon to be used as a base for rendered icon. +-} +markAttributesSetIconName :: + (B.CallStack.HasCallStack, MonadIO m, IsMarkAttributes a) => + a + {- ^ /@attributes@/: a 'GI.GtkSource.Objects.MarkAttributes.MarkAttributes'. -} + -> T.Text + {- ^ /@iconName@/: name of an icon to be used. -} + -> m () +markAttributesSetIconName attributes iconName = liftIO $ do + attributes' <- unsafeManagedPtrCastPtr attributes + iconName' <- textToCString iconName + gtk_source_mark_attributes_set_icon_name attributes' iconName' + touchManagedPtr attributes + freeMem iconName' + return () + +#if ENABLE_OVERLOADING +data MarkAttributesSetIconNameMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsMarkAttributes a) => O.MethodInfo MarkAttributesSetIconNameMethodInfo a signature where + overloadedMethod _ = markAttributesSetIconName + +#endif + +-- method MarkAttributes::set_pixbuf +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "attributes", argType = TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceMarkAttributes.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkPixbuf to be used.", 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_mark_attributes_set_pixbuf" gtk_source_mark_attributes_set_pixbuf :: + Ptr MarkAttributes -> -- attributes : TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}) + Ptr GdkPixbuf.Pixbuf.Pixbuf -> -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}) + IO () + +{- | +Sets a pixbuf to be used as a base for rendered icon. +-} +markAttributesSetPixbuf :: + (B.CallStack.HasCallStack, MonadIO m, IsMarkAttributes a, GdkPixbuf.Pixbuf.IsPixbuf b) => + a + {- ^ /@attributes@/: a 'GI.GtkSource.Objects.MarkAttributes.MarkAttributes'. -} + -> b + {- ^ /@pixbuf@/: a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' to be used. -} + -> m () +markAttributesSetPixbuf attributes pixbuf = liftIO $ do + attributes' <- unsafeManagedPtrCastPtr attributes + pixbuf' <- unsafeManagedPtrCastPtr pixbuf + gtk_source_mark_attributes_set_pixbuf attributes' pixbuf' + touchManagedPtr attributes + touchManagedPtr pixbuf + return () + +#if ENABLE_OVERLOADING +data MarkAttributesSetPixbufMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsMarkAttributes a, GdkPixbuf.Pixbuf.IsPixbuf b) => O.MethodInfo MarkAttributesSetPixbufMethodInfo a signature where + overloadedMethod _ = markAttributesSetPixbuf + +#endif + +-- method MarkAttributes::set_stock_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "attributes", argType = TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceMarkAttributes.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a stock id.", 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_mark_attributes_set_stock_id" gtk_source_mark_attributes_set_stock_id :: + Ptr MarkAttributes -> -- attributes : TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}) + CString -> -- stock_id : TBasicType TUTF8 + IO () + +{-# DEPRECATED markAttributesSetStockId ["(Since version 3.10)","Don\\'t use this function."] #-} +{- | +Sets stock id to be used as a base for rendered icon. +-} +markAttributesSetStockId :: + (B.CallStack.HasCallStack, MonadIO m, IsMarkAttributes a) => + a + {- ^ /@attributes@/: a 'GI.GtkSource.Objects.MarkAttributes.MarkAttributes'. -} + -> T.Text + {- ^ /@stockId@/: a stock id. -} + -> m () +markAttributesSetStockId attributes stockId = liftIO $ do + attributes' <- unsafeManagedPtrCastPtr attributes + stockId' <- textToCString stockId + gtk_source_mark_attributes_set_stock_id attributes' stockId' + touchManagedPtr attributes + freeMem stockId' + return () + +#if ENABLE_OVERLOADING +data MarkAttributesSetStockIdMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsMarkAttributes a) => O.MethodInfo MarkAttributesSetStockIdMethodInfo a signature where + overloadedMethod _ = markAttributesSetStockId + +#endif + + diff --git a/GI/GtkSource/Objects/MarkAttributes.hs-boot b/GI/GtkSource/Objects/MarkAttributes.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/MarkAttributes.hs-boot @@ -0,0 +1,89 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.MarkAttributes 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 MarkAttributes = MarkAttributes (ManagedPtr MarkAttributes) +instance GObject MarkAttributes where +class (GObject o, O.IsDescendantOf MarkAttributes o) => IsMarkAttributes o +instance (GObject o, O.IsDescendantOf MarkAttributes o) => IsMarkAttributes o +instance O.HasParentTypes MarkAttributes +#if ENABLE_OVERLOADING +data MarkAttributesBackgroundPropertyInfo +#endif +#if ENABLE_OVERLOADING +data MarkAttributesGiconPropertyInfo +#endif +#if ENABLE_OVERLOADING +data MarkAttributesIconNamePropertyInfo +#endif +#if ENABLE_OVERLOADING +data MarkAttributesPixbufPropertyInfo +#endif +#if ENABLE_OVERLOADING +data MarkAttributesStockIdPropertyInfo +#endif +#if ENABLE_OVERLOADING +data MarkAttributesQueryTooltipMarkupSignalInfo +#endif +#if ENABLE_OVERLOADING +data MarkAttributesQueryTooltipTextSignalInfo +#endif +#if ENABLE_OVERLOADING +data MarkAttributesGetBackgroundMethodInfo +#endif +#if ENABLE_OVERLOADING +data MarkAttributesGetGiconMethodInfo +#endif +#if ENABLE_OVERLOADING +data MarkAttributesGetIconNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data MarkAttributesGetPixbufMethodInfo +#endif +#if ENABLE_OVERLOADING +data MarkAttributesGetStockIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data MarkAttributesGetTooltipMarkupMethodInfo +#endif +#if ENABLE_OVERLOADING +data MarkAttributesGetTooltipTextMethodInfo +#endif +#if ENABLE_OVERLOADING +data MarkAttributesRenderIconMethodInfo +#endif +#if ENABLE_OVERLOADING +data MarkAttributesSetBackgroundMethodInfo +#endif +#if ENABLE_OVERLOADING +data MarkAttributesSetGiconMethodInfo +#endif +#if ENABLE_OVERLOADING +data MarkAttributesSetIconNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data MarkAttributesSetPixbufMethodInfo +#endif +#if ENABLE_OVERLOADING +data MarkAttributesSetStockIdMethodInfo +#endif diff --git a/GI/GtkSource/Objects/PrintCompositor.hs b/GI/GtkSource/Objects/PrintCompositor.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/PrintCompositor.hs @@ -0,0 +1,3042 @@ + + +{- | +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.PrintCompositor + ( + +-- * Exported types + PrintCompositor(..) , + IsPrintCompositor , + toPrintCompositor , + noPrintCompositor , + + + -- * Methods +-- ** drawPage #method:drawPage# + +#if ENABLE_OVERLOADING + PrintCompositorDrawPageMethodInfo , +#endif + printCompositorDrawPage , + + +-- ** getBodyFontName #method:getBodyFontName# + +#if ENABLE_OVERLOADING + PrintCompositorGetBodyFontNameMethodInfo, +#endif + printCompositorGetBodyFontName , + + +-- ** getBottomMargin #method:getBottomMargin# + +#if ENABLE_OVERLOADING + PrintCompositorGetBottomMarginMethodInfo, +#endif + printCompositorGetBottomMargin , + + +-- ** getBuffer #method:getBuffer# + +#if ENABLE_OVERLOADING + PrintCompositorGetBufferMethodInfo , +#endif + printCompositorGetBuffer , + + +-- ** getFooterFontName #method:getFooterFontName# + +#if ENABLE_OVERLOADING + PrintCompositorGetFooterFontNameMethodInfo, +#endif + printCompositorGetFooterFontName , + + +-- ** getHeaderFontName #method:getHeaderFontName# + +#if ENABLE_OVERLOADING + PrintCompositorGetHeaderFontNameMethodInfo, +#endif + printCompositorGetHeaderFontName , + + +-- ** getHighlightSyntax #method:getHighlightSyntax# + +#if ENABLE_OVERLOADING + PrintCompositorGetHighlightSyntaxMethodInfo, +#endif + printCompositorGetHighlightSyntax , + + +-- ** getLeftMargin #method:getLeftMargin# + +#if ENABLE_OVERLOADING + PrintCompositorGetLeftMarginMethodInfo , +#endif + printCompositorGetLeftMargin , + + +-- ** getLineNumbersFontName #method:getLineNumbersFontName# + +#if ENABLE_OVERLOADING + PrintCompositorGetLineNumbersFontNameMethodInfo, +#endif + printCompositorGetLineNumbersFontName , + + +-- ** getNPages #method:getNPages# + +#if ENABLE_OVERLOADING + PrintCompositorGetNPagesMethodInfo , +#endif + printCompositorGetNPages , + + +-- ** getPaginationProgress #method:getPaginationProgress# + +#if ENABLE_OVERLOADING + PrintCompositorGetPaginationProgressMethodInfo, +#endif + printCompositorGetPaginationProgress , + + +-- ** getPrintFooter #method:getPrintFooter# + +#if ENABLE_OVERLOADING + PrintCompositorGetPrintFooterMethodInfo , +#endif + printCompositorGetPrintFooter , + + +-- ** getPrintHeader #method:getPrintHeader# + +#if ENABLE_OVERLOADING + PrintCompositorGetPrintHeaderMethodInfo , +#endif + printCompositorGetPrintHeader , + + +-- ** getPrintLineNumbers #method:getPrintLineNumbers# + +#if ENABLE_OVERLOADING + PrintCompositorGetPrintLineNumbersMethodInfo, +#endif + printCompositorGetPrintLineNumbers , + + +-- ** getRightMargin #method:getRightMargin# + +#if ENABLE_OVERLOADING + PrintCompositorGetRightMarginMethodInfo , +#endif + printCompositorGetRightMargin , + + +-- ** getTabWidth #method:getTabWidth# + +#if ENABLE_OVERLOADING + PrintCompositorGetTabWidthMethodInfo , +#endif + printCompositorGetTabWidth , + + +-- ** getTopMargin #method:getTopMargin# + +#if ENABLE_OVERLOADING + PrintCompositorGetTopMarginMethodInfo , +#endif + printCompositorGetTopMargin , + + +-- ** getWrapMode #method:getWrapMode# + +#if ENABLE_OVERLOADING + PrintCompositorGetWrapModeMethodInfo , +#endif + printCompositorGetWrapMode , + + +-- ** new #method:new# + + printCompositorNew , + + +-- ** newFromView #method:newFromView# + + printCompositorNewFromView , + + +-- ** paginate #method:paginate# + +#if ENABLE_OVERLOADING + PrintCompositorPaginateMethodInfo , +#endif + printCompositorPaginate , + + +-- ** setBodyFontName #method:setBodyFontName# + +#if ENABLE_OVERLOADING + PrintCompositorSetBodyFontNameMethodInfo, +#endif + printCompositorSetBodyFontName , + + +-- ** setBottomMargin #method:setBottomMargin# + +#if ENABLE_OVERLOADING + PrintCompositorSetBottomMarginMethodInfo, +#endif + printCompositorSetBottomMargin , + + +-- ** setFooterFontName #method:setFooterFontName# + +#if ENABLE_OVERLOADING + PrintCompositorSetFooterFontNameMethodInfo, +#endif + printCompositorSetFooterFontName , + + +-- ** setFooterFormat #method:setFooterFormat# + +#if ENABLE_OVERLOADING + PrintCompositorSetFooterFormatMethodInfo, +#endif + printCompositorSetFooterFormat , + + +-- ** setHeaderFontName #method:setHeaderFontName# + +#if ENABLE_OVERLOADING + PrintCompositorSetHeaderFontNameMethodInfo, +#endif + printCompositorSetHeaderFontName , + + +-- ** setHeaderFormat #method:setHeaderFormat# + +#if ENABLE_OVERLOADING + PrintCompositorSetHeaderFormatMethodInfo, +#endif + printCompositorSetHeaderFormat , + + +-- ** setHighlightSyntax #method:setHighlightSyntax# + +#if ENABLE_OVERLOADING + PrintCompositorSetHighlightSyntaxMethodInfo, +#endif + printCompositorSetHighlightSyntax , + + +-- ** setLeftMargin #method:setLeftMargin# + +#if ENABLE_OVERLOADING + PrintCompositorSetLeftMarginMethodInfo , +#endif + printCompositorSetLeftMargin , + + +-- ** setLineNumbersFontName #method:setLineNumbersFontName# + +#if ENABLE_OVERLOADING + PrintCompositorSetLineNumbersFontNameMethodInfo, +#endif + printCompositorSetLineNumbersFontName , + + +-- ** setPrintFooter #method:setPrintFooter# + +#if ENABLE_OVERLOADING + PrintCompositorSetPrintFooterMethodInfo , +#endif + printCompositorSetPrintFooter , + + +-- ** setPrintHeader #method:setPrintHeader# + +#if ENABLE_OVERLOADING + PrintCompositorSetPrintHeaderMethodInfo , +#endif + printCompositorSetPrintHeader , + + +-- ** setPrintLineNumbers #method:setPrintLineNumbers# + +#if ENABLE_OVERLOADING + PrintCompositorSetPrintLineNumbersMethodInfo, +#endif + printCompositorSetPrintLineNumbers , + + +-- ** setRightMargin #method:setRightMargin# + +#if ENABLE_OVERLOADING + PrintCompositorSetRightMarginMethodInfo , +#endif + printCompositorSetRightMargin , + + +-- ** setTabWidth #method:setTabWidth# + +#if ENABLE_OVERLOADING + PrintCompositorSetTabWidthMethodInfo , +#endif + printCompositorSetTabWidth , + + +-- ** setTopMargin #method:setTopMargin# + +#if ENABLE_OVERLOADING + PrintCompositorSetTopMarginMethodInfo , +#endif + printCompositorSetTopMargin , + + +-- ** setWrapMode #method:setWrapMode# + +#if ENABLE_OVERLOADING + PrintCompositorSetWrapModeMethodInfo , +#endif + printCompositorSetWrapMode , + + + + + -- * Properties +-- ** bodyFontName #attr:bodyFontName# +{- | Name of the font used for the text body. + +Accepted values are strings representing a font description Pango can understand. +(e.g. "Monospace 10"). See 'GI.Pango.Functions.fontDescriptionFromString' +for a description of the format of the string representation. + +The value of this property cannot be changed anymore after the first +call to the 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function. + +/Since: 2.2/ +-} +#if ENABLE_OVERLOADING + PrintCompositorBodyFontNamePropertyInfo , +#endif + constructPrintCompositorBodyFontName , + getPrintCompositorBodyFontName , +#if ENABLE_OVERLOADING + printCompositorBodyFontName , +#endif + setPrintCompositorBodyFontName , + + +-- ** buffer #attr:buffer# +{- | The GtkSourceBuffer object to print. + +/Since: 2.2/ +-} +#if ENABLE_OVERLOADING + PrintCompositorBufferPropertyInfo , +#endif + constructPrintCompositorBuffer , + getPrintCompositorBuffer , +#if ENABLE_OVERLOADING + printCompositorBuffer , +#endif + + +-- ** footerFontName #attr:footerFontName# +{- | Name of the font used to print page footer. +If this property is unspecified, the text body font is used. + +Accepted values are strings representing a font description Pango can understand. +(e.g. "Monospace 10"). See 'GI.Pango.Functions.fontDescriptionFromString' +for a description of the format of the string representation. + +The value of this property cannot be changed anymore after the first +call to the 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function. + +/Since: 2.2/ +-} +#if ENABLE_OVERLOADING + PrintCompositorFooterFontNamePropertyInfo, +#endif + clearPrintCompositorFooterFontName , + constructPrintCompositorFooterFontName , + getPrintCompositorFooterFontName , +#if ENABLE_OVERLOADING + printCompositorFooterFontName , +#endif + setPrintCompositorFooterFontName , + + +-- ** headerFontName #attr:headerFontName# +{- | Name of the font used to print page header. +If this property is unspecified, the text body font is used. + +Accepted values are strings representing a font description Pango can understand. +(e.g. "Monospace 10"). See 'GI.Pango.Functions.fontDescriptionFromString' +for a description of the format of the string representation. + +The value of this property cannot be changed anymore after the first +call to the 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function. + +/Since: 2.2/ +-} +#if ENABLE_OVERLOADING + PrintCompositorHeaderFontNamePropertyInfo, +#endif + clearPrintCompositorHeaderFontName , + constructPrintCompositorHeaderFontName , + getPrintCompositorHeaderFontName , +#if ENABLE_OVERLOADING + printCompositorHeaderFontName , +#endif + setPrintCompositorHeaderFontName , + + +-- ** highlightSyntax #attr:highlightSyntax# +{- | Whether to print the document with highlighted syntax. + +The value of this property cannot be changed anymore after the first +call to the 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function. + +/Since: 2.2/ +-} +#if ENABLE_OVERLOADING + PrintCompositorHighlightSyntaxPropertyInfo, +#endif + constructPrintCompositorHighlightSyntax , + getPrintCompositorHighlightSyntax , +#if ENABLE_OVERLOADING + printCompositorHighlightSyntax , +#endif + setPrintCompositorHighlightSyntax , + + +-- ** lineNumbersFontName #attr:lineNumbersFontName# +{- | Name of the font used to print line numbers on the left margin. +If this property is unspecified, the text body font is used. + +Accepted values are strings representing a font description Pango can understand. +(e.g. "Monospace 10"). See 'GI.Pango.Functions.fontDescriptionFromString' +for a description of the format of the string representation. + +The value of this property cannot be changed anymore after the first +call to the 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function. + +/Since: 2.2/ +-} +#if ENABLE_OVERLOADING + PrintCompositorLineNumbersFontNamePropertyInfo, +#endif + clearPrintCompositorLineNumbersFontName , + constructPrintCompositorLineNumbersFontName, + getPrintCompositorLineNumbersFontName , +#if ENABLE_OVERLOADING + printCompositorLineNumbersFontName , +#endif + setPrintCompositorLineNumbersFontName , + + +-- ** nPages #attr:nPages# +{- | The number of pages in the document or \-1\<\/code> if the +document has not been completely paginated. + +/Since: 2.2/ +-} +#if ENABLE_OVERLOADING + PrintCompositorNPagesPropertyInfo , +#endif + getPrintCompositorNPages , +#if ENABLE_OVERLOADING + printCompositorNPages , +#endif + + +-- ** printFooter #attr:printFooter# +{- | Whether to print a footer in each page. + +Note that by default the footer format is unspecified, and if it is +unspecified the footer will not be printed, regardless of the value of +this property. + +The value of this property cannot be changed anymore after the first +call to the 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function. + +/Since: 2.2/ +-} +#if ENABLE_OVERLOADING + PrintCompositorPrintFooterPropertyInfo , +#endif + constructPrintCompositorPrintFooter , + getPrintCompositorPrintFooter , +#if ENABLE_OVERLOADING + printCompositorPrintFooter , +#endif + setPrintCompositorPrintFooter , + + +-- ** printHeader #attr:printHeader# +{- | Whether to print a header in each page. + +Note that by default the header format is unspecified, and if it is +unspecified the header will not be printed, regardless of the value of +this property. + +The value of this property cannot be changed anymore after the first +call to the 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function. + +/Since: 2.2/ +-} +#if ENABLE_OVERLOADING + PrintCompositorPrintHeaderPropertyInfo , +#endif + constructPrintCompositorPrintHeader , + getPrintCompositorPrintHeader , +#if ENABLE_OVERLOADING + printCompositorPrintHeader , +#endif + setPrintCompositorPrintHeader , + + +-- ** printLineNumbers #attr:printLineNumbers# +{- | Interval of printed line numbers. If this property is set to 0 no +numbers will be printed. If greater than 0, a number will be +printed every \"print-line-numbers\" lines (i.e. 1 will print all line numbers). + +The value of this property cannot be changed anymore after the first +call to the 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function. + +/Since: 2.2/ +-} +#if ENABLE_OVERLOADING + PrintCompositorPrintLineNumbersPropertyInfo, +#endif + constructPrintCompositorPrintLineNumbers, + getPrintCompositorPrintLineNumbers , +#if ENABLE_OVERLOADING + printCompositorPrintLineNumbers , +#endif + setPrintCompositorPrintLineNumbers , + + +-- ** tabWidth #attr:tabWidth# +{- | Width of a tab character expressed in spaces. + +The value of this property cannot be changed anymore after the first +call to the 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function. + +/Since: 2.2/ +-} +#if ENABLE_OVERLOADING + PrintCompositorTabWidthPropertyInfo , +#endif + constructPrintCompositorTabWidth , + getPrintCompositorTabWidth , +#if ENABLE_OVERLOADING + printCompositorTabWidth , +#endif + setPrintCompositorTabWidth , + + +-- ** wrapMode #attr:wrapMode# +{- | Whether to wrap lines never, at word boundaries, or at character boundaries. + +The value of this property cannot be changed anymore after the first +call to the 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function. + +/Since: 2.2/ +-} +#if ENABLE_OVERLOADING + PrintCompositorWrapModePropertyInfo , +#endif + constructPrintCompositorWrapMode , + getPrintCompositorWrapMode , +#if ENABLE_OVERLOADING + printCompositorWrapMode , +#endif + setPrintCompositorWrapMode , + + + + + ) 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.Enums as Gtk.Enums +import qualified GI.Gtk.Objects.PrintContext as Gtk.PrintContext +import {-# SOURCE #-} qualified GI.GtkSource.Objects.Buffer as GtkSource.Buffer +import {-# SOURCE #-} qualified GI.GtkSource.Objects.View as GtkSource.View + +-- | Memory-managed wrapper type. +newtype PrintCompositor = PrintCompositor (ManagedPtr PrintCompositor) +foreign import ccall "gtk_source_print_compositor_get_type" + c_gtk_source_print_compositor_get_type :: IO GType + +instance GObject PrintCompositor where + gobjectType = c_gtk_source_print_compositor_get_type + + +-- | Type class for types which can be safely cast to `PrintCompositor`, for instance with `toPrintCompositor`. +class (GObject o, O.IsDescendantOf PrintCompositor o) => IsPrintCompositor o +instance (GObject o, O.IsDescendantOf PrintCompositor o) => IsPrintCompositor o + +instance O.HasParentTypes PrintCompositor +type instance O.ParentTypes PrintCompositor = '[GObject.Object.Object] + +-- | Cast to `PrintCompositor`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toPrintCompositor :: (MonadIO m, IsPrintCompositor o) => o -> m PrintCompositor +toPrintCompositor = liftIO . unsafeCastTo PrintCompositor + +-- | A convenience alias for `Nothing` :: `Maybe` `PrintCompositor`. +noPrintCompositor :: Maybe PrintCompositor +noPrintCompositor = Nothing + +#if ENABLE_OVERLOADING +type family ResolvePrintCompositorMethod (t :: Symbol) (o :: *) :: * where + ResolvePrintCompositorMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolvePrintCompositorMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolvePrintCompositorMethod "drawPage" o = PrintCompositorDrawPageMethodInfo + ResolvePrintCompositorMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolvePrintCompositorMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolvePrintCompositorMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolvePrintCompositorMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolvePrintCompositorMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolvePrintCompositorMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolvePrintCompositorMethod "paginate" o = PrintCompositorPaginateMethodInfo + ResolvePrintCompositorMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolvePrintCompositorMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolvePrintCompositorMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolvePrintCompositorMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolvePrintCompositorMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolvePrintCompositorMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolvePrintCompositorMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolvePrintCompositorMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolvePrintCompositorMethod "getBodyFontName" o = PrintCompositorGetBodyFontNameMethodInfo + ResolvePrintCompositorMethod "getBottomMargin" o = PrintCompositorGetBottomMarginMethodInfo + ResolvePrintCompositorMethod "getBuffer" o = PrintCompositorGetBufferMethodInfo + ResolvePrintCompositorMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolvePrintCompositorMethod "getFooterFontName" o = PrintCompositorGetFooterFontNameMethodInfo + ResolvePrintCompositorMethod "getHeaderFontName" o = PrintCompositorGetHeaderFontNameMethodInfo + ResolvePrintCompositorMethod "getHighlightSyntax" o = PrintCompositorGetHighlightSyntaxMethodInfo + ResolvePrintCompositorMethod "getLeftMargin" o = PrintCompositorGetLeftMarginMethodInfo + ResolvePrintCompositorMethod "getLineNumbersFontName" o = PrintCompositorGetLineNumbersFontNameMethodInfo + ResolvePrintCompositorMethod "getNPages" o = PrintCompositorGetNPagesMethodInfo + ResolvePrintCompositorMethod "getPaginationProgress" o = PrintCompositorGetPaginationProgressMethodInfo + ResolvePrintCompositorMethod "getPrintFooter" o = PrintCompositorGetPrintFooterMethodInfo + ResolvePrintCompositorMethod "getPrintHeader" o = PrintCompositorGetPrintHeaderMethodInfo + ResolvePrintCompositorMethod "getPrintLineNumbers" o = PrintCompositorGetPrintLineNumbersMethodInfo + ResolvePrintCompositorMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolvePrintCompositorMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolvePrintCompositorMethod "getRightMargin" o = PrintCompositorGetRightMarginMethodInfo + ResolvePrintCompositorMethod "getTabWidth" o = PrintCompositorGetTabWidthMethodInfo + ResolvePrintCompositorMethod "getTopMargin" o = PrintCompositorGetTopMarginMethodInfo + ResolvePrintCompositorMethod "getWrapMode" o = PrintCompositorGetWrapModeMethodInfo + ResolvePrintCompositorMethod "setBodyFontName" o = PrintCompositorSetBodyFontNameMethodInfo + ResolvePrintCompositorMethod "setBottomMargin" o = PrintCompositorSetBottomMarginMethodInfo + ResolvePrintCompositorMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolvePrintCompositorMethod "setFooterFontName" o = PrintCompositorSetFooterFontNameMethodInfo + ResolvePrintCompositorMethod "setFooterFormat" o = PrintCompositorSetFooterFormatMethodInfo + ResolvePrintCompositorMethod "setHeaderFontName" o = PrintCompositorSetHeaderFontNameMethodInfo + ResolvePrintCompositorMethod "setHeaderFormat" o = PrintCompositorSetHeaderFormatMethodInfo + ResolvePrintCompositorMethod "setHighlightSyntax" o = PrintCompositorSetHighlightSyntaxMethodInfo + ResolvePrintCompositorMethod "setLeftMargin" o = PrintCompositorSetLeftMarginMethodInfo + ResolvePrintCompositorMethod "setLineNumbersFontName" o = PrintCompositorSetLineNumbersFontNameMethodInfo + ResolvePrintCompositorMethod "setPrintFooter" o = PrintCompositorSetPrintFooterMethodInfo + ResolvePrintCompositorMethod "setPrintHeader" o = PrintCompositorSetPrintHeaderMethodInfo + ResolvePrintCompositorMethod "setPrintLineNumbers" o = PrintCompositorSetPrintLineNumbersMethodInfo + ResolvePrintCompositorMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolvePrintCompositorMethod "setRightMargin" o = PrintCompositorSetRightMarginMethodInfo + ResolvePrintCompositorMethod "setTabWidth" o = PrintCompositorSetTabWidthMethodInfo + ResolvePrintCompositorMethod "setTopMargin" o = PrintCompositorSetTopMarginMethodInfo + ResolvePrintCompositorMethod "setWrapMode" o = PrintCompositorSetWrapModeMethodInfo + ResolvePrintCompositorMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolvePrintCompositorMethod t PrintCompositor, O.MethodInfo info PrintCompositor p) => OL.IsLabel t (PrintCompositor -> 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 + +-- VVV Prop "body-font-name" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Just False) + +{- | +Get the value of the “@body-font-name@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' printCompositor #bodyFontName +@ +-} +getPrintCompositorBodyFontName :: (MonadIO m, IsPrintCompositor o) => o -> m (Maybe T.Text) +getPrintCompositorBodyFontName obj = liftIO $ B.Properties.getObjectPropertyString obj "body-font-name" + +{- | +Set the value of the “@body-font-name@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' printCompositor [ #bodyFontName 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setPrintCompositorBodyFontName :: (MonadIO m, IsPrintCompositor o) => o -> T.Text -> m () +setPrintCompositorBodyFontName obj val = liftIO $ B.Properties.setObjectPropertyString obj "body-font-name" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@body-font-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructPrintCompositorBodyFontName :: (IsPrintCompositor o) => T.Text -> IO (GValueConstruct o) +constructPrintCompositorBodyFontName val = B.Properties.constructObjectPropertyString "body-font-name" (Just val) + +#if ENABLE_OVERLOADING +data PrintCompositorBodyFontNamePropertyInfo +instance AttrInfo PrintCompositorBodyFontNamePropertyInfo where + type AttrAllowedOps PrintCompositorBodyFontNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint PrintCompositorBodyFontNamePropertyInfo = (~) T.Text + type AttrBaseTypeConstraint PrintCompositorBodyFontNamePropertyInfo = IsPrintCompositor + type AttrGetType PrintCompositorBodyFontNamePropertyInfo = (Maybe T.Text) + type AttrLabel PrintCompositorBodyFontNamePropertyInfo = "body-font-name" + type AttrOrigin PrintCompositorBodyFontNamePropertyInfo = PrintCompositor + attrGet _ = getPrintCompositorBodyFontName + attrSet _ = setPrintCompositorBodyFontName + attrConstruct _ = constructPrintCompositorBodyFontName + attrClear _ = undefined +#endif + +-- VVV Prop "buffer" + -- Type: TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@buffer@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' printCompositor #buffer +@ +-} +getPrintCompositorBuffer :: (MonadIO m, IsPrintCompositor o) => o -> m GtkSource.Buffer.Buffer +getPrintCompositorBuffer obj = liftIO $ checkUnexpectedNothing "getPrintCompositorBuffer" $ B.Properties.getObjectPropertyObject obj "buffer" GtkSource.Buffer.Buffer + +{- | +Construct a `GValueConstruct` with valid value for the “@buffer@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructPrintCompositorBuffer :: (IsPrintCompositor o, GtkSource.Buffer.IsBuffer a) => a -> IO (GValueConstruct o) +constructPrintCompositorBuffer val = B.Properties.constructObjectPropertyObject "buffer" (Just val) + +#if ENABLE_OVERLOADING +data PrintCompositorBufferPropertyInfo +instance AttrInfo PrintCompositorBufferPropertyInfo where + type AttrAllowedOps PrintCompositorBufferPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint PrintCompositorBufferPropertyInfo = GtkSource.Buffer.IsBuffer + type AttrBaseTypeConstraint PrintCompositorBufferPropertyInfo = IsPrintCompositor + type AttrGetType PrintCompositorBufferPropertyInfo = GtkSource.Buffer.Buffer + type AttrLabel PrintCompositorBufferPropertyInfo = "buffer" + type AttrOrigin PrintCompositorBufferPropertyInfo = PrintCompositor + attrGet _ = getPrintCompositorBuffer + attrSet _ = undefined + attrConstruct _ = constructPrintCompositorBuffer + attrClear _ = undefined +#endif + +-- VVV Prop "footer-font-name" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Just True) + +{- | +Get the value of the “@footer-font-name@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' printCompositor #footerFontName +@ +-} +getPrintCompositorFooterFontName :: (MonadIO m, IsPrintCompositor o) => o -> m (Maybe T.Text) +getPrintCompositorFooterFontName obj = liftIO $ B.Properties.getObjectPropertyString obj "footer-font-name" + +{- | +Set the value of the “@footer-font-name@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' printCompositor [ #footerFontName 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setPrintCompositorFooterFontName :: (MonadIO m, IsPrintCompositor o) => o -> T.Text -> m () +setPrintCompositorFooterFontName obj val = liftIO $ B.Properties.setObjectPropertyString obj "footer-font-name" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@footer-font-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructPrintCompositorFooterFontName :: (IsPrintCompositor o) => T.Text -> IO (GValueConstruct o) +constructPrintCompositorFooterFontName val = B.Properties.constructObjectPropertyString "footer-font-name" (Just val) + +{- | +Set the value of the “@footer-font-name@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #footerFontName +@ +-} +clearPrintCompositorFooterFontName :: (MonadIO m, IsPrintCompositor o) => o -> m () +clearPrintCompositorFooterFontName obj = liftIO $ B.Properties.setObjectPropertyString obj "footer-font-name" (Nothing :: Maybe T.Text) + +#if ENABLE_OVERLOADING +data PrintCompositorFooterFontNamePropertyInfo +instance AttrInfo PrintCompositorFooterFontNamePropertyInfo where + type AttrAllowedOps PrintCompositorFooterFontNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint PrintCompositorFooterFontNamePropertyInfo = (~) T.Text + type AttrBaseTypeConstraint PrintCompositorFooterFontNamePropertyInfo = IsPrintCompositor + type AttrGetType PrintCompositorFooterFontNamePropertyInfo = (Maybe T.Text) + type AttrLabel PrintCompositorFooterFontNamePropertyInfo = "footer-font-name" + type AttrOrigin PrintCompositorFooterFontNamePropertyInfo = PrintCompositor + attrGet _ = getPrintCompositorFooterFontName + attrSet _ = setPrintCompositorFooterFontName + attrConstruct _ = constructPrintCompositorFooterFontName + attrClear _ = clearPrintCompositorFooterFontName +#endif + +-- VVV Prop "header-font-name" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Just True) + +{- | +Get the value of the “@header-font-name@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' printCompositor #headerFontName +@ +-} +getPrintCompositorHeaderFontName :: (MonadIO m, IsPrintCompositor o) => o -> m (Maybe T.Text) +getPrintCompositorHeaderFontName obj = liftIO $ B.Properties.getObjectPropertyString obj "header-font-name" + +{- | +Set the value of the “@header-font-name@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' printCompositor [ #headerFontName 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setPrintCompositorHeaderFontName :: (MonadIO m, IsPrintCompositor o) => o -> T.Text -> m () +setPrintCompositorHeaderFontName obj val = liftIO $ B.Properties.setObjectPropertyString obj "header-font-name" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@header-font-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructPrintCompositorHeaderFontName :: (IsPrintCompositor o) => T.Text -> IO (GValueConstruct o) +constructPrintCompositorHeaderFontName val = B.Properties.constructObjectPropertyString "header-font-name" (Just val) + +{- | +Set the value of the “@header-font-name@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #headerFontName +@ +-} +clearPrintCompositorHeaderFontName :: (MonadIO m, IsPrintCompositor o) => o -> m () +clearPrintCompositorHeaderFontName obj = liftIO $ B.Properties.setObjectPropertyString obj "header-font-name" (Nothing :: Maybe T.Text) + +#if ENABLE_OVERLOADING +data PrintCompositorHeaderFontNamePropertyInfo +instance AttrInfo PrintCompositorHeaderFontNamePropertyInfo where + type AttrAllowedOps PrintCompositorHeaderFontNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint PrintCompositorHeaderFontNamePropertyInfo = (~) T.Text + type AttrBaseTypeConstraint PrintCompositorHeaderFontNamePropertyInfo = IsPrintCompositor + type AttrGetType PrintCompositorHeaderFontNamePropertyInfo = (Maybe T.Text) + type AttrLabel PrintCompositorHeaderFontNamePropertyInfo = "header-font-name" + type AttrOrigin PrintCompositorHeaderFontNamePropertyInfo = PrintCompositor + attrGet _ = getPrintCompositorHeaderFontName + attrSet _ = setPrintCompositorHeaderFontName + attrConstruct _ = constructPrintCompositorHeaderFontName + attrClear _ = clearPrintCompositorHeaderFontName +#endif + +-- VVV Prop "highlight-syntax" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@highlight-syntax@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' printCompositor #highlightSyntax +@ +-} +getPrintCompositorHighlightSyntax :: (MonadIO m, IsPrintCompositor o) => o -> m Bool +getPrintCompositorHighlightSyntax obj = liftIO $ B.Properties.getObjectPropertyBool obj "highlight-syntax" + +{- | +Set the value of the “@highlight-syntax@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' printCompositor [ #highlightSyntax 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setPrintCompositorHighlightSyntax :: (MonadIO m, IsPrintCompositor o) => o -> Bool -> m () +setPrintCompositorHighlightSyntax 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`. +-} +constructPrintCompositorHighlightSyntax :: (IsPrintCompositor o) => Bool -> IO (GValueConstruct o) +constructPrintCompositorHighlightSyntax val = B.Properties.constructObjectPropertyBool "highlight-syntax" val + +#if ENABLE_OVERLOADING +data PrintCompositorHighlightSyntaxPropertyInfo +instance AttrInfo PrintCompositorHighlightSyntaxPropertyInfo where + type AttrAllowedOps PrintCompositorHighlightSyntaxPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint PrintCompositorHighlightSyntaxPropertyInfo = (~) Bool + type AttrBaseTypeConstraint PrintCompositorHighlightSyntaxPropertyInfo = IsPrintCompositor + type AttrGetType PrintCompositorHighlightSyntaxPropertyInfo = Bool + type AttrLabel PrintCompositorHighlightSyntaxPropertyInfo = "highlight-syntax" + type AttrOrigin PrintCompositorHighlightSyntaxPropertyInfo = PrintCompositor + attrGet _ = getPrintCompositorHighlightSyntax + attrSet _ = setPrintCompositorHighlightSyntax + attrConstruct _ = constructPrintCompositorHighlightSyntax + attrClear _ = undefined +#endif + +-- VVV Prop "line-numbers-font-name" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Just True) + +{- | +Get the value of the “@line-numbers-font-name@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' printCompositor #lineNumbersFontName +@ +-} +getPrintCompositorLineNumbersFontName :: (MonadIO m, IsPrintCompositor o) => o -> m (Maybe T.Text) +getPrintCompositorLineNumbersFontName obj = liftIO $ B.Properties.getObjectPropertyString obj "line-numbers-font-name" + +{- | +Set the value of the “@line-numbers-font-name@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' printCompositor [ #lineNumbersFontName 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setPrintCompositorLineNumbersFontName :: (MonadIO m, IsPrintCompositor o) => o -> T.Text -> m () +setPrintCompositorLineNumbersFontName obj val = liftIO $ B.Properties.setObjectPropertyString obj "line-numbers-font-name" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@line-numbers-font-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructPrintCompositorLineNumbersFontName :: (IsPrintCompositor o) => T.Text -> IO (GValueConstruct o) +constructPrintCompositorLineNumbersFontName val = B.Properties.constructObjectPropertyString "line-numbers-font-name" (Just val) + +{- | +Set the value of the “@line-numbers-font-name@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #lineNumbersFontName +@ +-} +clearPrintCompositorLineNumbersFontName :: (MonadIO m, IsPrintCompositor o) => o -> m () +clearPrintCompositorLineNumbersFontName obj = liftIO $ B.Properties.setObjectPropertyString obj "line-numbers-font-name" (Nothing :: Maybe T.Text) + +#if ENABLE_OVERLOADING +data PrintCompositorLineNumbersFontNamePropertyInfo +instance AttrInfo PrintCompositorLineNumbersFontNamePropertyInfo where + type AttrAllowedOps PrintCompositorLineNumbersFontNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint PrintCompositorLineNumbersFontNamePropertyInfo = (~) T.Text + type AttrBaseTypeConstraint PrintCompositorLineNumbersFontNamePropertyInfo = IsPrintCompositor + type AttrGetType PrintCompositorLineNumbersFontNamePropertyInfo = (Maybe T.Text) + type AttrLabel PrintCompositorLineNumbersFontNamePropertyInfo = "line-numbers-font-name" + type AttrOrigin PrintCompositorLineNumbersFontNamePropertyInfo = PrintCompositor + attrGet _ = getPrintCompositorLineNumbersFontName + attrSet _ = setPrintCompositorLineNumbersFontName + attrConstruct _ = constructPrintCompositorLineNumbersFontName + attrClear _ = clearPrintCompositorLineNumbersFontName +#endif + +-- VVV Prop "n-pages" + -- Type: TBasicType TInt + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@n-pages@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' printCompositor #nPages +@ +-} +getPrintCompositorNPages :: (MonadIO m, IsPrintCompositor o) => o -> m Int32 +getPrintCompositorNPages obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "n-pages" + +#if ENABLE_OVERLOADING +data PrintCompositorNPagesPropertyInfo +instance AttrInfo PrintCompositorNPagesPropertyInfo where + type AttrAllowedOps PrintCompositorNPagesPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint PrintCompositorNPagesPropertyInfo = (~) () + type AttrBaseTypeConstraint PrintCompositorNPagesPropertyInfo = IsPrintCompositor + type AttrGetType PrintCompositorNPagesPropertyInfo = Int32 + type AttrLabel PrintCompositorNPagesPropertyInfo = "n-pages" + type AttrOrigin PrintCompositorNPagesPropertyInfo = PrintCompositor + attrGet _ = getPrintCompositorNPages + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "print-footer" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@print-footer@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' printCompositor #printFooter +@ +-} +getPrintCompositorPrintFooter :: (MonadIO m, IsPrintCompositor o) => o -> m Bool +getPrintCompositorPrintFooter obj = liftIO $ B.Properties.getObjectPropertyBool obj "print-footer" + +{- | +Set the value of the “@print-footer@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' printCompositor [ #printFooter 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setPrintCompositorPrintFooter :: (MonadIO m, IsPrintCompositor o) => o -> Bool -> m () +setPrintCompositorPrintFooter obj val = liftIO $ B.Properties.setObjectPropertyBool obj "print-footer" val + +{- | +Construct a `GValueConstruct` with valid value for the “@print-footer@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructPrintCompositorPrintFooter :: (IsPrintCompositor o) => Bool -> IO (GValueConstruct o) +constructPrintCompositorPrintFooter val = B.Properties.constructObjectPropertyBool "print-footer" val + +#if ENABLE_OVERLOADING +data PrintCompositorPrintFooterPropertyInfo +instance AttrInfo PrintCompositorPrintFooterPropertyInfo where + type AttrAllowedOps PrintCompositorPrintFooterPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint PrintCompositorPrintFooterPropertyInfo = (~) Bool + type AttrBaseTypeConstraint PrintCompositorPrintFooterPropertyInfo = IsPrintCompositor + type AttrGetType PrintCompositorPrintFooterPropertyInfo = Bool + type AttrLabel PrintCompositorPrintFooterPropertyInfo = "print-footer" + type AttrOrigin PrintCompositorPrintFooterPropertyInfo = PrintCompositor + attrGet _ = getPrintCompositorPrintFooter + attrSet _ = setPrintCompositorPrintFooter + attrConstruct _ = constructPrintCompositorPrintFooter + attrClear _ = undefined +#endif + +-- VVV Prop "print-header" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@print-header@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' printCompositor #printHeader +@ +-} +getPrintCompositorPrintHeader :: (MonadIO m, IsPrintCompositor o) => o -> m Bool +getPrintCompositorPrintHeader obj = liftIO $ B.Properties.getObjectPropertyBool obj "print-header" + +{- | +Set the value of the “@print-header@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' printCompositor [ #printHeader 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setPrintCompositorPrintHeader :: (MonadIO m, IsPrintCompositor o) => o -> Bool -> m () +setPrintCompositorPrintHeader obj val = liftIO $ B.Properties.setObjectPropertyBool obj "print-header" val + +{- | +Construct a `GValueConstruct` with valid value for the “@print-header@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructPrintCompositorPrintHeader :: (IsPrintCompositor o) => Bool -> IO (GValueConstruct o) +constructPrintCompositorPrintHeader val = B.Properties.constructObjectPropertyBool "print-header" val + +#if ENABLE_OVERLOADING +data PrintCompositorPrintHeaderPropertyInfo +instance AttrInfo PrintCompositorPrintHeaderPropertyInfo where + type AttrAllowedOps PrintCompositorPrintHeaderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint PrintCompositorPrintHeaderPropertyInfo = (~) Bool + type AttrBaseTypeConstraint PrintCompositorPrintHeaderPropertyInfo = IsPrintCompositor + type AttrGetType PrintCompositorPrintHeaderPropertyInfo = Bool + type AttrLabel PrintCompositorPrintHeaderPropertyInfo = "print-header" + type AttrOrigin PrintCompositorPrintHeaderPropertyInfo = PrintCompositor + attrGet _ = getPrintCompositorPrintHeader + attrSet _ = setPrintCompositorPrintHeader + attrConstruct _ = constructPrintCompositorPrintHeader + attrClear _ = undefined +#endif + +-- VVV Prop "print-line-numbers" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@print-line-numbers@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' printCompositor #printLineNumbers +@ +-} +getPrintCompositorPrintLineNumbers :: (MonadIO m, IsPrintCompositor o) => o -> m Word32 +getPrintCompositorPrintLineNumbers obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "print-line-numbers" + +{- | +Set the value of the “@print-line-numbers@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' printCompositor [ #printLineNumbers 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setPrintCompositorPrintLineNumbers :: (MonadIO m, IsPrintCompositor o) => o -> Word32 -> m () +setPrintCompositorPrintLineNumbers obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "print-line-numbers" val + +{- | +Construct a `GValueConstruct` with valid value for the “@print-line-numbers@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructPrintCompositorPrintLineNumbers :: (IsPrintCompositor o) => Word32 -> IO (GValueConstruct o) +constructPrintCompositorPrintLineNumbers val = B.Properties.constructObjectPropertyUInt32 "print-line-numbers" val + +#if ENABLE_OVERLOADING +data PrintCompositorPrintLineNumbersPropertyInfo +instance AttrInfo PrintCompositorPrintLineNumbersPropertyInfo where + type AttrAllowedOps PrintCompositorPrintLineNumbersPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint PrintCompositorPrintLineNumbersPropertyInfo = (~) Word32 + type AttrBaseTypeConstraint PrintCompositorPrintLineNumbersPropertyInfo = IsPrintCompositor + type AttrGetType PrintCompositorPrintLineNumbersPropertyInfo = Word32 + type AttrLabel PrintCompositorPrintLineNumbersPropertyInfo = "print-line-numbers" + type AttrOrigin PrintCompositorPrintLineNumbersPropertyInfo = PrintCompositor + attrGet _ = getPrintCompositorPrintLineNumbers + attrSet _ = setPrintCompositorPrintLineNumbers + attrConstruct _ = constructPrintCompositorPrintLineNumbers + attrClear _ = undefined +#endif + +-- VVV Prop "tab-width" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@tab-width@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' printCompositor #tabWidth +@ +-} +getPrintCompositorTabWidth :: (MonadIO m, IsPrintCompositor o) => o -> m Word32 +getPrintCompositorTabWidth obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "tab-width" + +{- | +Set the value of the “@tab-width@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' printCompositor [ #tabWidth 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setPrintCompositorTabWidth :: (MonadIO m, IsPrintCompositor o) => o -> Word32 -> m () +setPrintCompositorTabWidth obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "tab-width" val + +{- | +Construct a `GValueConstruct` with valid value for the “@tab-width@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructPrintCompositorTabWidth :: (IsPrintCompositor o) => Word32 -> IO (GValueConstruct o) +constructPrintCompositorTabWidth val = B.Properties.constructObjectPropertyUInt32 "tab-width" val + +#if ENABLE_OVERLOADING +data PrintCompositorTabWidthPropertyInfo +instance AttrInfo PrintCompositorTabWidthPropertyInfo where + type AttrAllowedOps PrintCompositorTabWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint PrintCompositorTabWidthPropertyInfo = (~) Word32 + type AttrBaseTypeConstraint PrintCompositorTabWidthPropertyInfo = IsPrintCompositor + type AttrGetType PrintCompositorTabWidthPropertyInfo = Word32 + type AttrLabel PrintCompositorTabWidthPropertyInfo = "tab-width" + type AttrOrigin PrintCompositorTabWidthPropertyInfo = PrintCompositor + attrGet _ = getPrintCompositorTabWidth + attrSet _ = setPrintCompositorTabWidth + attrConstruct _ = constructPrintCompositorTabWidth + attrClear _ = undefined +#endif + +-- VVV Prop "wrap-mode" + -- Type: TInterface (Name {namespace = "Gtk", name = "WrapMode"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@wrap-mode@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' printCompositor #wrapMode +@ +-} +getPrintCompositorWrapMode :: (MonadIO m, IsPrintCompositor o) => o -> m Gtk.Enums.WrapMode +getPrintCompositorWrapMode obj = liftIO $ B.Properties.getObjectPropertyEnum obj "wrap-mode" + +{- | +Set the value of the “@wrap-mode@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' printCompositor [ #wrapMode 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setPrintCompositorWrapMode :: (MonadIO m, IsPrintCompositor o) => o -> Gtk.Enums.WrapMode -> m () +setPrintCompositorWrapMode obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "wrap-mode" val + +{- | +Construct a `GValueConstruct` with valid value for the “@wrap-mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructPrintCompositorWrapMode :: (IsPrintCompositor o) => Gtk.Enums.WrapMode -> IO (GValueConstruct o) +constructPrintCompositorWrapMode val = B.Properties.constructObjectPropertyEnum "wrap-mode" val + +#if ENABLE_OVERLOADING +data PrintCompositorWrapModePropertyInfo +instance AttrInfo PrintCompositorWrapModePropertyInfo where + type AttrAllowedOps PrintCompositorWrapModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint PrintCompositorWrapModePropertyInfo = (~) Gtk.Enums.WrapMode + type AttrBaseTypeConstraint PrintCompositorWrapModePropertyInfo = IsPrintCompositor + type AttrGetType PrintCompositorWrapModePropertyInfo = Gtk.Enums.WrapMode + type AttrLabel PrintCompositorWrapModePropertyInfo = "wrap-mode" + type AttrOrigin PrintCompositorWrapModePropertyInfo = PrintCompositor + attrGet _ = getPrintCompositorWrapMode + attrSet _ = setPrintCompositorWrapMode + attrConstruct _ = constructPrintCompositorWrapMode + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList PrintCompositor +type instance O.AttributeList PrintCompositor = PrintCompositorAttributeList +type PrintCompositorAttributeList = ('[ '("bodyFontName", PrintCompositorBodyFontNamePropertyInfo), '("buffer", PrintCompositorBufferPropertyInfo), '("footerFontName", PrintCompositorFooterFontNamePropertyInfo), '("headerFontName", PrintCompositorHeaderFontNamePropertyInfo), '("highlightSyntax", PrintCompositorHighlightSyntaxPropertyInfo), '("lineNumbersFontName", PrintCompositorLineNumbersFontNamePropertyInfo), '("nPages", PrintCompositorNPagesPropertyInfo), '("printFooter", PrintCompositorPrintFooterPropertyInfo), '("printHeader", PrintCompositorPrintHeaderPropertyInfo), '("printLineNumbers", PrintCompositorPrintLineNumbersPropertyInfo), '("tabWidth", PrintCompositorTabWidthPropertyInfo), '("wrapMode", PrintCompositorWrapModePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +printCompositorBodyFontName :: AttrLabelProxy "bodyFontName" +printCompositorBodyFontName = AttrLabelProxy + +printCompositorBuffer :: AttrLabelProxy "buffer" +printCompositorBuffer = AttrLabelProxy + +printCompositorFooterFontName :: AttrLabelProxy "footerFontName" +printCompositorFooterFontName = AttrLabelProxy + +printCompositorHeaderFontName :: AttrLabelProxy "headerFontName" +printCompositorHeaderFontName = AttrLabelProxy + +printCompositorHighlightSyntax :: AttrLabelProxy "highlightSyntax" +printCompositorHighlightSyntax = AttrLabelProxy + +printCompositorLineNumbersFontName :: AttrLabelProxy "lineNumbersFontName" +printCompositorLineNumbersFontName = AttrLabelProxy + +printCompositorNPages :: AttrLabelProxy "nPages" +printCompositorNPages = AttrLabelProxy + +printCompositorPrintFooter :: AttrLabelProxy "printFooter" +printCompositorPrintFooter = AttrLabelProxy + +printCompositorPrintHeader :: AttrLabelProxy "printHeader" +printCompositorPrintHeader = AttrLabelProxy + +printCompositorPrintLineNumbers :: AttrLabelProxy "printLineNumbers" +printCompositorPrintLineNumbers = AttrLabelProxy + +printCompositorTabWidth :: AttrLabelProxy "tabWidth" +printCompositorTabWidth = AttrLabelProxy + +printCompositorWrapMode :: AttrLabelProxy "wrapMode" +printCompositorWrapMode = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList PrintCompositor = PrintCompositorSignalList +type PrintCompositorSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method PrintCompositor::new +-- method type : Constructor +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkSourceBuffer to print.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_print_compositor_new" gtk_source_print_compositor_new :: + Ptr GtkSource.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + IO (Ptr PrintCompositor) + +{- | +Creates a new print compositor that can be used to print /@buffer@/. + +/Since: 2.2/ +-} +printCompositorNew :: + (B.CallStack.HasCallStack, MonadIO m, GtkSource.Buffer.IsBuffer a) => + a + {- ^ /@buffer@/: the 'GI.GtkSource.Objects.Buffer.Buffer' to print. -} + -> m PrintCompositor + {- ^ __Returns:__ a new print compositor object. -} +printCompositorNew buffer = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + result <- gtk_source_print_compositor_new buffer' + checkUnexpectedReturnNULL "printCompositorNew" result + result' <- (wrapObject PrintCompositor) result + touchManagedPtr buffer + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method PrintCompositor::new_from_view +-- method type : Constructor +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView to get configuration from.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_print_compositor_new_from_view" gtk_source_print_compositor_new_from_view :: + Ptr GtkSource.View.View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + IO (Ptr PrintCompositor) + +{- | +Creates a new print compositor that can be used to print the buffer +associated with /@view@/. +This constructor sets some configuration properties to make the +printed output match /@view@/ as much as possible. The properties set are +'GI.GtkSource.Objects.PrintCompositor.PrintCompositor':@/tab-width/@, 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor':@/highlight-syntax/@, +'GI.GtkSource.Objects.PrintCompositor.PrintCompositor':@/wrap-mode/@, 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor':@/body-font-name/@ and +'GI.GtkSource.Objects.PrintCompositor.PrintCompositor':@/print-line-numbers/@. + +/Since: 2.2/ +-} +printCompositorNewFromView :: + (B.CallStack.HasCallStack, MonadIO m, GtkSource.View.IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View' to get configuration from. -} + -> m PrintCompositor + {- ^ __Returns:__ a new print compositor object. -} +printCompositorNewFromView view = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + result <- gtk_source_print_compositor_new_from_view view' + checkUnexpectedReturnNULL "printCompositorNewFromView" result + result' <- (wrapObject PrintCompositor) result + touchManagedPtr view + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method PrintCompositor::draw_page +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "Gtk", name = "PrintContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkPrintContext encapsulating the context information that is required when\n drawing the page for printing.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "page_nr", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of the page to print.", 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_print_compositor_draw_page" gtk_source_print_compositor_draw_page :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + Ptr Gtk.PrintContext.PrintContext -> -- context : TInterface (Name {namespace = "Gtk", name = "PrintContext"}) + Int32 -> -- page_nr : TBasicType TInt + IO () + +{- | +Draw page /@pageNr@/ for printing on the the Cairo context encapsuled in /@context@/. + +This method has been designed to be called in the handler of the 'GI.Gtk.Objects.PrintOperation.PrintOperation'::@/draw_page/@ signal +as shown in the following example: + +\\ +\/\/ Signal handler for the GtkPrintOperation::draw_page signal + +static void +draw_page (GtkPrintOperation *operation, + GtkPrintContext *context, + gint page_nr, + gpointer user_data) +{ + GtkSourcePrintCompositor *compositor; + + compositor = GTK_SOURCE_PRINT_COMPOSITOR (user_data); + + gtk_source_print_compositor_draw_page (compositor, + context, + page_nr); +} +\<\/programlisting>\<\/informalexample> +-} +printCompositorDrawPage :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a, Gtk.PrintContext.IsPrintContext b) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> b + {- ^ /@context@/: the 'GI.Gtk.Objects.PrintContext.PrintContext' encapsulating the context information that is required when + drawing the page for printing. -} + -> Int32 + {- ^ /@pageNr@/: the number of the page to print. -} + -> m () +printCompositorDrawPage compositor context pageNr = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + context' <- unsafeManagedPtrCastPtr context + gtk_source_print_compositor_draw_page compositor' context' pageNr + touchManagedPtr compositor + touchManagedPtr context + return () + +#if ENABLE_OVERLOADING +data PrintCompositorDrawPageMethodInfo +instance (signature ~ (b -> Int32 -> m ()), MonadIO m, IsPrintCompositor a, Gtk.PrintContext.IsPrintContext b) => O.MethodInfo PrintCompositorDrawPageMethodInfo a signature where + overloadedMethod _ = printCompositorDrawPage + +#endif + +-- method PrintCompositor::get_body_font_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", 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_print_compositor_get_body_font_name" gtk_source_print_compositor_get_body_font_name :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + IO CString + +{- | +Returns the name of the font used to print the text body. The returned string +must be freed with 'GI.GLib.Functions.free'. + +/Since: 2.2/ +-} +printCompositorGetBodyFontName :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> m T.Text + {- ^ __Returns:__ a new string containing the name of the font used to print the +text body. -} +printCompositorGetBodyFontName compositor = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + result <- gtk_source_print_compositor_get_body_font_name compositor' + checkUnexpectedReturnNULL "printCompositorGetBodyFontName" result + result' <- cstringToText result + freeMem result + touchManagedPtr compositor + return result' + +#if ENABLE_OVERLOADING +data PrintCompositorGetBodyFontNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetBodyFontNameMethodInfo a signature where + overloadedMethod _ = printCompositorGetBodyFontName + +#endif + +-- method PrintCompositor::get_bottom_margin +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "unit", argType = TInterface (Name {namespace = "Gtk", name = "Unit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the unit for the return value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_print_compositor_get_bottom_margin" gtk_source_print_compositor_get_bottom_margin :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + CUInt -> -- unit : TInterface (Name {namespace = "Gtk", name = "Unit"}) + IO CDouble + +{- | +Gets the bottom margin in units of /@unit@/. + +/Since: 2.2/ +-} +printCompositorGetBottomMargin :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> Gtk.Enums.Unit + {- ^ /@unit@/: the unit for the return value. -} + -> m Double + {- ^ __Returns:__ the bottom margin. -} +printCompositorGetBottomMargin compositor unit = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + let unit' = (fromIntegral . fromEnum) unit + result <- gtk_source_print_compositor_get_bottom_margin compositor' unit' + let result' = realToFrac result + touchManagedPtr compositor + return result' + +#if ENABLE_OVERLOADING +data PrintCompositorGetBottomMarginMethodInfo +instance (signature ~ (Gtk.Enums.Unit -> m Double), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetBottomMarginMethodInfo a signature where + overloadedMethod _ = printCompositorGetBottomMargin + +#endif + +-- method PrintCompositor::get_buffer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", 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_print_compositor_get_buffer" gtk_source_print_compositor_get_buffer :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + IO (Ptr GtkSource.Buffer.Buffer) + +{- | +Gets the 'GI.GtkSource.Objects.Buffer.Buffer' associated with the compositor. The returned +object reference is owned by the compositor object and +should not be unreferenced. + +/Since: 2.2/ +-} +printCompositorGetBuffer :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> m GtkSource.Buffer.Buffer + {- ^ __Returns:__ the 'GI.GtkSource.Objects.Buffer.Buffer' associated with the compositor. -} +printCompositorGetBuffer compositor = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + result <- gtk_source_print_compositor_get_buffer compositor' + checkUnexpectedReturnNULL "printCompositorGetBuffer" result + result' <- (newObject GtkSource.Buffer.Buffer) result + touchManagedPtr compositor + return result' + +#if ENABLE_OVERLOADING +data PrintCompositorGetBufferMethodInfo +instance (signature ~ (m GtkSource.Buffer.Buffer), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetBufferMethodInfo a signature where + overloadedMethod _ = printCompositorGetBuffer + +#endif + +-- method PrintCompositor::get_footer_font_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", 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_print_compositor_get_footer_font_name" gtk_source_print_compositor_get_footer_font_name :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + IO CString + +{- | +Returns the name of the font used to print the page footer. +The returned string must be freed with 'GI.GLib.Functions.free'. + +/Since: 2.2/ +-} +printCompositorGetFooterFontName :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> m T.Text + {- ^ __Returns:__ a new string containing the name of the font used to print +the page footer. -} +printCompositorGetFooterFontName compositor = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + result <- gtk_source_print_compositor_get_footer_font_name compositor' + checkUnexpectedReturnNULL "printCompositorGetFooterFontName" result + result' <- cstringToText result + freeMem result + touchManagedPtr compositor + return result' + +#if ENABLE_OVERLOADING +data PrintCompositorGetFooterFontNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetFooterFontNameMethodInfo a signature where + overloadedMethod _ = printCompositorGetFooterFontName + +#endif + +-- method PrintCompositor::get_header_font_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", 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_print_compositor_get_header_font_name" gtk_source_print_compositor_get_header_font_name :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + IO CString + +{- | +Returns the name of the font used to print the page header. +The returned string must be freed with 'GI.GLib.Functions.free'. + +/Since: 2.2/ +-} +printCompositorGetHeaderFontName :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> m T.Text + {- ^ __Returns:__ a new string containing the name of the font used to print +the page header. -} +printCompositorGetHeaderFontName compositor = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + result <- gtk_source_print_compositor_get_header_font_name compositor' + checkUnexpectedReturnNULL "printCompositorGetHeaderFontName" result + result' <- cstringToText result + freeMem result + touchManagedPtr compositor + return result' + +#if ENABLE_OVERLOADING +data PrintCompositorGetHeaderFontNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetHeaderFontNameMethodInfo a signature where + overloadedMethod _ = printCompositorGetHeaderFontName + +#endif + +-- method PrintCompositor::get_highlight_syntax +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", 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_print_compositor_get_highlight_syntax" gtk_source_print_compositor_get_highlight_syntax :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + IO CInt + +{- | +Determines whether the printed text will be highlighted according to the +buffer rules. Note that highlighting will happen +only if the buffer to print has highlighting activated. + +/Since: 2.2/ +-} +printCompositorGetHighlightSyntax :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> m Bool + {- ^ __Returns:__ 'True' if the printed output will be highlighted. -} +printCompositorGetHighlightSyntax compositor = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + result <- gtk_source_print_compositor_get_highlight_syntax compositor' + let result' = (/= 0) result + touchManagedPtr compositor + return result' + +#if ENABLE_OVERLOADING +data PrintCompositorGetHighlightSyntaxMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetHighlightSyntaxMethodInfo a signature where + overloadedMethod _ = printCompositorGetHighlightSyntax + +#endif + +-- method PrintCompositor::get_left_margin +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "unit", argType = TInterface (Name {namespace = "Gtk", name = "Unit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the unit for the return value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_print_compositor_get_left_margin" gtk_source_print_compositor_get_left_margin :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + CUInt -> -- unit : TInterface (Name {namespace = "Gtk", name = "Unit"}) + IO CDouble + +{- | +Gets the left margin in units of /@unit@/. + +/Since: 2.2/ +-} +printCompositorGetLeftMargin :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> Gtk.Enums.Unit + {- ^ /@unit@/: the unit for the return value. -} + -> m Double + {- ^ __Returns:__ the left margin -} +printCompositorGetLeftMargin compositor unit = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + let unit' = (fromIntegral . fromEnum) unit + result <- gtk_source_print_compositor_get_left_margin compositor' unit' + let result' = realToFrac result + touchManagedPtr compositor + return result' + +#if ENABLE_OVERLOADING +data PrintCompositorGetLeftMarginMethodInfo +instance (signature ~ (Gtk.Enums.Unit -> m Double), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetLeftMarginMethodInfo a signature where + overloadedMethod _ = printCompositorGetLeftMargin + +#endif + +-- method PrintCompositor::get_line_numbers_font_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", 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_print_compositor_get_line_numbers_font_name" gtk_source_print_compositor_get_line_numbers_font_name :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + IO CString + +{- | +Returns the name of the font used to print line numbers on the left margin. +The returned string must be freed with 'GI.GLib.Functions.free'. + +/Since: 2.2/ +-} +printCompositorGetLineNumbersFontName :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> m T.Text + {- ^ __Returns:__ a new string containing the name of the font used to print +line numbers on the left margin. -} +printCompositorGetLineNumbersFontName compositor = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + result <- gtk_source_print_compositor_get_line_numbers_font_name compositor' + checkUnexpectedReturnNULL "printCompositorGetLineNumbersFontName" result + result' <- cstringToText result + freeMem result + touchManagedPtr compositor + return result' + +#if ENABLE_OVERLOADING +data PrintCompositorGetLineNumbersFontNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetLineNumbersFontNameMethodInfo a signature where + overloadedMethod _ = printCompositorGetLineNumbersFontName + +#endif + +-- method PrintCompositor::get_n_pages +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", 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_print_compositor_get_n_pages" gtk_source_print_compositor_get_n_pages :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + IO Int32 + +{- | +Returns the number of pages in the document or \-1\<\/code> if the +document has not been completely paginated. + +/Since: 2.2/ +-} +printCompositorGetNPages :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> m Int32 + {- ^ __Returns:__ the number of pages in the document or \-1\<\/code> if the +document has not been completely paginated. -} +printCompositorGetNPages compositor = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + result <- gtk_source_print_compositor_get_n_pages compositor' + touchManagedPtr compositor + return result + +#if ENABLE_OVERLOADING +data PrintCompositorGetNPagesMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetNPagesMethodInfo a signature where + overloadedMethod _ = printCompositorGetNPages + +#endif + +-- method PrintCompositor::get_pagination_progress +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_print_compositor_get_pagination_progress" gtk_source_print_compositor_get_pagination_progress :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + IO CDouble + +{- | +Returns the current fraction of the document pagination that has been completed. + +/Since: 2.2/ +-} +printCompositorGetPaginationProgress :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> m Double + {- ^ __Returns:__ a fraction from 0.0 to 1.0 inclusive. -} +printCompositorGetPaginationProgress compositor = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + result <- gtk_source_print_compositor_get_pagination_progress compositor' + let result' = realToFrac result + touchManagedPtr compositor + return result' + +#if ENABLE_OVERLOADING +data PrintCompositorGetPaginationProgressMethodInfo +instance (signature ~ (m Double), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetPaginationProgressMethodInfo a signature where + overloadedMethod _ = printCompositorGetPaginationProgress + +#endif + +-- method PrintCompositor::get_print_footer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", 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_print_compositor_get_print_footer" gtk_source_print_compositor_get_print_footer :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + IO CInt + +{- | +Determines if a footer is set to be printed for each page. A +footer will be printed if this function returns 'True' +\and\<\/emphasis> some format strings have been specified +with 'GI.GtkSource.Objects.PrintCompositor.printCompositorSetFooterFormat'. + +/Since: 2.2/ +-} +printCompositorGetPrintFooter :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> m Bool + {- ^ __Returns:__ 'True' if the footer is set to be printed. -} +printCompositorGetPrintFooter compositor = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + result <- gtk_source_print_compositor_get_print_footer compositor' + let result' = (/= 0) result + touchManagedPtr compositor + return result' + +#if ENABLE_OVERLOADING +data PrintCompositorGetPrintFooterMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetPrintFooterMethodInfo a signature where + overloadedMethod _ = printCompositorGetPrintFooter + +#endif + +-- method PrintCompositor::get_print_header +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", 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_print_compositor_get_print_header" gtk_source_print_compositor_get_print_header :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + IO CInt + +{- | +Determines if a header is set to be printed for each page. A +header will be printed if this function returns 'True' +\and\<\/emphasis> some format strings have been specified +with 'GI.GtkSource.Objects.PrintCompositor.printCompositorSetHeaderFormat'. + +/Since: 2.2/ +-} +printCompositorGetPrintHeader :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> m Bool + {- ^ __Returns:__ 'True' if the header is set to be printed. -} +printCompositorGetPrintHeader compositor = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + result <- gtk_source_print_compositor_get_print_header compositor' + let result' = (/= 0) result + touchManagedPtr compositor + return result' + +#if ENABLE_OVERLOADING +data PrintCompositorGetPrintHeaderMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetPrintHeaderMethodInfo a signature where + overloadedMethod _ = printCompositorGetPrintHeader + +#endif + +-- method PrintCompositor::get_print_line_numbers +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", 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_print_compositor_get_print_line_numbers" gtk_source_print_compositor_get_print_line_numbers :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + IO Word32 + +{- | +Returns the interval used for line number printing. If the +value is 0, no line numbers will be printed. The default value is +1 (i.e. numbers printed in all lines). + +/Since: 2.2/ +-} +printCompositorGetPrintLineNumbers :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> m Word32 + {- ^ __Returns:__ the interval of printed line numbers. -} +printCompositorGetPrintLineNumbers compositor = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + result <- gtk_source_print_compositor_get_print_line_numbers compositor' + touchManagedPtr compositor + return result + +#if ENABLE_OVERLOADING +data PrintCompositorGetPrintLineNumbersMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetPrintLineNumbersMethodInfo a signature where + overloadedMethod _ = printCompositorGetPrintLineNumbers + +#endif + +-- method PrintCompositor::get_right_margin +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "unit", argType = TInterface (Name {namespace = "Gtk", name = "Unit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the unit for the return value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_print_compositor_get_right_margin" gtk_source_print_compositor_get_right_margin :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + CUInt -> -- unit : TInterface (Name {namespace = "Gtk", name = "Unit"}) + IO CDouble + +{- | +Gets the right margin in units of /@unit@/. + +/Since: 2.2/ +-} +printCompositorGetRightMargin :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> Gtk.Enums.Unit + {- ^ /@unit@/: the unit for the return value. -} + -> m Double + {- ^ __Returns:__ the right margin. -} +printCompositorGetRightMargin compositor unit = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + let unit' = (fromIntegral . fromEnum) unit + result <- gtk_source_print_compositor_get_right_margin compositor' unit' + let result' = realToFrac result + touchManagedPtr compositor + return result' + +#if ENABLE_OVERLOADING +data PrintCompositorGetRightMarginMethodInfo +instance (signature ~ (Gtk.Enums.Unit -> m Double), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetRightMarginMethodInfo a signature where + overloadedMethod _ = printCompositorGetRightMargin + +#endif + +-- method PrintCompositor::get_tab_width +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", 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_print_compositor_get_tab_width" gtk_source_print_compositor_get_tab_width :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + IO Word32 + +{- | +Returns the width of tabulation in characters for printed text. + +/Since: 2.2/ +-} +printCompositorGetTabWidth :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> m Word32 + {- ^ __Returns:__ width of tab. -} +printCompositorGetTabWidth compositor = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + result <- gtk_source_print_compositor_get_tab_width compositor' + touchManagedPtr compositor + return result + +#if ENABLE_OVERLOADING +data PrintCompositorGetTabWidthMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetTabWidthMethodInfo a signature where + overloadedMethod _ = printCompositorGetTabWidth + +#endif + +-- method PrintCompositor::get_top_margin +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "unit", argType = TInterface (Name {namespace = "Gtk", name = "Unit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the unit for the return value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_print_compositor_get_top_margin" gtk_source_print_compositor_get_top_margin :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + CUInt -> -- unit : TInterface (Name {namespace = "Gtk", name = "Unit"}) + IO CDouble + +{- | +Gets the top margin in units of /@unit@/. + +/Since: 2.2/ +-} +printCompositorGetTopMargin :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> Gtk.Enums.Unit + {- ^ /@unit@/: the unit for the return value. -} + -> m Double + {- ^ __Returns:__ the top margin. -} +printCompositorGetTopMargin compositor unit = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + let unit' = (fromIntegral . fromEnum) unit + result <- gtk_source_print_compositor_get_top_margin compositor' unit' + let result' = realToFrac result + touchManagedPtr compositor + return result' + +#if ENABLE_OVERLOADING +data PrintCompositorGetTopMarginMethodInfo +instance (signature ~ (Gtk.Enums.Unit -> m Double), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetTopMarginMethodInfo a signature where + overloadedMethod _ = printCompositorGetTopMargin + +#endif + +-- method PrintCompositor::get_wrap_mode +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "WrapMode"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_print_compositor_get_wrap_mode" gtk_source_print_compositor_get_wrap_mode :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + IO CUInt + +{- | +Gets the line wrapping mode for the printed text. + +/Since: 2.2/ +-} +printCompositorGetWrapMode :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> m Gtk.Enums.WrapMode + {- ^ __Returns:__ the line wrap mode. -} +printCompositorGetWrapMode compositor = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + result <- gtk_source_print_compositor_get_wrap_mode compositor' + let result' = (toEnum . fromIntegral) result + touchManagedPtr compositor + return result' + +#if ENABLE_OVERLOADING +data PrintCompositorGetWrapModeMethodInfo +instance (signature ~ (m Gtk.Enums.WrapMode), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorGetWrapModeMethodInfo a signature where + overloadedMethod _ = printCompositorGetWrapMode + +#endif + +-- method PrintCompositor::paginate +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "Gtk", name = "PrintContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkPrintContext whose parameters (e.g. paper size, print margins, etc.)\nare used by the the @compositor to paginate the document.", 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_print_compositor_paginate" gtk_source_print_compositor_paginate :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + Ptr Gtk.PrintContext.PrintContext -> -- context : TInterface (Name {namespace = "Gtk", name = "PrintContext"}) + IO CInt + +{- | +Paginate the document associated with the /@compositor@/. + +In order to support non-blocking pagination, document is paginated in small chunks. +Each time 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' is invoked, a chunk of the document +is paginated. To paginate the entire document, 'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' +must be invoked multiple times. +It returns 'True' if the document has been completely paginated, otherwise it returns 'False'. + +This method has been designed to be invoked in the handler of the 'GI.Gtk.Objects.PrintOperation.PrintOperation'::@/paginate/@ signal, +as shown in the following example: + +\\ +\/\/ Signal handler for the GtkPrintOperation::paginate signal + +static gboolean +paginate (GtkPrintOperation *operation, + GtkPrintContext *context, + gpointer user_data) +{ + GtkSourcePrintCompositor *compositor; + + compositor = GTK_SOURCE_PRINT_COMPOSITOR (user_data); + + if (gtk_source_print_compositor_paginate (compositor, context)) + { + gint n_pages; + + n_pages = gtk_source_print_compositor_get_n_pages (compositor); + gtk_print_operation_set_n_pages (operation, n_pages); + + return TRUE; + } + + return FALSE; +} +\<\/programlisting>\<\/informalexample> + +If you don\'t need to do pagination in chunks, you can simply do it all in the +'GI.Gtk.Objects.PrintOperation.PrintOperation'::@/begin-print/@ handler, and set the number of pages from there, like +in the following example: + +\\ +\/\/ Signal handler for the GtkPrintOperation::begin-print signal + +static void +begin_print (GtkPrintOperation *operation, + GtkPrintContext *context, + gpointer user_data) +{ + GtkSourcePrintCompositor *compositor; + gint n_pages; + + compositor = GTK_SOURCE_PRINT_COMPOSITOR (user_data); + + while (!gtk_source_print_compositor_paginate (compositor, context)); + + n_pages = gtk_source_print_compositor_get_n_pages (compositor); + gtk_print_operation_set_n_pages (operation, n_pages); +} +\<\/programlisting>\<\/informalexample> + +/Since: 2.2/ +-} +printCompositorPaginate :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a, Gtk.PrintContext.IsPrintContext b) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> b + {- ^ /@context@/: the 'GI.Gtk.Objects.PrintContext.PrintContext' whose parameters (e.g. paper size, print margins, etc.) +are used by the the /@compositor@/ to paginate the document. -} + -> m Bool + {- ^ __Returns:__ 'True' if the document has been completely paginated, 'False' otherwise. -} +printCompositorPaginate compositor context = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + context' <- unsafeManagedPtrCastPtr context + result <- gtk_source_print_compositor_paginate compositor' context' + let result' = (/= 0) result + touchManagedPtr compositor + touchManagedPtr context + return result' + +#if ENABLE_OVERLOADING +data PrintCompositorPaginateMethodInfo +instance (signature ~ (b -> m Bool), MonadIO m, IsPrintCompositor a, Gtk.PrintContext.IsPrintContext b) => O.MethodInfo PrintCompositorPaginateMethodInfo a signature where + overloadedMethod _ = printCompositorPaginate + +#endif + +-- method PrintCompositor::set_body_font_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "font_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the default font for the body text.", 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_print_compositor_set_body_font_name" gtk_source_print_compositor_set_body_font_name :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + CString -> -- font_name : TBasicType TUTF8 + IO () + +{- | +Sets the default font for the printed text. + +/@fontName@/ should be a +string representation of a font description Pango can understand. +(e.g. "Monospace 10"). See 'GI.Pango.Functions.fontDescriptionFromString' +for a description of the format of the string representation. + +This function cannot be called anymore after the first call to the +'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function. + +/Since: 2.2/ +-} +printCompositorSetBodyFontName :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> T.Text + {- ^ /@fontName@/: the name of the default font for the body text. -} + -> m () +printCompositorSetBodyFontName compositor fontName = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + fontName' <- textToCString fontName + gtk_source_print_compositor_set_body_font_name compositor' fontName' + touchManagedPtr compositor + freeMem fontName' + return () + +#if ENABLE_OVERLOADING +data PrintCompositorSetBodyFontNameMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetBodyFontNameMethodInfo a signature where + overloadedMethod _ = printCompositorSetBodyFontName + +#endif + +-- method PrintCompositor::set_bottom_margin +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "margin", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new bottom margin in units of @unit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "unit", argType = TInterface (Name {namespace = "Gtk", name = "Unit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the units for @margin.", 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_print_compositor_set_bottom_margin" gtk_source_print_compositor_set_bottom_margin :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + CDouble -> -- margin : TBasicType TDouble + CUInt -> -- unit : TInterface (Name {namespace = "Gtk", name = "Unit"}) + IO () + +{- | +Sets the bottom margin used by /@compositor@/. + +/Since: 2.2/ +-} +printCompositorSetBottomMargin :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> Double + {- ^ /@margin@/: the new bottom margin in units of /@unit@/. -} + -> Gtk.Enums.Unit + {- ^ /@unit@/: the units for /@margin@/. -} + -> m () +printCompositorSetBottomMargin compositor margin unit = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + let margin' = realToFrac margin + let unit' = (fromIntegral . fromEnum) unit + gtk_source_print_compositor_set_bottom_margin compositor' margin' unit' + touchManagedPtr compositor + return () + +#if ENABLE_OVERLOADING +data PrintCompositorSetBottomMarginMethodInfo +instance (signature ~ (Double -> Gtk.Enums.Unit -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetBottomMarginMethodInfo a signature where + overloadedMethod _ = printCompositorSetBottomMargin + +#endif + +-- method PrintCompositor::set_footer_font_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "font_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the name of the font for the footer text, 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_print_compositor_set_footer_font_name" gtk_source_print_compositor_set_footer_font_name :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + CString -> -- font_name : TBasicType TUTF8 + IO () + +{- | +Sets the font for printing the page footer. If +'Nothing' is supplied, the default font (i.e. the one being used for the +text) will be used instead. + +/@fontName@/ should be a +string representation of a font description Pango can understand. +(e.g. "Monospace 10"). See 'GI.Pango.Functions.fontDescriptionFromString' +for a description of the format of the string representation. + +This function cannot be called anymore after the first call to the +'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function. + +/Since: 2.2/ +-} +printCompositorSetFooterFontName :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> Maybe (T.Text) + {- ^ /@fontName@/: the name of the font for the footer text, or 'Nothing'. -} + -> m () +printCompositorSetFooterFontName compositor fontName = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + maybeFontName <- case fontName of + Nothing -> return nullPtr + Just jFontName -> do + jFontName' <- textToCString jFontName + return jFontName' + gtk_source_print_compositor_set_footer_font_name compositor' maybeFontName + touchManagedPtr compositor + freeMem maybeFontName + return () + +#if ENABLE_OVERLOADING +data PrintCompositorSetFooterFontNameMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetFooterFontNameMethodInfo a signature where + overloadedMethod _ = printCompositorSetFooterFontName + +#endif + +-- method PrintCompositor::set_footer_format +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "separator", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if you want a separator line to be printed.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "left", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a format string to print on the left of the footer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "center", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a format string to print on the center of the footer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "right", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a format string to print on the right of the footer.", 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_print_compositor_set_footer_format" gtk_source_print_compositor_set_footer_format :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + CInt -> -- separator : TBasicType TBoolean + CString -> -- left : TBasicType TUTF8 + CString -> -- center : TBasicType TUTF8 + CString -> -- right : TBasicType TUTF8 + IO () + +{- | +See 'GI.GtkSource.Objects.PrintCompositor.printCompositorSetHeaderFormat' for more information +about the parameters. + +/Since: 2.2/ +-} +printCompositorSetFooterFormat :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> Bool + {- ^ /@separator@/: 'True' if you want a separator line to be printed. -} + -> Maybe (T.Text) + {- ^ /@left@/: a format string to print on the left of the footer. -} + -> Maybe (T.Text) + {- ^ /@center@/: a format string to print on the center of the footer. -} + -> Maybe (T.Text) + {- ^ /@right@/: a format string to print on the right of the footer. -} + -> m () +printCompositorSetFooterFormat compositor separator left center right = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + let separator' = (fromIntegral . fromEnum) separator + maybeLeft <- case left of + Nothing -> return nullPtr + Just jLeft -> do + jLeft' <- textToCString jLeft + return jLeft' + maybeCenter <- case center of + Nothing -> return nullPtr + Just jCenter -> do + jCenter' <- textToCString jCenter + return jCenter' + maybeRight <- case right of + Nothing -> return nullPtr + Just jRight -> do + jRight' <- textToCString jRight + return jRight' + gtk_source_print_compositor_set_footer_format compositor' separator' maybeLeft maybeCenter maybeRight + touchManagedPtr compositor + freeMem maybeLeft + freeMem maybeCenter + freeMem maybeRight + return () + +#if ENABLE_OVERLOADING +data PrintCompositorSetFooterFormatMethodInfo +instance (signature ~ (Bool -> Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetFooterFormatMethodInfo a signature where + overloadedMethod _ = printCompositorSetFooterFormat + +#endif + +-- method PrintCompositor::set_header_font_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "font_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the name of the font for header text, 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_print_compositor_set_header_font_name" gtk_source_print_compositor_set_header_font_name :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + CString -> -- font_name : TBasicType TUTF8 + IO () + +{- | +Sets the font for printing the page header. If +'Nothing' is supplied, the default font (i.e. the one being used for the +text) will be used instead. + +/@fontName@/ should be a +string representation of a font description Pango can understand. +(e.g. "Monospace 10"). See 'GI.Pango.Functions.fontDescriptionFromString' +for a description of the format of the string representation. + +This function cannot be called anymore after the first call to the +'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function. + +/Since: 2.2/ +-} +printCompositorSetHeaderFontName :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> Maybe (T.Text) + {- ^ /@fontName@/: the name of the font for header text, or 'Nothing'. -} + -> m () +printCompositorSetHeaderFontName compositor fontName = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + maybeFontName <- case fontName of + Nothing -> return nullPtr + Just jFontName -> do + jFontName' <- textToCString jFontName + return jFontName' + gtk_source_print_compositor_set_header_font_name compositor' maybeFontName + touchManagedPtr compositor + freeMem maybeFontName + return () + +#if ENABLE_OVERLOADING +data PrintCompositorSetHeaderFontNameMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetHeaderFontNameMethodInfo a signature where + overloadedMethod _ = printCompositorSetHeaderFontName + +#endif + +-- method PrintCompositor::set_header_format +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "separator", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if you want a separator line to be printed.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "left", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a format string to print on the left of the header.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "center", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a format string to print on the center of the header.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "right", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a format string to print on the right of the header.", 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_print_compositor_set_header_format" gtk_source_print_compositor_set_header_format :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + CInt -> -- separator : TBasicType TBoolean + CString -> -- left : TBasicType TUTF8 + CString -> -- center : TBasicType TUTF8 + CString -> -- right : TBasicType TUTF8 + IO () + +{- | +Sets strftime like header format strings, to be printed on the +left, center and right of the top of each page. The strings may +include strftime(3) codes which will be expanded at print time. +A subset of @/strftime()/@ codes are accepted, see 'GI.GLib.Structs.DateTime.dateTimeFormat' +for more details on the accepted format specifiers. +Additionally the following format specifiers are accepted: + +* @/N/@: the page number +* @/Q/@: the page count. + + +/@separator@/ specifies if a solid line should be drawn to separate +the header from the document text. + +If 'Nothing' is given for any of the three arguments, that particular +string will not be printed. + +For the header to be printed, in +addition to specifying format strings, you need to enable header +printing with 'GI.GtkSource.Objects.PrintCompositor.printCompositorSetPrintHeader'. + +This function cannot be called anymore after the first call to the +'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function. + +/Since: 2.2/ +-} +printCompositorSetHeaderFormat :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> Bool + {- ^ /@separator@/: 'True' if you want a separator line to be printed. -} + -> Maybe (T.Text) + {- ^ /@left@/: a format string to print on the left of the header. -} + -> Maybe (T.Text) + {- ^ /@center@/: a format string to print on the center of the header. -} + -> Maybe (T.Text) + {- ^ /@right@/: a format string to print on the right of the header. -} + -> m () +printCompositorSetHeaderFormat compositor separator left center right = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + let separator' = (fromIntegral . fromEnum) separator + maybeLeft <- case left of + Nothing -> return nullPtr + Just jLeft -> do + jLeft' <- textToCString jLeft + return jLeft' + maybeCenter <- case center of + Nothing -> return nullPtr + Just jCenter -> do + jCenter' <- textToCString jCenter + return jCenter' + maybeRight <- case right of + Nothing -> return nullPtr + Just jRight -> do + jRight' <- textToCString jRight + return jRight' + gtk_source_print_compositor_set_header_format compositor' separator' maybeLeft maybeCenter maybeRight + touchManagedPtr compositor + freeMem maybeLeft + freeMem maybeCenter + freeMem maybeRight + return () + +#if ENABLE_OVERLOADING +data PrintCompositorSetHeaderFormatMethodInfo +instance (signature ~ (Bool -> Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetHeaderFormatMethodInfo a signature where + overloadedMethod _ = printCompositorSetHeaderFormat + +#endif + +-- method PrintCompositor::set_highlight_syntax +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", 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 "whether syntax should be 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_print_compositor_set_highlight_syntax" gtk_source_print_compositor_set_highlight_syntax :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + CInt -> -- highlight : TBasicType TBoolean + IO () + +{- | +Sets whether the printed text will be highlighted according to the +buffer rules. Both color and font style are applied. + +This function cannot be called anymore after the first call to the +'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function. + +/Since: 2.2/ +-} +printCompositorSetHighlightSyntax :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> Bool + {- ^ /@highlight@/: whether syntax should be highlighted. -} + -> m () +printCompositorSetHighlightSyntax compositor highlight = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + let highlight' = (fromIntegral . fromEnum) highlight + gtk_source_print_compositor_set_highlight_syntax compositor' highlight' + touchManagedPtr compositor + return () + +#if ENABLE_OVERLOADING +data PrintCompositorSetHighlightSyntaxMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetHighlightSyntaxMethodInfo a signature where + overloadedMethod _ = printCompositorSetHighlightSyntax + +#endif + +-- method PrintCompositor::set_left_margin +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "margin", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new left margin in units of @unit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "unit", argType = TInterface (Name {namespace = "Gtk", name = "Unit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the units for @margin.", 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_print_compositor_set_left_margin" gtk_source_print_compositor_set_left_margin :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + CDouble -> -- margin : TBasicType TDouble + CUInt -> -- unit : TInterface (Name {namespace = "Gtk", name = "Unit"}) + IO () + +{- | +Sets the left margin used by /@compositor@/. + +/Since: 2.2/ +-} +printCompositorSetLeftMargin :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> Double + {- ^ /@margin@/: the new left margin in units of /@unit@/. -} + -> Gtk.Enums.Unit + {- ^ /@unit@/: the units for /@margin@/. -} + -> m () +printCompositorSetLeftMargin compositor margin unit = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + let margin' = realToFrac margin + let unit' = (fromIntegral . fromEnum) unit + gtk_source_print_compositor_set_left_margin compositor' margin' unit' + touchManagedPtr compositor + return () + +#if ENABLE_OVERLOADING +data PrintCompositorSetLeftMarginMethodInfo +instance (signature ~ (Double -> Gtk.Enums.Unit -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetLeftMarginMethodInfo a signature where + overloadedMethod _ = printCompositorSetLeftMargin + +#endif + +-- method PrintCompositor::set_line_numbers_font_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "font_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the name of the font for line numbers, 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_print_compositor_set_line_numbers_font_name" gtk_source_print_compositor_set_line_numbers_font_name :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + CString -> -- font_name : TBasicType TUTF8 + IO () + +{- | +Sets the font for printing line numbers on the left margin. If +'Nothing' is supplied, the default font (i.e. the one being used for the +text) will be used instead. + +/@fontName@/ should be a +string representation of a font description Pango can understand. +(e.g. "Monospace 10"). See 'GI.Pango.Functions.fontDescriptionFromString' +for a description of the format of the string representation. + +This function cannot be called anymore after the first call to the +'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function. + +/Since: 2.2/ +-} +printCompositorSetLineNumbersFontName :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> Maybe (T.Text) + {- ^ /@fontName@/: the name of the font for line numbers, or 'Nothing'. -} + -> m () +printCompositorSetLineNumbersFontName compositor fontName = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + maybeFontName <- case fontName of + Nothing -> return nullPtr + Just jFontName -> do + jFontName' <- textToCString jFontName + return jFontName' + gtk_source_print_compositor_set_line_numbers_font_name compositor' maybeFontName + touchManagedPtr compositor + freeMem maybeFontName + return () + +#if ENABLE_OVERLOADING +data PrintCompositorSetLineNumbersFontNameMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetLineNumbersFontNameMethodInfo a signature where + overloadedMethod _ = printCompositorSetLineNumbersFontName + +#endif + +-- method PrintCompositor::set_print_footer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "print", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if you want the footer to be printed.", 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_print_compositor_set_print_footer" gtk_source_print_compositor_set_print_footer :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + CInt -> -- print : TBasicType TBoolean + IO () + +{- | +Sets whether you want to print a footer in each page. The +footer consists of three pieces of text and an optional line +separator, configurable with +'GI.GtkSource.Objects.PrintCompositor.printCompositorSetFooterFormat'. + +Note that by default the footer format is unspecified, and if it\'s +empty it will not be printed, regardless of this setting. + +This function cannot be called anymore after the first call to the +'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function. + +/Since: 2.2/ +-} +printCompositorSetPrintFooter :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> Bool + {- ^ /@print@/: 'True' if you want the footer to be printed. -} + -> m () +printCompositorSetPrintFooter compositor print = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + let print' = (fromIntegral . fromEnum) print + gtk_source_print_compositor_set_print_footer compositor' print' + touchManagedPtr compositor + return () + +#if ENABLE_OVERLOADING +data PrintCompositorSetPrintFooterMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetPrintFooterMethodInfo a signature where + overloadedMethod _ = printCompositorSetPrintFooter + +#endif + +-- method PrintCompositor::set_print_header +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "print", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if you want the header to be printed.", 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_print_compositor_set_print_header" gtk_source_print_compositor_set_print_header :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + CInt -> -- print : TBasicType TBoolean + IO () + +{- | +Sets whether you want to print a header in each page. The +header consists of three pieces of text and an optional line +separator, configurable with +'GI.GtkSource.Objects.PrintCompositor.printCompositorSetHeaderFormat'. + +Note that by default the header format is unspecified, and if it\'s +empty it will not be printed, regardless of this setting. + +This function cannot be called anymore after the first call to the +'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function. + +/Since: 2.2/ +-} +printCompositorSetPrintHeader :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> Bool + {- ^ /@print@/: 'True' if you want the header to be printed. -} + -> m () +printCompositorSetPrintHeader compositor print = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + let print' = (fromIntegral . fromEnum) print + gtk_source_print_compositor_set_print_header compositor' print' + touchManagedPtr compositor + return () + +#if ENABLE_OVERLOADING +data PrintCompositorSetPrintHeaderMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetPrintHeaderMethodInfo a signature where + overloadedMethod _ = printCompositorSetPrintHeader + +#endif + +-- method PrintCompositor::set_print_line_numbers +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interval", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "interval for printed line numbers.", 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_print_compositor_set_print_line_numbers" gtk_source_print_compositor_set_print_line_numbers :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + Word32 -> -- interval : TBasicType TUInt + IO () + +{- | +Sets the interval for printed line numbers. If /@interval@/ is 0 no +numbers will be printed. If greater than 0, a number will be +printed every /@interval@/ lines (i.e. 1 will print all line numbers). + +Maximum accepted value for /@interval@/ is 100. + +This function cannot be called anymore after the first call to the +'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function. + +/Since: 2.2/ +-} +printCompositorSetPrintLineNumbers :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> Word32 + {- ^ /@interval@/: interval for printed line numbers. -} + -> m () +printCompositorSetPrintLineNumbers compositor interval = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + gtk_source_print_compositor_set_print_line_numbers compositor' interval + touchManagedPtr compositor + return () + +#if ENABLE_OVERLOADING +data PrintCompositorSetPrintLineNumbersMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetPrintLineNumbersMethodInfo a signature where + overloadedMethod _ = printCompositorSetPrintLineNumbers + +#endif + +-- method PrintCompositor::set_right_margin +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "margin", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new right margin in units of @unit.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "unit", argType = TInterface (Name {namespace = "Gtk", name = "Unit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the units for @margin.", 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_print_compositor_set_right_margin" gtk_source_print_compositor_set_right_margin :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + CDouble -> -- margin : TBasicType TDouble + CUInt -> -- unit : TInterface (Name {namespace = "Gtk", name = "Unit"}) + IO () + +{- | +Sets the right margin used by /@compositor@/. + +/Since: 2.2/ +-} +printCompositorSetRightMargin :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> Double + {- ^ /@margin@/: the new right margin in units of /@unit@/. -} + -> Gtk.Enums.Unit + {- ^ /@unit@/: the units for /@margin@/. -} + -> m () +printCompositorSetRightMargin compositor margin unit = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + let margin' = realToFrac margin + let unit' = (fromIntegral . fromEnum) unit + gtk_source_print_compositor_set_right_margin compositor' margin' unit' + touchManagedPtr compositor + return () + +#if ENABLE_OVERLOADING +data PrintCompositorSetRightMarginMethodInfo +instance (signature ~ (Double -> Gtk.Enums.Unit -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetRightMarginMethodInfo a signature where + overloadedMethod _ = printCompositorSetRightMargin + +#endif + +-- method PrintCompositor::set_tab_width +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "width of tab in characters.", 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_print_compositor_set_tab_width" gtk_source_print_compositor_set_tab_width :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + Word32 -> -- width : TBasicType TUInt + IO () + +{- | +Sets the width of tabulation in characters for printed text. + +This function cannot be called anymore after the first call to the +'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function. + +/Since: 2.2/ +-} +printCompositorSetTabWidth :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> Word32 + {- ^ /@width@/: width of tab in characters. -} + -> m () +printCompositorSetTabWidth compositor width = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + gtk_source_print_compositor_set_tab_width compositor' width + touchManagedPtr compositor + return () + +#if ENABLE_OVERLOADING +data PrintCompositorSetTabWidthMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetTabWidthMethodInfo a signature where + overloadedMethod _ = printCompositorSetTabWidth + +#endif + +-- method PrintCompositor::set_top_margin +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "margin", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new top margin in units of @unit", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "unit", argType = TInterface (Name {namespace = "Gtk", name = "Unit"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the units for @margin", 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_print_compositor_set_top_margin" gtk_source_print_compositor_set_top_margin :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + CDouble -> -- margin : TBasicType TDouble + CUInt -> -- unit : TInterface (Name {namespace = "Gtk", name = "Unit"}) + IO () + +{- | +Sets the top margin used by /@compositor@/. + +/Since: 2.2/ +-} +printCompositorSetTopMargin :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> Double + {- ^ /@margin@/: the new top margin in units of /@unit@/ -} + -> Gtk.Enums.Unit + {- ^ /@unit@/: the units for /@margin@/ -} + -> m () +printCompositorSetTopMargin compositor margin unit = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + let margin' = realToFrac margin + let unit' = (fromIntegral . fromEnum) unit + gtk_source_print_compositor_set_top_margin compositor' margin' unit' + touchManagedPtr compositor + return () + +#if ENABLE_OVERLOADING +data PrintCompositorSetTopMarginMethodInfo +instance (signature ~ (Double -> Gtk.Enums.Unit -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetTopMarginMethodInfo a signature where + overloadedMethod _ = printCompositorSetTopMargin + +#endif + +-- method PrintCompositor::set_wrap_mode +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "compositor", argType = TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourcePrintCompositor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "wrap_mode", argType = TInterface (Name {namespace = "Gtk", name = "WrapMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWrapMode.", 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_print_compositor_set_wrap_mode" gtk_source_print_compositor_set_wrap_mode :: + Ptr PrintCompositor -> -- compositor : TInterface (Name {namespace = "GtkSource", name = "PrintCompositor"}) + CUInt -> -- wrap_mode : TInterface (Name {namespace = "Gtk", name = "WrapMode"}) + IO () + +{- | +Sets the line wrapping mode for the printed text. + +This function cannot be called anymore after the first call to the +'GI.GtkSource.Objects.PrintCompositor.printCompositorPaginate' function. + +/Since: 2.2/ +-} +printCompositorSetWrapMode :: + (B.CallStack.HasCallStack, MonadIO m, IsPrintCompositor a) => + a + {- ^ /@compositor@/: a 'GI.GtkSource.Objects.PrintCompositor.PrintCompositor'. -} + -> Gtk.Enums.WrapMode + {- ^ /@wrapMode@/: a 'GI.Gtk.Enums.WrapMode'. -} + -> m () +printCompositorSetWrapMode compositor wrapMode = liftIO $ do + compositor' <- unsafeManagedPtrCastPtr compositor + let wrapMode' = (fromIntegral . fromEnum) wrapMode + gtk_source_print_compositor_set_wrap_mode compositor' wrapMode' + touchManagedPtr compositor + return () + +#if ENABLE_OVERLOADING +data PrintCompositorSetWrapModeMethodInfo +instance (signature ~ (Gtk.Enums.WrapMode -> m ()), MonadIO m, IsPrintCompositor a) => O.MethodInfo PrintCompositorSetWrapModeMethodInfo a signature where + overloadedMethod _ = printCompositorSetWrapMode + +#endif + + diff --git a/GI/GtkSource/Objects/PrintCompositor.hs-boot b/GI/GtkSource/Objects/PrintCompositor.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/PrintCompositor.hs-boot @@ -0,0 +1,170 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.PrintCompositor 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 PrintCompositor = PrintCompositor (ManagedPtr PrintCompositor) +instance GObject PrintCompositor where +class (GObject o, O.IsDescendantOf PrintCompositor o) => IsPrintCompositor o +instance (GObject o, O.IsDescendantOf PrintCompositor o) => IsPrintCompositor o +instance O.HasParentTypes PrintCompositor +#if ENABLE_OVERLOADING +data PrintCompositorBodyFontNamePropertyInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorBufferPropertyInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorFooterFontNamePropertyInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorHeaderFontNamePropertyInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorHighlightSyntaxPropertyInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorLineNumbersFontNamePropertyInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorNPagesPropertyInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorPrintFooterPropertyInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorPrintHeaderPropertyInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorPrintLineNumbersPropertyInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorTabWidthPropertyInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorWrapModePropertyInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorDrawPageMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorGetBodyFontNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorGetBottomMarginMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorGetBufferMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorGetFooterFontNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorGetHeaderFontNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorGetHighlightSyntaxMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorGetLeftMarginMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorGetLineNumbersFontNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorGetNPagesMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorGetPaginationProgressMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorGetPrintFooterMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorGetPrintHeaderMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorGetPrintLineNumbersMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorGetRightMarginMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorGetTabWidthMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorGetTopMarginMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorGetWrapModeMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorPaginateMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorSetBodyFontNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorSetBottomMarginMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorSetFooterFontNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorSetFooterFormatMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorSetHeaderFontNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorSetHeaderFormatMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorSetHighlightSyntaxMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorSetLeftMarginMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorSetLineNumbersFontNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorSetPrintFooterMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorSetPrintHeaderMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorSetPrintLineNumbersMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorSetRightMarginMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorSetTabWidthMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorSetTopMarginMethodInfo +#endif +#if ENABLE_OVERLOADING +data PrintCompositorSetWrapModeMethodInfo +#endif diff --git a/GI/GtkSource/Objects/Region.hs b/GI/GtkSource/Objects/Region.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/Region.hs @@ -0,0 +1,808 @@ + + +{- | +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.Region + ( + +-- * Exported types + Region(..) , + IsRegion , + toRegion , + noRegion , + + + -- * Methods +-- ** addRegion #method:addRegion# + +#if ENABLE_OVERLOADING + RegionAddRegionMethodInfo , +#endif + regionAddRegion , + + +-- ** addSubregion #method:addSubregion# + +#if ENABLE_OVERLOADING + RegionAddSubregionMethodInfo , +#endif + regionAddSubregion , + + +-- ** getBounds #method:getBounds# + +#if ENABLE_OVERLOADING + RegionGetBoundsMethodInfo , +#endif + regionGetBounds , + + +-- ** getBuffer #method:getBuffer# + +#if ENABLE_OVERLOADING + RegionGetBufferMethodInfo , +#endif + regionGetBuffer , + + +-- ** getStartRegionIter #method:getStartRegionIter# + +#if ENABLE_OVERLOADING + RegionGetStartRegionIterMethodInfo , +#endif + regionGetStartRegionIter , + + +-- ** intersectRegion #method:intersectRegion# + +#if ENABLE_OVERLOADING + RegionIntersectRegionMethodInfo , +#endif + regionIntersectRegion , + + +-- ** intersectSubregion #method:intersectSubregion# + +#if ENABLE_OVERLOADING + RegionIntersectSubregionMethodInfo , +#endif + regionIntersectSubregion , + + +-- ** isEmpty #method:isEmpty# + +#if ENABLE_OVERLOADING + RegionIsEmptyMethodInfo , +#endif + regionIsEmpty , + + +-- ** new #method:new# + + regionNew , + + +-- ** subtractRegion #method:subtractRegion# + +#if ENABLE_OVERLOADING + RegionSubtractRegionMethodInfo , +#endif + regionSubtractRegion , + + +-- ** subtractSubregion #method:subtractSubregion# + +#if ENABLE_OVERLOADING + RegionSubtractSubregionMethodInfo , +#endif + regionSubtractSubregion , + + +-- ** toString #method:toString# + +#if ENABLE_OVERLOADING + RegionToStringMethodInfo , +#endif + regionToString , + + + + + -- * Properties +-- ** buffer #attr:buffer# +{- | The 'GI.Gtk.Objects.TextBuffer.TextBuffer'. The 'GI.GtkSource.Objects.Region.Region' has a weak reference to the +buffer. + +/Since: 3.22/ +-} +#if ENABLE_OVERLOADING + RegionBufferPropertyInfo , +#endif + constructRegionBuffer , + getRegionBuffer , +#if ENABLE_OVERLOADING + regionBuffer , +#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 qualified GI.Gtk.Objects.TextBuffer as Gtk.TextBuffer +import qualified GI.Gtk.Structs.TextIter as Gtk.TextIter +import {-# SOURCE #-} qualified GI.GtkSource.Structs.RegionIter as GtkSource.RegionIter + +-- | Memory-managed wrapper type. +newtype Region = Region (ManagedPtr Region) +foreign import ccall "gtk_source_region_get_type" + c_gtk_source_region_get_type :: IO GType + +instance GObject Region where + gobjectType = c_gtk_source_region_get_type + + +-- | Type class for types which can be safely cast to `Region`, for instance with `toRegion`. +class (GObject o, O.IsDescendantOf Region o) => IsRegion o +instance (GObject o, O.IsDescendantOf Region o) => IsRegion o + +instance O.HasParentTypes Region +type instance O.ParentTypes Region = '[GObject.Object.Object] + +-- | Cast to `Region`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toRegion :: (MonadIO m, IsRegion o) => o -> m Region +toRegion = liftIO . unsafeCastTo Region + +-- | A convenience alias for `Nothing` :: `Maybe` `Region`. +noRegion :: Maybe Region +noRegion = Nothing + +#if ENABLE_OVERLOADING +type family ResolveRegionMethod (t :: Symbol) (o :: *) :: * where + ResolveRegionMethod "addRegion" o = RegionAddRegionMethodInfo + ResolveRegionMethod "addSubregion" o = RegionAddSubregionMethodInfo + ResolveRegionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveRegionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveRegionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveRegionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveRegionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveRegionMethod "intersectRegion" o = RegionIntersectRegionMethodInfo + ResolveRegionMethod "intersectSubregion" o = RegionIntersectSubregionMethodInfo + ResolveRegionMethod "isEmpty" o = RegionIsEmptyMethodInfo + ResolveRegionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveRegionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveRegionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveRegionMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveRegionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveRegionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveRegionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveRegionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveRegionMethod "subtractRegion" o = RegionSubtractRegionMethodInfo + ResolveRegionMethod "subtractSubregion" o = RegionSubtractSubregionMethodInfo + ResolveRegionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveRegionMethod "toString" o = RegionToStringMethodInfo + ResolveRegionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveRegionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveRegionMethod "getBounds" o = RegionGetBoundsMethodInfo + ResolveRegionMethod "getBuffer" o = RegionGetBufferMethodInfo + ResolveRegionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveRegionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveRegionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveRegionMethod "getStartRegionIter" o = RegionGetStartRegionIterMethodInfo + ResolveRegionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveRegionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveRegionMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRegionMethod t Region, O.MethodInfo info Region p) => OL.IsLabel t (Region -> 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 + +-- VVV Prop "buffer" + -- Type: TInterface (Name {namespace = "Gtk", name = "TextBuffer"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@buffer@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' region #buffer +@ +-} +getRegionBuffer :: (MonadIO m, IsRegion o) => o -> m (Maybe Gtk.TextBuffer.TextBuffer) +getRegionBuffer obj = liftIO $ B.Properties.getObjectPropertyObject obj "buffer" Gtk.TextBuffer.TextBuffer + +{- | +Construct a `GValueConstruct` with valid value for the “@buffer@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructRegionBuffer :: (IsRegion o, Gtk.TextBuffer.IsTextBuffer a) => a -> IO (GValueConstruct o) +constructRegionBuffer val = B.Properties.constructObjectPropertyObject "buffer" (Just val) + +#if ENABLE_OVERLOADING +data RegionBufferPropertyInfo +instance AttrInfo RegionBufferPropertyInfo where + type AttrAllowedOps RegionBufferPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint RegionBufferPropertyInfo = Gtk.TextBuffer.IsTextBuffer + type AttrBaseTypeConstraint RegionBufferPropertyInfo = IsRegion + type AttrGetType RegionBufferPropertyInfo = (Maybe Gtk.TextBuffer.TextBuffer) + type AttrLabel RegionBufferPropertyInfo = "buffer" + type AttrOrigin RegionBufferPropertyInfo = Region + attrGet _ = getRegionBuffer + attrSet _ = undefined + attrConstruct _ = constructRegionBuffer + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Region +type instance O.AttributeList Region = RegionAttributeList +type RegionAttributeList = ('[ '("buffer", RegionBufferPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +regionBuffer :: AttrLabelProxy "buffer" +regionBuffer = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Region = RegionSignalList +type RegionSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Region::new +-- method type : Constructor +-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Region"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_region_new" gtk_source_region_new :: + Ptr Gtk.TextBuffer.TextBuffer -> -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"}) + IO (Ptr Region) + +{- | +/No description available in the introspection data./ + +/Since: 3.22/ +-} +regionNew :: + (B.CallStack.HasCallStack, MonadIO m, Gtk.TextBuffer.IsTextBuffer a) => + a + {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer'. -} + -> m Region + {- ^ __Returns:__ a new 'GI.GtkSource.Objects.Region.Region' object for /@buffer@/. -} +regionNew buffer = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + result <- gtk_source_region_new buffer' + checkUnexpectedReturnNULL "regionNew" result + result' <- (wrapObject Region) result + touchManagedPtr buffer + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Region::add_region +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "region", argType = TInterface (Name {namespace = "GtkSource", name = "Region"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceRegion.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "region_to_add", argType = TInterface (Name {namespace = "GtkSource", name = "Region"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the #GtkSourceRegion to add to @region, 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_region_add_region" gtk_source_region_add_region :: + Ptr Region -> -- region : TInterface (Name {namespace = "GtkSource", name = "Region"}) + Ptr Region -> -- region_to_add : TInterface (Name {namespace = "GtkSource", name = "Region"}) + IO () + +{- | +Adds /@regionToAdd@/ to /@region@/. /@regionToAdd@/ is not modified. + +/Since: 3.22/ +-} +regionAddRegion :: + (B.CallStack.HasCallStack, MonadIO m, IsRegion a, IsRegion b) => + a + {- ^ /@region@/: a 'GI.GtkSource.Objects.Region.Region'. -} + -> Maybe (b) + {- ^ /@regionToAdd@/: the 'GI.GtkSource.Objects.Region.Region' to add to /@region@/, or 'Nothing'. -} + -> m () +regionAddRegion region regionToAdd = liftIO $ do + region' <- unsafeManagedPtrCastPtr region + maybeRegionToAdd <- case regionToAdd of + Nothing -> return nullPtr + Just jRegionToAdd -> do + jRegionToAdd' <- unsafeManagedPtrCastPtr jRegionToAdd + return jRegionToAdd' + gtk_source_region_add_region region' maybeRegionToAdd + touchManagedPtr region + whenJust regionToAdd touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data RegionAddRegionMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsRegion a, IsRegion b) => O.MethodInfo RegionAddRegionMethodInfo a signature where + overloadedMethod _ = regionAddRegion + +#endif + +-- method Region::add_subregion +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "region", argType = TInterface (Name {namespace = "GtkSource", name = "Region"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceRegion.", 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 "the start of the subregion.", 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 "the end of the subregion.", 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_region_add_subregion" gtk_source_region_add_subregion :: + Ptr Region -> -- region : TInterface (Name {namespace = "GtkSource", name = "Region"}) + Ptr Gtk.TextIter.TextIter -> -- _start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- _end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + IO () + +{- | +Adds the subregion delimited by /@start_@/ and /@end_@/ to /@region@/. + +/Since: 3.22/ +-} +regionAddSubregion :: + (B.CallStack.HasCallStack, MonadIO m, IsRegion a) => + a + {- ^ /@region@/: a 'GI.GtkSource.Objects.Region.Region'. -} + -> Gtk.TextIter.TextIter + {- ^ /@start_@/: the start of the subregion. -} + -> Gtk.TextIter.TextIter + {- ^ /@end_@/: the end of the subregion. -} + -> m () +regionAddSubregion region _start _end = liftIO $ do + region' <- unsafeManagedPtrCastPtr region + _start' <- unsafeManagedPtrGetPtr _start + _end' <- unsafeManagedPtrGetPtr _end + gtk_source_region_add_subregion region' _start' _end' + touchManagedPtr region + touchManagedPtr _start + touchManagedPtr _end + return () + +#if ENABLE_OVERLOADING +data RegionAddSubregionMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> m ()), MonadIO m, IsRegion a) => O.MethodInfo RegionAddSubregionMethodInfo a signature where + overloadedMethod _ = regionAddSubregion + +#endif + +-- method Region::get_bounds +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "region", argType = TInterface (Name {namespace = "GtkSource", name = "Region"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceRegion.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "iterator to initialize with the start of @region,\n or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "iterator to initialize with the end of @region,\n or %NULL.", 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_region_get_bounds" gtk_source_region_get_bounds :: + Ptr Region -> -- region : TInterface (Name {namespace = "GtkSource", name = "Region"}) + Ptr Gtk.TextIter.TextIter -> -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + IO CInt + +{- | +Gets the /@start@/ and /@end@/ bounds of the /@region@/. + +/Since: 3.22/ +-} +regionGetBounds :: + (B.CallStack.HasCallStack, MonadIO m, IsRegion a) => + a + {- ^ /@region@/: a 'GI.GtkSource.Objects.Region.Region'. -} + -> m ((Bool, Gtk.TextIter.TextIter, Gtk.TextIter.TextIter)) + {- ^ __Returns:__ 'True' if /@start@/ and /@end@/ have been set successfully (if non-'Nothing'), + or 'False' if the /@region@/ is empty. -} +regionGetBounds region = liftIO $ do + region' <- unsafeManagedPtrCastPtr region + start <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter) + end <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter) + result <- gtk_source_region_get_bounds region' start end + let result' = (/= 0) result + start' <- (wrapBoxed Gtk.TextIter.TextIter) start + end' <- (wrapBoxed Gtk.TextIter.TextIter) end + touchManagedPtr region + return (result', start', end') + +#if ENABLE_OVERLOADING +data RegionGetBoundsMethodInfo +instance (signature ~ (m ((Bool, Gtk.TextIter.TextIter, Gtk.TextIter.TextIter))), MonadIO m, IsRegion a) => O.MethodInfo RegionGetBoundsMethodInfo a signature where + overloadedMethod _ = regionGetBounds + +#endif + +-- method Region::get_buffer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "region", argType = TInterface (Name {namespace = "GtkSource", name = "Region"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceRegion.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "TextBuffer"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_region_get_buffer" gtk_source_region_get_buffer :: + Ptr Region -> -- region : TInterface (Name {namespace = "GtkSource", name = "Region"}) + IO (Ptr Gtk.TextBuffer.TextBuffer) + +{- | +/No description available in the introspection data./ + +/Since: 3.22/ +-} +regionGetBuffer :: + (B.CallStack.HasCallStack, MonadIO m, IsRegion a) => + a + {- ^ /@region@/: a 'GI.GtkSource.Objects.Region.Region'. -} + -> m (Maybe Gtk.TextBuffer.TextBuffer) + {- ^ __Returns:__ the 'GI.Gtk.Objects.TextBuffer.TextBuffer'. -} +regionGetBuffer region = liftIO $ do + region' <- unsafeManagedPtrCastPtr region + result <- gtk_source_region_get_buffer region' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject Gtk.TextBuffer.TextBuffer) result' + return result'' + touchManagedPtr region + return maybeResult + +#if ENABLE_OVERLOADING +data RegionGetBufferMethodInfo +instance (signature ~ (m (Maybe Gtk.TextBuffer.TextBuffer)), MonadIO m, IsRegion a) => O.MethodInfo RegionGetBufferMethodInfo a signature where + overloadedMethod _ = regionGetBuffer + +#endif + +-- method Region::get_start_region_iter +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "region", argType = TInterface (Name {namespace = "GtkSource", name = "Region"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceRegion.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "GtkSource", name = "RegionIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "iterator to initialize to the first subregion.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_region_get_start_region_iter" gtk_source_region_get_start_region_iter :: + Ptr Region -> -- region : TInterface (Name {namespace = "GtkSource", name = "Region"}) + Ptr GtkSource.RegionIter.RegionIter -> -- iter : TInterface (Name {namespace = "GtkSource", name = "RegionIter"}) + IO () + +{- | +Initializes a 'GI.GtkSource.Structs.RegionIter.RegionIter' to the first subregion of /@region@/. If +/@region@/ is empty, /@iter@/ will be initialized to the end iterator. + +/Since: 3.22/ +-} +regionGetStartRegionIter :: + (B.CallStack.HasCallStack, MonadIO m, IsRegion a) => + a + {- ^ /@region@/: a 'GI.GtkSource.Objects.Region.Region'. -} + -> m (GtkSource.RegionIter.RegionIter) +regionGetStartRegionIter region = liftIO $ do + region' <- unsafeManagedPtrCastPtr region + iter <- callocBytes 24 :: IO (Ptr GtkSource.RegionIter.RegionIter) + gtk_source_region_get_start_region_iter region' iter + iter' <- (wrapPtr GtkSource.RegionIter.RegionIter) iter + touchManagedPtr region + return iter' + +#if ENABLE_OVERLOADING +data RegionGetStartRegionIterMethodInfo +instance (signature ~ (m (GtkSource.RegionIter.RegionIter)), MonadIO m, IsRegion a) => O.MethodInfo RegionGetStartRegionIterMethodInfo a signature where + overloadedMethod _ = regionGetStartRegionIter + +#endif + +-- method Region::intersect_region +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "region1", argType = TInterface (Name {namespace = "GtkSource", name = "Region"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceRegion, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "region2", argType = TInterface (Name {namespace = "GtkSource", name = "Region"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkSourceRegion, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Region"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_region_intersect_region" gtk_source_region_intersect_region :: + Ptr Region -> -- region1 : TInterface (Name {namespace = "GtkSource", name = "Region"}) + Ptr Region -> -- region2 : TInterface (Name {namespace = "GtkSource", name = "Region"}) + IO (Ptr Region) + +{- | +Returns the intersection between /@region1@/ and /@region2@/. /@region1@/ and +/@region2@/ are not modified. + +/Since: 3.22/ +-} +regionIntersectRegion :: + (B.CallStack.HasCallStack, MonadIO m, IsRegion a, IsRegion b) => + a + {- ^ /@region1@/: a 'GI.GtkSource.Objects.Region.Region', or 'Nothing'. -} + -> Maybe (b) + {- ^ /@region2@/: a 'GI.GtkSource.Objects.Region.Region', or 'Nothing'. -} + -> m (Maybe Region) + {- ^ __Returns:__ the intersection as a 'GI.GtkSource.Objects.Region.Region' + object. -} +regionIntersectRegion region1 region2 = liftIO $ do + region1' <- unsafeManagedPtrCastPtr region1 + maybeRegion2 <- case region2 of + Nothing -> return nullPtr + Just jRegion2 -> do + jRegion2' <- unsafeManagedPtrCastPtr jRegion2 + return jRegion2' + result <- gtk_source_region_intersect_region region1' maybeRegion2 + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Region) result' + return result'' + touchManagedPtr region1 + whenJust region2 touchManagedPtr + return maybeResult + +#if ENABLE_OVERLOADING +data RegionIntersectRegionMethodInfo +instance (signature ~ (Maybe (b) -> m (Maybe Region)), MonadIO m, IsRegion a, IsRegion b) => O.MethodInfo RegionIntersectRegionMethodInfo a signature where + overloadedMethod _ = regionIntersectRegion + +#endif + +-- method Region::intersect_subregion +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "region", argType = TInterface (Name {namespace = "GtkSource", name = "Region"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceRegion.", 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 "the start of the subregion.", 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 "the end of the subregion.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Region"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_region_intersect_subregion" gtk_source_region_intersect_subregion :: + Ptr Region -> -- region : TInterface (Name {namespace = "GtkSource", name = "Region"}) + Ptr Gtk.TextIter.TextIter -> -- _start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- _end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + IO (Ptr Region) + +{- | +Returns the intersection between /@region@/ and the subregion delimited by +/@start_@/ and /@end_@/. /@region@/ is not modified. + +/Since: 3.22/ +-} +regionIntersectSubregion :: + (B.CallStack.HasCallStack, MonadIO m, IsRegion a) => + a + {- ^ /@region@/: a 'GI.GtkSource.Objects.Region.Region'. -} + -> Gtk.TextIter.TextIter + {- ^ /@start_@/: the start of the subregion. -} + -> Gtk.TextIter.TextIter + {- ^ /@end_@/: the end of the subregion. -} + -> m (Maybe Region) + {- ^ __Returns:__ the intersection as a new + 'GI.GtkSource.Objects.Region.Region'. -} +regionIntersectSubregion region _start _end = liftIO $ do + region' <- unsafeManagedPtrCastPtr region + _start' <- unsafeManagedPtrGetPtr _start + _end' <- unsafeManagedPtrGetPtr _end + result <- gtk_source_region_intersect_subregion region' _start' _end' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Region) result' + return result'' + touchManagedPtr region + touchManagedPtr _start + touchManagedPtr _end + return maybeResult + +#if ENABLE_OVERLOADING +data RegionIntersectSubregionMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> m (Maybe Region)), MonadIO m, IsRegion a) => O.MethodInfo RegionIntersectSubregionMethodInfo a signature where + overloadedMethod _ = regionIntersectSubregion + +#endif + +-- method Region::is_empty +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "region", argType = TInterface (Name {namespace = "GtkSource", name = "Region"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceRegion, 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_region_is_empty" gtk_source_region_is_empty :: + Ptr Region -> -- region : TInterface (Name {namespace = "GtkSource", name = "Region"}) + IO CInt + +{- | +Returns whether the /@region@/ is empty. A 'Nothing' /@region@/ is considered empty. + +/Since: 3.22/ +-} +regionIsEmpty :: + (B.CallStack.HasCallStack, MonadIO m, IsRegion a) => + a + {- ^ /@region@/: a 'GI.GtkSource.Objects.Region.Region', or 'Nothing'. -} + -> m Bool + {- ^ __Returns:__ whether the /@region@/ is empty. -} +regionIsEmpty region = liftIO $ do + region' <- unsafeManagedPtrCastPtr region + result <- gtk_source_region_is_empty region' + let result' = (/= 0) result + touchManagedPtr region + return result' + +#if ENABLE_OVERLOADING +data RegionIsEmptyMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsRegion a) => O.MethodInfo RegionIsEmptyMethodInfo a signature where + overloadedMethod _ = regionIsEmpty + +#endif + +-- method Region::subtract_region +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "region", argType = TInterface (Name {namespace = "GtkSource", name = "Region"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceRegion.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "region_to_subtract", argType = TInterface (Name {namespace = "GtkSource", name = "Region"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the #GtkSourceRegion to subtract from\n @region, 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_region_subtract_region" gtk_source_region_subtract_region :: + Ptr Region -> -- region : TInterface (Name {namespace = "GtkSource", name = "Region"}) + Ptr Region -> -- region_to_subtract : TInterface (Name {namespace = "GtkSource", name = "Region"}) + IO () + +{- | +Subtracts /@regionToSubtract@/ from /@region@/. /@regionToSubtract@/ is not +modified. + +/Since: 3.22/ +-} +regionSubtractRegion :: + (B.CallStack.HasCallStack, MonadIO m, IsRegion a, IsRegion b) => + a + {- ^ /@region@/: a 'GI.GtkSource.Objects.Region.Region'. -} + -> Maybe (b) + {- ^ /@regionToSubtract@/: the 'GI.GtkSource.Objects.Region.Region' to subtract from + /@region@/, or 'Nothing'. -} + -> m () +regionSubtractRegion region regionToSubtract = liftIO $ do + region' <- unsafeManagedPtrCastPtr region + maybeRegionToSubtract <- case regionToSubtract of + Nothing -> return nullPtr + Just jRegionToSubtract -> do + jRegionToSubtract' <- unsafeManagedPtrCastPtr jRegionToSubtract + return jRegionToSubtract' + gtk_source_region_subtract_region region' maybeRegionToSubtract + touchManagedPtr region + whenJust regionToSubtract touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data RegionSubtractRegionMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsRegion a, IsRegion b) => O.MethodInfo RegionSubtractRegionMethodInfo a signature where + overloadedMethod _ = regionSubtractRegion + +#endif + +-- method Region::subtract_subregion +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "region", argType = TInterface (Name {namespace = "GtkSource", name = "Region"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceRegion.", 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 "the start of the subregion.", 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 "the end of the subregion.", 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_region_subtract_subregion" gtk_source_region_subtract_subregion :: + Ptr Region -> -- region : TInterface (Name {namespace = "GtkSource", name = "Region"}) + Ptr Gtk.TextIter.TextIter -> -- _start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- _end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + IO () + +{- | +Subtracts the subregion delimited by /@start_@/ and /@end_@/ from /@region@/. + +/Since: 3.22/ +-} +regionSubtractSubregion :: + (B.CallStack.HasCallStack, MonadIO m, IsRegion a) => + a + {- ^ /@region@/: a 'GI.GtkSource.Objects.Region.Region'. -} + -> Gtk.TextIter.TextIter + {- ^ /@start_@/: the start of the subregion. -} + -> Gtk.TextIter.TextIter + {- ^ /@end_@/: the end of the subregion. -} + -> m () +regionSubtractSubregion region _start _end = liftIO $ do + region' <- unsafeManagedPtrCastPtr region + _start' <- unsafeManagedPtrGetPtr _start + _end' <- unsafeManagedPtrGetPtr _end + gtk_source_region_subtract_subregion region' _start' _end' + touchManagedPtr region + touchManagedPtr _start + touchManagedPtr _end + return () + +#if ENABLE_OVERLOADING +data RegionSubtractSubregionMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> m ()), MonadIO m, IsRegion a) => O.MethodInfo RegionSubtractSubregionMethodInfo a signature where + overloadedMethod _ = regionSubtractSubregion + +#endif + +-- method Region::to_string +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "region", argType = TInterface (Name {namespace = "GtkSource", name = "Region"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceRegion.", 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_region_to_string" gtk_source_region_to_string :: + Ptr Region -> -- region : TInterface (Name {namespace = "GtkSource", name = "Region"}) + IO CString + +{- | +Gets a string represention of /@region@/, for debugging purposes. + +The returned string contains the character offsets of the subregions. It +doesn\'t include a newline character at the end of the string. + +/Since: 3.22/ +-} +regionToString :: + (B.CallStack.HasCallStack, MonadIO m, IsRegion a) => + a + {- ^ /@region@/: a 'GI.GtkSource.Objects.Region.Region'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ a string represention of /@region@/. Free + with 'GI.GLib.Functions.free' when no longer needed. -} +regionToString region = liftIO $ do + region' <- unsafeManagedPtrCastPtr region + result <- gtk_source_region_to_string region' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + freeMem result' + return result'' + touchManagedPtr region + return maybeResult + +#if ENABLE_OVERLOADING +data RegionToStringMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsRegion a) => O.MethodInfo RegionToStringMethodInfo a signature where + overloadedMethod _ = regionToString + +#endif + + diff --git a/GI/GtkSource/Objects/Region.hs-boot b/GI/GtkSource/Objects/Region.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/Region.hs-boot @@ -0,0 +1,65 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.Region 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 Region = Region (ManagedPtr Region) +instance GObject Region where +class (GObject o, O.IsDescendantOf Region o) => IsRegion o +instance (GObject o, O.IsDescendantOf Region o) => IsRegion o +instance O.HasParentTypes Region +#if ENABLE_OVERLOADING +data RegionBufferPropertyInfo +#endif +#if ENABLE_OVERLOADING +data RegionAddRegionMethodInfo +#endif +#if ENABLE_OVERLOADING +data RegionAddSubregionMethodInfo +#endif +#if ENABLE_OVERLOADING +data RegionGetBoundsMethodInfo +#endif +#if ENABLE_OVERLOADING +data RegionGetBufferMethodInfo +#endif +#if ENABLE_OVERLOADING +data RegionGetStartRegionIterMethodInfo +#endif +#if ENABLE_OVERLOADING +data RegionIntersectRegionMethodInfo +#endif +#if ENABLE_OVERLOADING +data RegionIntersectSubregionMethodInfo +#endif +#if ENABLE_OVERLOADING +data RegionIsEmptyMethodInfo +#endif +#if ENABLE_OVERLOADING +data RegionSubtractRegionMethodInfo +#endif +#if ENABLE_OVERLOADING +data RegionSubtractSubregionMethodInfo +#endif +#if ENABLE_OVERLOADING +data RegionToStringMethodInfo +#endif diff --git a/GI/GtkSource/Objects/SearchContext.hs b/GI/GtkSource/Objects/SearchContext.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/SearchContext.hs @@ -0,0 +1,1984 @@ + + +{- | +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.SearchContext + ( + +-- * Exported types + SearchContext(..) , + IsSearchContext , + toSearchContext , + noSearchContext , + + + -- * Methods +-- ** backward #method:backward# + +#if ENABLE_OVERLOADING + SearchContextBackwardMethodInfo , +#endif + searchContextBackward , + + +-- ** backward2 #method:backward2# + +#if ENABLE_OVERLOADING + SearchContextBackward2MethodInfo , +#endif + searchContextBackward2 , + + +-- ** backwardAsync #method:backwardAsync# + +#if ENABLE_OVERLOADING + SearchContextBackwardAsyncMethodInfo , +#endif + searchContextBackwardAsync , + + +-- ** backwardFinish #method:backwardFinish# + +#if ENABLE_OVERLOADING + SearchContextBackwardFinishMethodInfo , +#endif + searchContextBackwardFinish , + + +-- ** backwardFinish2 #method:backwardFinish2# + +#if ENABLE_OVERLOADING + SearchContextBackwardFinish2MethodInfo , +#endif + searchContextBackwardFinish2 , + + +-- ** forward #method:forward# + +#if ENABLE_OVERLOADING + SearchContextForwardMethodInfo , +#endif + searchContextForward , + + +-- ** forward2 #method:forward2# + +#if ENABLE_OVERLOADING + SearchContextForward2MethodInfo , +#endif + searchContextForward2 , + + +-- ** forwardAsync #method:forwardAsync# + +#if ENABLE_OVERLOADING + SearchContextForwardAsyncMethodInfo , +#endif + searchContextForwardAsync , + + +-- ** forwardFinish #method:forwardFinish# + +#if ENABLE_OVERLOADING + SearchContextForwardFinishMethodInfo , +#endif + searchContextForwardFinish , + + +-- ** forwardFinish2 #method:forwardFinish2# + +#if ENABLE_OVERLOADING + SearchContextForwardFinish2MethodInfo , +#endif + searchContextForwardFinish2 , + + +-- ** getBuffer #method:getBuffer# + +#if ENABLE_OVERLOADING + SearchContextGetBufferMethodInfo , +#endif + searchContextGetBuffer , + + +-- ** getHighlight #method:getHighlight# + +#if ENABLE_OVERLOADING + SearchContextGetHighlightMethodInfo , +#endif + searchContextGetHighlight , + + +-- ** getMatchStyle #method:getMatchStyle# + +#if ENABLE_OVERLOADING + SearchContextGetMatchStyleMethodInfo , +#endif + searchContextGetMatchStyle , + + +-- ** getOccurrencePosition #method:getOccurrencePosition# + +#if ENABLE_OVERLOADING + SearchContextGetOccurrencePositionMethodInfo, +#endif + searchContextGetOccurrencePosition , + + +-- ** getOccurrencesCount #method:getOccurrencesCount# + +#if ENABLE_OVERLOADING + SearchContextGetOccurrencesCountMethodInfo, +#endif + searchContextGetOccurrencesCount , + + +-- ** getRegexError #method:getRegexError# + +#if ENABLE_OVERLOADING + SearchContextGetRegexErrorMethodInfo , +#endif + searchContextGetRegexError , + + +-- ** getSettings #method:getSettings# + +#if ENABLE_OVERLOADING + SearchContextGetSettingsMethodInfo , +#endif + searchContextGetSettings , + + +-- ** new #method:new# + + searchContextNew , + + +-- ** replace #method:replace# + +#if ENABLE_OVERLOADING + SearchContextReplaceMethodInfo , +#endif + searchContextReplace , + + +-- ** replace2 #method:replace2# + +#if ENABLE_OVERLOADING + SearchContextReplace2MethodInfo , +#endif + searchContextReplace2 , + + +-- ** replaceAll #method:replaceAll# + +#if ENABLE_OVERLOADING + SearchContextReplaceAllMethodInfo , +#endif + searchContextReplaceAll , + + +-- ** setHighlight #method:setHighlight# + +#if ENABLE_OVERLOADING + SearchContextSetHighlightMethodInfo , +#endif + searchContextSetHighlight , + + +-- ** setMatchStyle #method:setMatchStyle# + +#if ENABLE_OVERLOADING + SearchContextSetMatchStyleMethodInfo , +#endif + searchContextSetMatchStyle , + + +-- ** setSettings #method:setSettings# + +#if ENABLE_OVERLOADING + SearchContextSetSettingsMethodInfo , +#endif + searchContextSetSettings , + + + + + -- * Properties +-- ** buffer #attr:buffer# +{- | The 'GI.GtkSource.Objects.Buffer.Buffer' associated to the search context. + +/Since: 3.10/ +-} +#if ENABLE_OVERLOADING + SearchContextBufferPropertyInfo , +#endif + constructSearchContextBuffer , + getSearchContextBuffer , +#if ENABLE_OVERLOADING + searchContextBuffer , +#endif + + +-- ** highlight #attr:highlight# +{- | Highlight the search occurrences. + +/Since: 3.10/ +-} +#if ENABLE_OVERLOADING + SearchContextHighlightPropertyInfo , +#endif + constructSearchContextHighlight , + getSearchContextHighlight , +#if ENABLE_OVERLOADING + searchContextHighlight , +#endif + setSearchContextHighlight , + + +-- ** matchStyle #attr:matchStyle# +{- | A 'GI.GtkSource.Objects.Style.Style', or 'Nothing' for theme\'s scheme default style. + +/Since: 3.16/ +-} +#if ENABLE_OVERLOADING + SearchContextMatchStylePropertyInfo , +#endif + clearSearchContextMatchStyle , + constructSearchContextMatchStyle , + getSearchContextMatchStyle , +#if ENABLE_OVERLOADING + searchContextMatchStyle , +#endif + setSearchContextMatchStyle , + + +-- ** occurrencesCount #attr:occurrencesCount# +{- | The total number of search occurrences. If the search is disabled, +the value is 0. If the buffer is not already fully scanned, the value +is -1. + +/Since: 3.10/ +-} +#if ENABLE_OVERLOADING + SearchContextOccurrencesCountPropertyInfo, +#endif + getSearchContextOccurrencesCount , +#if ENABLE_OVERLOADING + searchContextOccurrencesCount , +#endif + + +-- ** regexError #attr:regexError# +{- | If the regex search pattern doesn\'t follow all the rules, this +property will be set. If the pattern is valid, the value is 'Nothing'. + +Free with 'GI.GLib.Structs.Error.errorFree'. + +/Since: 3.10/ +-} +#if ENABLE_OVERLOADING + SearchContextRegexErrorPropertyInfo , +#endif + getSearchContextRegexError , +#if ENABLE_OVERLOADING + searchContextRegexError , +#endif + + +-- ** settings #attr:settings# +{- | The 'GI.GtkSource.Objects.SearchSettings.SearchSettings' associated to the search context. + +/Since: 3.10/ +-} +#if ENABLE_OVERLOADING + SearchContextSettingsPropertyInfo , +#endif + clearSearchContextSettings , + constructSearchContextSettings , + getSearchContextSettings , +#if ENABLE_OVERLOADING + searchContextSettings , +#endif + setSearchContextSettings , + + + + + ) 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.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Gtk.Structs.TextIter as Gtk.TextIter +import {-# SOURCE #-} qualified GI.GtkSource.Objects.Buffer as GtkSource.Buffer +import {-# SOURCE #-} qualified GI.GtkSource.Objects.SearchSettings as GtkSource.SearchSettings +import {-# SOURCE #-} qualified GI.GtkSource.Objects.Style as GtkSource.Style + +-- | Memory-managed wrapper type. +newtype SearchContext = SearchContext (ManagedPtr SearchContext) +foreign import ccall "gtk_source_search_context_get_type" + c_gtk_source_search_context_get_type :: IO GType + +instance GObject SearchContext where + gobjectType = c_gtk_source_search_context_get_type + + +-- | Type class for types which can be safely cast to `SearchContext`, for instance with `toSearchContext`. +class (GObject o, O.IsDescendantOf SearchContext o) => IsSearchContext o +instance (GObject o, O.IsDescendantOf SearchContext o) => IsSearchContext o + +instance O.HasParentTypes SearchContext +type instance O.ParentTypes SearchContext = '[GObject.Object.Object] + +-- | Cast to `SearchContext`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toSearchContext :: (MonadIO m, IsSearchContext o) => o -> m SearchContext +toSearchContext = liftIO . unsafeCastTo SearchContext + +-- | A convenience alias for `Nothing` :: `Maybe` `SearchContext`. +noSearchContext :: Maybe SearchContext +noSearchContext = Nothing + +#if ENABLE_OVERLOADING +type family ResolveSearchContextMethod (t :: Symbol) (o :: *) :: * where + ResolveSearchContextMethod "backward" o = SearchContextBackwardMethodInfo + ResolveSearchContextMethod "backward2" o = SearchContextBackward2MethodInfo + ResolveSearchContextMethod "backwardAsync" o = SearchContextBackwardAsyncMethodInfo + ResolveSearchContextMethod "backwardFinish" o = SearchContextBackwardFinishMethodInfo + ResolveSearchContextMethod "backwardFinish2" o = SearchContextBackwardFinish2MethodInfo + ResolveSearchContextMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveSearchContextMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveSearchContextMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveSearchContextMethod "forward" o = SearchContextForwardMethodInfo + ResolveSearchContextMethod "forward2" o = SearchContextForward2MethodInfo + ResolveSearchContextMethod "forwardAsync" o = SearchContextForwardAsyncMethodInfo + ResolveSearchContextMethod "forwardFinish" o = SearchContextForwardFinishMethodInfo + ResolveSearchContextMethod "forwardFinish2" o = SearchContextForwardFinish2MethodInfo + ResolveSearchContextMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveSearchContextMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveSearchContextMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveSearchContextMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveSearchContextMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveSearchContextMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveSearchContextMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveSearchContextMethod "replace" o = SearchContextReplaceMethodInfo + ResolveSearchContextMethod "replace2" o = SearchContextReplace2MethodInfo + ResolveSearchContextMethod "replaceAll" o = SearchContextReplaceAllMethodInfo + ResolveSearchContextMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveSearchContextMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveSearchContextMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveSearchContextMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveSearchContextMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveSearchContextMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveSearchContextMethod "getBuffer" o = SearchContextGetBufferMethodInfo + ResolveSearchContextMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveSearchContextMethod "getHighlight" o = SearchContextGetHighlightMethodInfo + ResolveSearchContextMethod "getMatchStyle" o = SearchContextGetMatchStyleMethodInfo + ResolveSearchContextMethod "getOccurrencePosition" o = SearchContextGetOccurrencePositionMethodInfo + ResolveSearchContextMethod "getOccurrencesCount" o = SearchContextGetOccurrencesCountMethodInfo + ResolveSearchContextMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveSearchContextMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveSearchContextMethod "getRegexError" o = SearchContextGetRegexErrorMethodInfo + ResolveSearchContextMethod "getSettings" o = SearchContextGetSettingsMethodInfo + ResolveSearchContextMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveSearchContextMethod "setHighlight" o = SearchContextSetHighlightMethodInfo + ResolveSearchContextMethod "setMatchStyle" o = SearchContextSetMatchStyleMethodInfo + ResolveSearchContextMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveSearchContextMethod "setSettings" o = SearchContextSetSettingsMethodInfo + ResolveSearchContextMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSearchContextMethod t SearchContext, O.MethodInfo info SearchContext p) => OL.IsLabel t (SearchContext -> 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 + +-- VVV Prop "buffer" + -- Type: TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@buffer@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' searchContext #buffer +@ +-} +getSearchContextBuffer :: (MonadIO m, IsSearchContext o) => o -> m GtkSource.Buffer.Buffer +getSearchContextBuffer obj = liftIO $ checkUnexpectedNothing "getSearchContextBuffer" $ B.Properties.getObjectPropertyObject obj "buffer" GtkSource.Buffer.Buffer + +{- | +Construct a `GValueConstruct` with valid value for the “@buffer@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSearchContextBuffer :: (IsSearchContext o, GtkSource.Buffer.IsBuffer a) => a -> IO (GValueConstruct o) +constructSearchContextBuffer val = B.Properties.constructObjectPropertyObject "buffer" (Just val) + +#if ENABLE_OVERLOADING +data SearchContextBufferPropertyInfo +instance AttrInfo SearchContextBufferPropertyInfo where + type AttrAllowedOps SearchContextBufferPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint SearchContextBufferPropertyInfo = GtkSource.Buffer.IsBuffer + type AttrBaseTypeConstraint SearchContextBufferPropertyInfo = IsSearchContext + type AttrGetType SearchContextBufferPropertyInfo = GtkSource.Buffer.Buffer + type AttrLabel SearchContextBufferPropertyInfo = "buffer" + type AttrOrigin SearchContextBufferPropertyInfo = SearchContext + attrGet _ = getSearchContextBuffer + attrSet _ = undefined + attrConstruct _ = constructSearchContextBuffer + attrClear _ = undefined +#endif + +-- VVV Prop "highlight" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@highlight@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' searchContext #highlight +@ +-} +getSearchContextHighlight :: (MonadIO m, IsSearchContext o) => o -> m Bool +getSearchContextHighlight obj = liftIO $ B.Properties.getObjectPropertyBool obj "highlight" + +{- | +Set the value of the “@highlight@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' searchContext [ #highlight 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSearchContextHighlight :: (MonadIO m, IsSearchContext o) => o -> Bool -> m () +setSearchContextHighlight obj val = liftIO $ B.Properties.setObjectPropertyBool obj "highlight" val + +{- | +Construct a `GValueConstruct` with valid value for the “@highlight@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSearchContextHighlight :: (IsSearchContext o) => Bool -> IO (GValueConstruct o) +constructSearchContextHighlight val = B.Properties.constructObjectPropertyBool "highlight" val + +#if ENABLE_OVERLOADING +data SearchContextHighlightPropertyInfo +instance AttrInfo SearchContextHighlightPropertyInfo where + type AttrAllowedOps SearchContextHighlightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SearchContextHighlightPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SearchContextHighlightPropertyInfo = IsSearchContext + type AttrGetType SearchContextHighlightPropertyInfo = Bool + type AttrLabel SearchContextHighlightPropertyInfo = "highlight" + type AttrOrigin SearchContextHighlightPropertyInfo = SearchContext + attrGet _ = getSearchContextHighlight + attrSet _ = setSearchContextHighlight + attrConstruct _ = constructSearchContextHighlight + attrClear _ = undefined +#endif + +-- VVV Prop "match-style" + -- Type: TInterface (Name {namespace = "GtkSource", name = "Style"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just True) + +{- | +Get the value of the “@match-style@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' searchContext #matchStyle +@ +-} +getSearchContextMatchStyle :: (MonadIO m, IsSearchContext o) => o -> m GtkSource.Style.Style +getSearchContextMatchStyle obj = liftIO $ checkUnexpectedNothing "getSearchContextMatchStyle" $ B.Properties.getObjectPropertyObject obj "match-style" GtkSource.Style.Style + +{- | +Set the value of the “@match-style@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' searchContext [ #matchStyle 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSearchContextMatchStyle :: (MonadIO m, IsSearchContext o, GtkSource.Style.IsStyle a) => o -> a -> m () +setSearchContextMatchStyle obj val = liftIO $ B.Properties.setObjectPropertyObject obj "match-style" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@match-style@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSearchContextMatchStyle :: (IsSearchContext o, GtkSource.Style.IsStyle a) => a -> IO (GValueConstruct o) +constructSearchContextMatchStyle val = B.Properties.constructObjectPropertyObject "match-style" (Just val) + +{- | +Set the value of the “@match-style@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #matchStyle +@ +-} +clearSearchContextMatchStyle :: (MonadIO m, IsSearchContext o) => o -> m () +clearSearchContextMatchStyle obj = liftIO $ B.Properties.setObjectPropertyObject obj "match-style" (Nothing :: Maybe GtkSource.Style.Style) + +#if ENABLE_OVERLOADING +data SearchContextMatchStylePropertyInfo +instance AttrInfo SearchContextMatchStylePropertyInfo where + type AttrAllowedOps SearchContextMatchStylePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint SearchContextMatchStylePropertyInfo = GtkSource.Style.IsStyle + type AttrBaseTypeConstraint SearchContextMatchStylePropertyInfo = IsSearchContext + type AttrGetType SearchContextMatchStylePropertyInfo = GtkSource.Style.Style + type AttrLabel SearchContextMatchStylePropertyInfo = "match-style" + type AttrOrigin SearchContextMatchStylePropertyInfo = SearchContext + attrGet _ = getSearchContextMatchStyle + attrSet _ = setSearchContextMatchStyle + attrConstruct _ = constructSearchContextMatchStyle + attrClear _ = clearSearchContextMatchStyle +#endif + +-- VVV Prop "occurrences-count" + -- Type: TBasicType TInt + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@occurrences-count@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' searchContext #occurrencesCount +@ +-} +getSearchContextOccurrencesCount :: (MonadIO m, IsSearchContext o) => o -> m Int32 +getSearchContextOccurrencesCount obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "occurrences-count" + +#if ENABLE_OVERLOADING +data SearchContextOccurrencesCountPropertyInfo +instance AttrInfo SearchContextOccurrencesCountPropertyInfo where + type AttrAllowedOps SearchContextOccurrencesCountPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint SearchContextOccurrencesCountPropertyInfo = (~) () + type AttrBaseTypeConstraint SearchContextOccurrencesCountPropertyInfo = IsSearchContext + type AttrGetType SearchContextOccurrencesCountPropertyInfo = Int32 + type AttrLabel SearchContextOccurrencesCountPropertyInfo = "occurrences-count" + type AttrOrigin SearchContextOccurrencesCountPropertyInfo = SearchContext + attrGet _ = getSearchContextOccurrencesCount + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "regex-error" + -- Type: TBasicType TPtr + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@regex-error@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' searchContext #regexError +@ +-} +getSearchContextRegexError :: (MonadIO m, IsSearchContext o) => o -> m (Ptr ()) +getSearchContextRegexError obj = liftIO $ B.Properties.getObjectPropertyPtr obj "regex-error" + +#if ENABLE_OVERLOADING +data SearchContextRegexErrorPropertyInfo +instance AttrInfo SearchContextRegexErrorPropertyInfo where + type AttrAllowedOps SearchContextRegexErrorPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint SearchContextRegexErrorPropertyInfo = (~) () + type AttrBaseTypeConstraint SearchContextRegexErrorPropertyInfo = IsSearchContext + type AttrGetType SearchContextRegexErrorPropertyInfo = (Ptr ()) + type AttrLabel SearchContextRegexErrorPropertyInfo = "regex-error" + type AttrOrigin SearchContextRegexErrorPropertyInfo = SearchContext + attrGet _ = getSearchContextRegexError + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "settings" + -- Type: TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just True) + +{- | +Get the value of the “@settings@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' searchContext #settings +@ +-} +getSearchContextSettings :: (MonadIO m, IsSearchContext o) => o -> m GtkSource.SearchSettings.SearchSettings +getSearchContextSettings obj = liftIO $ checkUnexpectedNothing "getSearchContextSettings" $ B.Properties.getObjectPropertyObject obj "settings" GtkSource.SearchSettings.SearchSettings + +{- | +Set the value of the “@settings@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' searchContext [ #settings 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSearchContextSettings :: (MonadIO m, IsSearchContext o, GtkSource.SearchSettings.IsSearchSettings a) => o -> a -> m () +setSearchContextSettings obj val = liftIO $ B.Properties.setObjectPropertyObject obj "settings" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@settings@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSearchContextSettings :: (IsSearchContext o, GtkSource.SearchSettings.IsSearchSettings a) => a -> IO (GValueConstruct o) +constructSearchContextSettings val = B.Properties.constructObjectPropertyObject "settings" (Just val) + +{- | +Set the value of the “@settings@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #settings +@ +-} +clearSearchContextSettings :: (MonadIO m, IsSearchContext o) => o -> m () +clearSearchContextSettings obj = liftIO $ B.Properties.setObjectPropertyObject obj "settings" (Nothing :: Maybe GtkSource.SearchSettings.SearchSettings) + +#if ENABLE_OVERLOADING +data SearchContextSettingsPropertyInfo +instance AttrInfo SearchContextSettingsPropertyInfo where + type AttrAllowedOps SearchContextSettingsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint SearchContextSettingsPropertyInfo = GtkSource.SearchSettings.IsSearchSettings + type AttrBaseTypeConstraint SearchContextSettingsPropertyInfo = IsSearchContext + type AttrGetType SearchContextSettingsPropertyInfo = GtkSource.SearchSettings.SearchSettings + type AttrLabel SearchContextSettingsPropertyInfo = "settings" + type AttrOrigin SearchContextSettingsPropertyInfo = SearchContext + attrGet _ = getSearchContextSettings + attrSet _ = setSearchContextSettings + attrConstruct _ = constructSearchContextSettings + attrClear _ = clearSearchContextSettings +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList SearchContext +type instance O.AttributeList SearchContext = SearchContextAttributeList +type SearchContextAttributeList = ('[ '("buffer", SearchContextBufferPropertyInfo), '("highlight", SearchContextHighlightPropertyInfo), '("matchStyle", SearchContextMatchStylePropertyInfo), '("occurrencesCount", SearchContextOccurrencesCountPropertyInfo), '("regexError", SearchContextRegexErrorPropertyInfo), '("settings", SearchContextSettingsPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +searchContextBuffer :: AttrLabelProxy "buffer" +searchContextBuffer = AttrLabelProxy + +searchContextHighlight :: AttrLabelProxy "highlight" +searchContextHighlight = AttrLabelProxy + +searchContextMatchStyle :: AttrLabelProxy "matchStyle" +searchContextMatchStyle = AttrLabelProxy + +searchContextOccurrencesCount :: AttrLabelProxy "occurrencesCount" +searchContextOccurrencesCount = AttrLabelProxy + +searchContextRegexError :: AttrLabelProxy "regexError" +searchContextRegexError = AttrLabelProxy + +searchContextSettings :: AttrLabelProxy "settings" +searchContextSettings = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList SearchContext = SearchContextSignalList +type SearchContextSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method SearchContext::new +-- method type : Constructor +-- 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 = "settings", argType = TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchSettings, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "SearchContext"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_search_context_new" gtk_source_search_context_new :: + Ptr GtkSource.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + Ptr GtkSource.SearchSettings.SearchSettings -> -- settings : TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}) + IO (Ptr SearchContext) + +{- | +Creates a new search context, associated with /@buffer@/, and customized with +/@settings@/. If /@settings@/ is 'Nothing', a new 'GI.GtkSource.Objects.SearchSettings.SearchSettings' object will +be created, that you can retrieve with +'GI.GtkSource.Objects.SearchContext.searchContextGetSettings'. + +/Since: 3.10/ +-} +searchContextNew :: + (B.CallStack.HasCallStack, MonadIO m, GtkSource.Buffer.IsBuffer a, GtkSource.SearchSettings.IsSearchSettings b) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> Maybe (b) + {- ^ /@settings@/: a 'GI.GtkSource.Objects.SearchSettings.SearchSettings', or 'Nothing'. -} + -> m SearchContext + {- ^ __Returns:__ a new search context. -} +searchContextNew buffer settings = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + maybeSettings <- case settings of + Nothing -> return nullPtr + Just jSettings -> do + jSettings' <- unsafeManagedPtrCastPtr jSettings + return jSettings' + result <- gtk_source_search_context_new buffer' maybeSettings + checkUnexpectedReturnNULL "searchContextNew" result + result' <- (wrapObject SearchContext) result + touchManagedPtr buffer + whenJust settings touchManagedPtr + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method SearchContext::backward +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "search", argType = TInterface (Name {namespace = "GtkSource", name = "SearchContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchContext.", 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 "start of search.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "match_start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for start of match, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "match_end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for end of match, or %NULL.", 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_search_context_backward" gtk_source_search_context_backward :: + Ptr SearchContext -> -- search : TInterface (Name {namespace = "GtkSource", name = "SearchContext"}) + Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- match_start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- match_end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + IO CInt + +{-# DEPRECATED searchContextBackward ["(Since version 3.22)","Use 'GI.GtkSource.Objects.SearchContext.searchContextBackward2' instead."] #-} +{- | +Synchronous backward search. It is recommended to use the asynchronous +functions instead, to not block the user interface. However, if you are sure +that the /@buffer@/ is small, this function is more convenient to use. + +/Since: 3.10/ +-} +searchContextBackward :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchContext a) => + a + {- ^ /@search@/: a 'GI.GtkSource.Objects.SearchContext.SearchContext'. -} + -> Gtk.TextIter.TextIter + {- ^ /@iter@/: start of search. -} + -> m ((Bool, Gtk.TextIter.TextIter, Gtk.TextIter.TextIter)) + {- ^ __Returns:__ whether a match was found. -} +searchContextBackward search iter = liftIO $ do + search' <- unsafeManagedPtrCastPtr search + iter' <- unsafeManagedPtrGetPtr iter + matchStart <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter) + matchEnd <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter) + result <- gtk_source_search_context_backward search' iter' matchStart matchEnd + let result' = (/= 0) result + matchStart' <- (wrapBoxed Gtk.TextIter.TextIter) matchStart + matchEnd' <- (wrapBoxed Gtk.TextIter.TextIter) matchEnd + touchManagedPtr search + touchManagedPtr iter + return (result', matchStart', matchEnd') + +#if ENABLE_OVERLOADING +data SearchContextBackwardMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> m ((Bool, Gtk.TextIter.TextIter, Gtk.TextIter.TextIter))), MonadIO m, IsSearchContext a) => O.MethodInfo SearchContextBackwardMethodInfo a signature where + overloadedMethod _ = searchContextBackward + +#endif + +-- method SearchContext::backward2 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "search", argType = TInterface (Name {namespace = "GtkSource", name = "SearchContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchContext.", 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 "start of search.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "match_start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for start of match, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "match_end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for end of match, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "has_wrapped_around", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location to know whether the\n search has wrapped around, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_search_context_backward2" gtk_source_search_context_backward2 :: + Ptr SearchContext -> -- search : TInterface (Name {namespace = "GtkSource", name = "SearchContext"}) + Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- match_start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- match_end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr CInt -> -- has_wrapped_around : TBasicType TBoolean + IO CInt + +{- | +Synchronous backward search. It is recommended to use the asynchronous +functions instead, to not block the user interface. However, if you are sure +that the /@buffer@/ is small, this function is more convenient to use. + +The difference with 'GI.GtkSource.Objects.SearchContext.searchContextBackward' is that the +/@hasWrappedAround@/ out parameter has been added for convenience. + +If the 'GI.GtkSource.Objects.SearchSettings.SearchSettings':@/wrap-around/@ property is 'False', this function +doesn\'t try to wrap around. + +The /@hasWrappedAround@/ out parameter is set independently of whether a match +is found. So if this function returns 'False', /@hasWrappedAround@/ will have +the same value as the 'GI.GtkSource.Objects.SearchSettings.SearchSettings':@/wrap-around/@ property. + +/Since: 3.22/ +-} +searchContextBackward2 :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchContext a) => + a + {- ^ /@search@/: a 'GI.GtkSource.Objects.SearchContext.SearchContext'. -} + -> Gtk.TextIter.TextIter + {- ^ /@iter@/: start of search. -} + -> m ((Bool, Gtk.TextIter.TextIter, Gtk.TextIter.TextIter, Bool)) + {- ^ __Returns:__ whether a match was found. -} +searchContextBackward2 search iter = liftIO $ do + search' <- unsafeManagedPtrCastPtr search + iter' <- unsafeManagedPtrGetPtr iter + matchStart <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter) + matchEnd <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter) + hasWrappedAround <- allocMem :: IO (Ptr CInt) + result <- gtk_source_search_context_backward2 search' iter' matchStart matchEnd hasWrappedAround + let result' = (/= 0) result + matchStart' <- (wrapBoxed Gtk.TextIter.TextIter) matchStart + matchEnd' <- (wrapBoxed Gtk.TextIter.TextIter) matchEnd + hasWrappedAround' <- peek hasWrappedAround + let hasWrappedAround'' = (/= 0) hasWrappedAround' + touchManagedPtr search + touchManagedPtr iter + freeMem hasWrappedAround + return (result', matchStart', matchEnd', hasWrappedAround'') + +#if ENABLE_OVERLOADING +data SearchContextBackward2MethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> m ((Bool, Gtk.TextIter.TextIter, Gtk.TextIter.TextIter, Bool))), MonadIO m, IsSearchContext a) => O.MethodInfo SearchContextBackward2MethodInfo a signature where + overloadedMethod _ = searchContextBackward2 + +#endif + +-- method SearchContext::backward_async +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "search", argType = TInterface (Name {namespace = "GtkSource", name = "SearchContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchContext.", 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 "start of search.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the operation is finished.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to the @callback function.", 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_search_context_backward_async" gtk_source_search_context_backward_async :: + Ptr SearchContext -> -- search : TInterface (Name {namespace = "GtkSource", name = "SearchContext"}) + Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + IO () + +{- | +The asynchronous version of 'GI.GtkSource.Objects.SearchContext.searchContextBackward2'. + +See the documentation of 'GI.GtkSource.Objects.SearchContext.searchContextBackward2' for more +details. + +See the 'GI.Gio.Interfaces.AsyncResult.AsyncResult' documentation to know how to use this function. + +If the operation is cancelled, the /@callback@/ will only be called if +/@cancellable@/ was not 'Nothing'. 'GI.GtkSource.Objects.SearchContext.searchContextBackwardAsync' takes +ownership of /@cancellable@/, so you can unref it after calling this function. + +/Since: 3.10/ +-} +searchContextBackwardAsync :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchContext a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@search@/: a 'GI.GtkSource.Objects.SearchContext.SearchContext'. -} + -> Gtk.TextIter.TextIter + {- ^ /@iter@/: start of search. -} + -> Maybe (b) + {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing'. -} + -> Maybe (Gio.Callbacks.AsyncReadyCallback) + {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the operation is finished. -} + -> m () +searchContextBackwardAsync search iter cancellable callback = liftIO $ do + search' <- unsafeManagedPtrCastPtr search + iter' <- unsafeManagedPtrGetPtr iter + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + maybeCallback <- case callback of + Nothing -> return (castPtrToFunPtr nullPtr) + Just jCallback -> do + ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback)) + jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback)) + poke ptrcallback jCallback' + return jCallback' + let userData = nullPtr + gtk_source_search_context_backward_async search' iter' maybeCancellable maybeCallback userData + touchManagedPtr search + touchManagedPtr iter + whenJust cancellable touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data SearchContextBackwardAsyncMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsSearchContext a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SearchContextBackwardAsyncMethodInfo a signature where + overloadedMethod _ = searchContextBackwardAsync + +#endif + +-- method SearchContext::backward_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "search", argType = TInterface (Name {namespace = "GtkSource", name = "SearchContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchContext.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "match_start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for start of match, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "match_end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for end of match, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "gtk_source_search_context_backward_finish" gtk_source_search_context_backward_finish :: + Ptr SearchContext -> -- search : TInterface (Name {namespace = "GtkSource", name = "SearchContext"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr Gtk.TextIter.TextIter -> -- match_start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- match_end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{-# DEPRECATED searchContextBackwardFinish ["(Since version 3.22)","Use 'GI.GtkSource.Objects.SearchContext.searchContextBackwardFinish2' instead."] #-} +{- | +Finishes a backward search started with +'GI.GtkSource.Objects.SearchContext.searchContextBackwardAsync'. + +/Since: 3.10/ +-} +searchContextBackwardFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchContext a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@search@/: a 'GI.GtkSource.Objects.SearchContext.SearchContext'. -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -} + -> m ((Gtk.TextIter.TextIter, Gtk.TextIter.TextIter)) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +searchContextBackwardFinish search result_ = liftIO $ do + search' <- unsafeManagedPtrCastPtr search + result_' <- unsafeManagedPtrCastPtr result_ + matchStart <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter) + matchEnd <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter) + onException (do + _ <- propagateGError $ gtk_source_search_context_backward_finish search' result_' matchStart matchEnd + matchStart' <- (wrapBoxed Gtk.TextIter.TextIter) matchStart + matchEnd' <- (wrapBoxed Gtk.TextIter.TextIter) matchEnd + touchManagedPtr search + touchManagedPtr result_ + return (matchStart', matchEnd') + ) (do + freeMem matchStart + freeMem matchEnd + ) + +#if ENABLE_OVERLOADING +data SearchContextBackwardFinishMethodInfo +instance (signature ~ (b -> m ((Gtk.TextIter.TextIter, Gtk.TextIter.TextIter))), MonadIO m, IsSearchContext a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo SearchContextBackwardFinishMethodInfo a signature where + overloadedMethod _ = searchContextBackwardFinish + +#endif + +-- method SearchContext::backward_finish2 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "search", argType = TInterface (Name {namespace = "GtkSource", name = "SearchContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchContext.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "match_start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for start of match, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "match_end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for end of match, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "has_wrapped_around", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location to know whether the\n search has wrapped around, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "gtk_source_search_context_backward_finish2" gtk_source_search_context_backward_finish2 :: + Ptr SearchContext -> -- search : TInterface (Name {namespace = "GtkSource", name = "SearchContext"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr Gtk.TextIter.TextIter -> -- match_start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- match_end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr CInt -> -- has_wrapped_around : TBasicType TBoolean + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Finishes a backward search started with +'GI.GtkSource.Objects.SearchContext.searchContextBackwardAsync'. + +See the documentation of 'GI.GtkSource.Objects.SearchContext.searchContextBackward2' for more +details. + +/Since: 3.22/ +-} +searchContextBackwardFinish2 :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchContext a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@search@/: a 'GI.GtkSource.Objects.SearchContext.SearchContext'. -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -} + -> m ((Gtk.TextIter.TextIter, Gtk.TextIter.TextIter, Bool)) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +searchContextBackwardFinish2 search result_ = liftIO $ do + search' <- unsafeManagedPtrCastPtr search + result_' <- unsafeManagedPtrCastPtr result_ + matchStart <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter) + matchEnd <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter) + hasWrappedAround <- allocMem :: IO (Ptr CInt) + onException (do + _ <- propagateGError $ gtk_source_search_context_backward_finish2 search' result_' matchStart matchEnd hasWrappedAround + matchStart' <- (wrapBoxed Gtk.TextIter.TextIter) matchStart + matchEnd' <- (wrapBoxed Gtk.TextIter.TextIter) matchEnd + hasWrappedAround' <- peek hasWrappedAround + let hasWrappedAround'' = (/= 0) hasWrappedAround' + touchManagedPtr search + touchManagedPtr result_ + freeMem hasWrappedAround + return (matchStart', matchEnd', hasWrappedAround'') + ) (do + freeMem matchStart + freeMem matchEnd + freeMem hasWrappedAround + ) + +#if ENABLE_OVERLOADING +data SearchContextBackwardFinish2MethodInfo +instance (signature ~ (b -> m ((Gtk.TextIter.TextIter, Gtk.TextIter.TextIter, Bool))), MonadIO m, IsSearchContext a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo SearchContextBackwardFinish2MethodInfo a signature where + overloadedMethod _ = searchContextBackwardFinish2 + +#endif + +-- method SearchContext::forward +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "search", argType = TInterface (Name {namespace = "GtkSource", name = "SearchContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchContext.", 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 "start of search.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "match_start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for start of match, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "match_end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for end of match, or %NULL.", 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_search_context_forward" gtk_source_search_context_forward :: + Ptr SearchContext -> -- search : TInterface (Name {namespace = "GtkSource", name = "SearchContext"}) + Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- match_start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- match_end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + IO CInt + +{-# DEPRECATED searchContextForward ["(Since version 3.22)","Use 'GI.GtkSource.Objects.SearchContext.searchContextForward2' instead."] #-} +{- | +Synchronous forward search. It is recommended to use the asynchronous +functions instead, to not block the user interface. However, if you are sure +that the /@buffer@/ is small, this function is more convenient to use. + +/Since: 3.10/ +-} +searchContextForward :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchContext a) => + a + {- ^ /@search@/: a 'GI.GtkSource.Objects.SearchContext.SearchContext'. -} + -> Gtk.TextIter.TextIter + {- ^ /@iter@/: start of search. -} + -> m ((Bool, Gtk.TextIter.TextIter, Gtk.TextIter.TextIter)) + {- ^ __Returns:__ whether a match was found. -} +searchContextForward search iter = liftIO $ do + search' <- unsafeManagedPtrCastPtr search + iter' <- unsafeManagedPtrGetPtr iter + matchStart <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter) + matchEnd <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter) + result <- gtk_source_search_context_forward search' iter' matchStart matchEnd + let result' = (/= 0) result + matchStart' <- (wrapBoxed Gtk.TextIter.TextIter) matchStart + matchEnd' <- (wrapBoxed Gtk.TextIter.TextIter) matchEnd + touchManagedPtr search + touchManagedPtr iter + return (result', matchStart', matchEnd') + +#if ENABLE_OVERLOADING +data SearchContextForwardMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> m ((Bool, Gtk.TextIter.TextIter, Gtk.TextIter.TextIter))), MonadIO m, IsSearchContext a) => O.MethodInfo SearchContextForwardMethodInfo a signature where + overloadedMethod _ = searchContextForward + +#endif + +-- method SearchContext::forward2 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "search", argType = TInterface (Name {namespace = "GtkSource", name = "SearchContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchContext.", 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 "start of search.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "match_start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for start of match, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "match_end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for end of match, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "has_wrapped_around", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location to know whether the\n search has wrapped around, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_search_context_forward2" gtk_source_search_context_forward2 :: + Ptr SearchContext -> -- search : TInterface (Name {namespace = "GtkSource", name = "SearchContext"}) + Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- match_start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- match_end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr CInt -> -- has_wrapped_around : TBasicType TBoolean + IO CInt + +{- | +Synchronous forward search. It is recommended to use the asynchronous +functions instead, to not block the user interface. However, if you are sure +that the /@buffer@/ is small, this function is more convenient to use. + +The difference with 'GI.GtkSource.Objects.SearchContext.searchContextForward' is that the +/@hasWrappedAround@/ out parameter has been added for convenience. + +If the 'GI.GtkSource.Objects.SearchSettings.SearchSettings':@/wrap-around/@ property is 'False', this function +doesn\'t try to wrap around. + +The /@hasWrappedAround@/ out parameter is set independently of whether a match +is found. So if this function returns 'False', /@hasWrappedAround@/ will have +the same value as the 'GI.GtkSource.Objects.SearchSettings.SearchSettings':@/wrap-around/@ property. + +/Since: 3.22/ +-} +searchContextForward2 :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchContext a) => + a + {- ^ /@search@/: a 'GI.GtkSource.Objects.SearchContext.SearchContext'. -} + -> Gtk.TextIter.TextIter + {- ^ /@iter@/: start of search. -} + -> m ((Bool, Gtk.TextIter.TextIter, Gtk.TextIter.TextIter, Bool)) + {- ^ __Returns:__ whether a match was found. -} +searchContextForward2 search iter = liftIO $ do + search' <- unsafeManagedPtrCastPtr search + iter' <- unsafeManagedPtrGetPtr iter + matchStart <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter) + matchEnd <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter) + hasWrappedAround <- allocMem :: IO (Ptr CInt) + result <- gtk_source_search_context_forward2 search' iter' matchStart matchEnd hasWrappedAround + let result' = (/= 0) result + matchStart' <- (wrapBoxed Gtk.TextIter.TextIter) matchStart + matchEnd' <- (wrapBoxed Gtk.TextIter.TextIter) matchEnd + hasWrappedAround' <- peek hasWrappedAround + let hasWrappedAround'' = (/= 0) hasWrappedAround' + touchManagedPtr search + touchManagedPtr iter + freeMem hasWrappedAround + return (result', matchStart', matchEnd', hasWrappedAround'') + +#if ENABLE_OVERLOADING +data SearchContextForward2MethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> m ((Bool, Gtk.TextIter.TextIter, Gtk.TextIter.TextIter, Bool))), MonadIO m, IsSearchContext a) => O.MethodInfo SearchContextForward2MethodInfo a signature where + overloadedMethod _ = searchContextForward2 + +#endif + +-- method SearchContext::forward_async +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "search", argType = TInterface (Name {namespace = "GtkSource", name = "SearchContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchContext.", 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 "start of search.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the operation is finished.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to the @callback function.", 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_search_context_forward_async" gtk_source_search_context_forward_async :: + Ptr SearchContext -> -- search : TInterface (Name {namespace = "GtkSource", name = "SearchContext"}) + Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + IO () + +{- | +The asynchronous version of 'GI.GtkSource.Objects.SearchContext.searchContextForward2'. + +See the documentation of 'GI.GtkSource.Objects.SearchContext.searchContextForward2' for more +details. + +See the 'GI.Gio.Interfaces.AsyncResult.AsyncResult' documentation to know how to use this function. + +If the operation is cancelled, the /@callback@/ will only be called if +/@cancellable@/ was not 'Nothing'. 'GI.GtkSource.Objects.SearchContext.searchContextForwardAsync' takes +ownership of /@cancellable@/, so you can unref it after calling this function. + +/Since: 3.10/ +-} +searchContextForwardAsync :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchContext a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@search@/: a 'GI.GtkSource.Objects.SearchContext.SearchContext'. -} + -> Gtk.TextIter.TextIter + {- ^ /@iter@/: start of search. -} + -> Maybe (b) + {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing'. -} + -> Maybe (Gio.Callbacks.AsyncReadyCallback) + {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the operation is finished. -} + -> m () +searchContextForwardAsync search iter cancellable callback = liftIO $ do + search' <- unsafeManagedPtrCastPtr search + iter' <- unsafeManagedPtrGetPtr iter + maybeCancellable <- case cancellable of + Nothing -> return nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + maybeCallback <- case callback of + Nothing -> return (castPtrToFunPtr nullPtr) + Just jCallback -> do + ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback)) + jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback)) + poke ptrcallback jCallback' + return jCallback' + let userData = nullPtr + gtk_source_search_context_forward_async search' iter' maybeCancellable maybeCallback userData + touchManagedPtr search + touchManagedPtr iter + whenJust cancellable touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data SearchContextForwardAsyncMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsSearchContext a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SearchContextForwardAsyncMethodInfo a signature where + overloadedMethod _ = searchContextForwardAsync + +#endif + +-- method SearchContext::forward_finish +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "search", argType = TInterface (Name {namespace = "GtkSource", name = "SearchContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchContext.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "match_start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for start of match, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "match_end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for end of match, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "gtk_source_search_context_forward_finish" gtk_source_search_context_forward_finish :: + Ptr SearchContext -> -- search : TInterface (Name {namespace = "GtkSource", name = "SearchContext"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr Gtk.TextIter.TextIter -> -- match_start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- match_end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr (Ptr GError) -> -- error + IO CInt + +{-# DEPRECATED searchContextForwardFinish ["(Since version 3.22)","Use 'GI.GtkSource.Objects.SearchContext.searchContextForwardFinish2' instead."] #-} +{- | +Finishes a forward search started with +'GI.GtkSource.Objects.SearchContext.searchContextForwardAsync'. + +/Since: 3.10/ +-} +searchContextForwardFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchContext a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@search@/: a 'GI.GtkSource.Objects.SearchContext.SearchContext'. -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -} + -> m ((Gtk.TextIter.TextIter, Gtk.TextIter.TextIter)) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +searchContextForwardFinish search result_ = liftIO $ do + search' <- unsafeManagedPtrCastPtr search + result_' <- unsafeManagedPtrCastPtr result_ + matchStart <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter) + matchEnd <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter) + onException (do + _ <- propagateGError $ gtk_source_search_context_forward_finish search' result_' matchStart matchEnd + matchStart' <- (wrapBoxed Gtk.TextIter.TextIter) matchStart + matchEnd' <- (wrapBoxed Gtk.TextIter.TextIter) matchEnd + touchManagedPtr search + touchManagedPtr result_ + return (matchStart', matchEnd') + ) (do + freeMem matchStart + freeMem matchEnd + ) + +#if ENABLE_OVERLOADING +data SearchContextForwardFinishMethodInfo +instance (signature ~ (b -> m ((Gtk.TextIter.TextIter, Gtk.TextIter.TextIter))), MonadIO m, IsSearchContext a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo SearchContextForwardFinishMethodInfo a signature where + overloadedMethod _ = searchContextForwardFinish + +#endif + +-- method SearchContext::forward_finish2 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "search", argType = TInterface (Name {namespace = "GtkSource", name = "SearchContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchContext.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "match_start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for start of match, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "match_end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for end of match, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "has_wrapped_around", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location to know whether the\n search has wrapped around, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "gtk_source_search_context_forward_finish2" gtk_source_search_context_forward_finish2 :: + Ptr SearchContext -> -- search : TInterface (Name {namespace = "GtkSource", name = "SearchContext"}) + Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr Gtk.TextIter.TextIter -> -- match_start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- match_end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr CInt -> -- has_wrapped_around : TBasicType TBoolean + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Finishes a forward search started with +'GI.GtkSource.Objects.SearchContext.searchContextForwardAsync'. + +See the documentation of 'GI.GtkSource.Objects.SearchContext.searchContextForward2' for more +details. + +/Since: 3.22/ +-} +searchContextForwardFinish2 :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchContext a, Gio.AsyncResult.IsAsyncResult b) => + a + {- ^ /@search@/: a 'GI.GtkSource.Objects.SearchContext.SearchContext'. -} + -> b + {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -} + -> m ((Gtk.TextIter.TextIter, Gtk.TextIter.TextIter, Bool)) + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +searchContextForwardFinish2 search result_ = liftIO $ do + search' <- unsafeManagedPtrCastPtr search + result_' <- unsafeManagedPtrCastPtr result_ + matchStart <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter) + matchEnd <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter) + hasWrappedAround <- allocMem :: IO (Ptr CInt) + onException (do + _ <- propagateGError $ gtk_source_search_context_forward_finish2 search' result_' matchStart matchEnd hasWrappedAround + matchStart' <- (wrapBoxed Gtk.TextIter.TextIter) matchStart + matchEnd' <- (wrapBoxed Gtk.TextIter.TextIter) matchEnd + hasWrappedAround' <- peek hasWrappedAround + let hasWrappedAround'' = (/= 0) hasWrappedAround' + touchManagedPtr search + touchManagedPtr result_ + freeMem hasWrappedAround + return (matchStart', matchEnd', hasWrappedAround'') + ) (do + freeMem matchStart + freeMem matchEnd + freeMem hasWrappedAround + ) + +#if ENABLE_OVERLOADING +data SearchContextForwardFinish2MethodInfo +instance (signature ~ (b -> m ((Gtk.TextIter.TextIter, Gtk.TextIter.TextIter, Bool))), MonadIO m, IsSearchContext a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo SearchContextForwardFinish2MethodInfo a signature where + overloadedMethod _ = searchContextForwardFinish2 + +#endif + +-- method SearchContext::get_buffer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "search", argType = TInterface (Name {namespace = "GtkSource", name = "SearchContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchContext.", 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_search_context_get_buffer" gtk_source_search_context_get_buffer :: + Ptr SearchContext -> -- search : TInterface (Name {namespace = "GtkSource", name = "SearchContext"}) + IO (Ptr GtkSource.Buffer.Buffer) + +{- | +/No description available in the introspection data./ + +/Since: 3.10/ +-} +searchContextGetBuffer :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchContext a) => + a + {- ^ /@search@/: a 'GI.GtkSource.Objects.SearchContext.SearchContext'. -} + -> m GtkSource.Buffer.Buffer + {- ^ __Returns:__ the associated buffer. -} +searchContextGetBuffer search = liftIO $ do + search' <- unsafeManagedPtrCastPtr search + result <- gtk_source_search_context_get_buffer search' + checkUnexpectedReturnNULL "searchContextGetBuffer" result + result' <- (newObject GtkSource.Buffer.Buffer) result + touchManagedPtr search + return result' + +#if ENABLE_OVERLOADING +data SearchContextGetBufferMethodInfo +instance (signature ~ (m GtkSource.Buffer.Buffer), MonadIO m, IsSearchContext a) => O.MethodInfo SearchContextGetBufferMethodInfo a signature where + overloadedMethod _ = searchContextGetBuffer + +#endif + +-- method SearchContext::get_highlight +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "search", argType = TInterface (Name {namespace = "GtkSource", name = "SearchContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchContext.", 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_search_context_get_highlight" gtk_source_search_context_get_highlight :: + Ptr SearchContext -> -- search : TInterface (Name {namespace = "GtkSource", name = "SearchContext"}) + IO CInt + +{- | +/No description available in the introspection data./ + +/Since: 3.10/ +-} +searchContextGetHighlight :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchContext a) => + a + {- ^ /@search@/: a 'GI.GtkSource.Objects.SearchContext.SearchContext'. -} + -> m Bool + {- ^ __Returns:__ whether to highlight the search occurrences. -} +searchContextGetHighlight search = liftIO $ do + search' <- unsafeManagedPtrCastPtr search + result <- gtk_source_search_context_get_highlight search' + let result' = (/= 0) result + touchManagedPtr search + return result' + +#if ENABLE_OVERLOADING +data SearchContextGetHighlightMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSearchContext a) => O.MethodInfo SearchContextGetHighlightMethodInfo a signature where + overloadedMethod _ = searchContextGetHighlight + +#endif + +-- method SearchContext::get_match_style +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "search", argType = TInterface (Name {namespace = "GtkSource", name = "SearchContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchContext.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Style"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_search_context_get_match_style" gtk_source_search_context_get_match_style :: + Ptr SearchContext -> -- search : TInterface (Name {namespace = "GtkSource", name = "SearchContext"}) + IO (Ptr GtkSource.Style.Style) + +{- | +/No description available in the introspection data./ + +/Since: 3.16/ +-} +searchContextGetMatchStyle :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchContext a) => + a + {- ^ /@search@/: a 'GI.GtkSource.Objects.SearchContext.SearchContext'. -} + -> m GtkSource.Style.Style + {- ^ __Returns:__ the 'GI.GtkSource.Objects.Style.Style' to apply on search matches. -} +searchContextGetMatchStyle search = liftIO $ do + search' <- unsafeManagedPtrCastPtr search + result <- gtk_source_search_context_get_match_style search' + checkUnexpectedReturnNULL "searchContextGetMatchStyle" result + result' <- (newObject GtkSource.Style.Style) result + touchManagedPtr search + return result' + +#if ENABLE_OVERLOADING +data SearchContextGetMatchStyleMethodInfo +instance (signature ~ (m GtkSource.Style.Style), MonadIO m, IsSearchContext a) => O.MethodInfo SearchContextGetMatchStyleMethodInfo a signature where + overloadedMethod _ = searchContextGetMatchStyle + +#endif + +-- method SearchContext::get_occurrence_position +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "search", argType = TInterface (Name {namespace = "GtkSource", name = "SearchContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchContext.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "match_start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the start of the occurrence.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "match_end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the end of the occurrence.", 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_search_context_get_occurrence_position" gtk_source_search_context_get_occurrence_position :: + Ptr SearchContext -> -- search : TInterface (Name {namespace = "GtkSource", name = "SearchContext"}) + Ptr Gtk.TextIter.TextIter -> -- match_start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- match_end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + IO Int32 + +{- | +Gets the position of a search occurrence. If the buffer is not already fully +scanned, the position may be unknown, and -1 is returned. If 0 is returned, +it means that this part of the buffer has already been scanned, and that +/@matchStart@/ and /@matchEnd@/ don\'t delimit an occurrence. + +/Since: 3.10/ +-} +searchContextGetOccurrencePosition :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchContext a) => + a + {- ^ /@search@/: a 'GI.GtkSource.Objects.SearchContext.SearchContext'. -} + -> Gtk.TextIter.TextIter + {- ^ /@matchStart@/: the start of the occurrence. -} + -> Gtk.TextIter.TextIter + {- ^ /@matchEnd@/: the end of the occurrence. -} + -> m Int32 + {- ^ __Returns:__ the position of the search occurrence. The first occurrence has the +position 1 (not 0). Returns 0 if /@matchStart@/ and /@matchEnd@/ don\'t delimit +an occurrence. Returns -1 if the position is not yet known. -} +searchContextGetOccurrencePosition search matchStart matchEnd = liftIO $ do + search' <- unsafeManagedPtrCastPtr search + matchStart' <- unsafeManagedPtrGetPtr matchStart + matchEnd' <- unsafeManagedPtrGetPtr matchEnd + result <- gtk_source_search_context_get_occurrence_position search' matchStart' matchEnd' + touchManagedPtr search + touchManagedPtr matchStart + touchManagedPtr matchEnd + return result + +#if ENABLE_OVERLOADING +data SearchContextGetOccurrencePositionMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> m Int32), MonadIO m, IsSearchContext a) => O.MethodInfo SearchContextGetOccurrencePositionMethodInfo a signature where + overloadedMethod _ = searchContextGetOccurrencePosition + +#endif + +-- method SearchContext::get_occurrences_count +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "search", argType = TInterface (Name {namespace = "GtkSource", name = "SearchContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchContext.", 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_search_context_get_occurrences_count" gtk_source_search_context_get_occurrences_count :: + Ptr SearchContext -> -- search : TInterface (Name {namespace = "GtkSource", name = "SearchContext"}) + IO Int32 + +{- | +Gets the total number of search occurrences. If the buffer is not already +fully scanned, the total number of occurrences is unknown, and -1 is +returned. + +/Since: 3.10/ +-} +searchContextGetOccurrencesCount :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchContext a) => + a + {- ^ /@search@/: a 'GI.GtkSource.Objects.SearchContext.SearchContext'. -} + -> m Int32 + {- ^ __Returns:__ the total number of search occurrences, or -1 if unknown. -} +searchContextGetOccurrencesCount search = liftIO $ do + search' <- unsafeManagedPtrCastPtr search + result <- gtk_source_search_context_get_occurrences_count search' + touchManagedPtr search + return result + +#if ENABLE_OVERLOADING +data SearchContextGetOccurrencesCountMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsSearchContext a) => O.MethodInfo SearchContextGetOccurrencesCountMethodInfo a signature where + overloadedMethod _ = searchContextGetOccurrencesCount + +#endif + +-- method SearchContext::get_regex_error +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "search", argType = TInterface (Name {namespace = "GtkSource", name = "SearchContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchContext.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just TError +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_search_context_get_regex_error" gtk_source_search_context_get_regex_error :: + Ptr SearchContext -> -- search : TInterface (Name {namespace = "GtkSource", name = "SearchContext"}) + IO (Ptr GError) + +{- | +Regular expression patterns must follow certain rules. If +'GI.GtkSource.Objects.SearchSettings.SearchSettings':@/search-text/@ breaks a rule, the error can be retrieved +with this function. The error domain is @/G_REGEX_ERROR/@. + +Free the return value with 'GI.GLib.Structs.Error.errorFree'. + +/Since: 3.10/ +-} +searchContextGetRegexError :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchContext a) => + a + {- ^ /@search@/: a 'GI.GtkSource.Objects.SearchContext.SearchContext'. -} + -> m (Maybe GError) + {- ^ __Returns:__ the 'GError', or 'Nothing' if the pattern is valid. -} +searchContextGetRegexError search = liftIO $ do + search' <- unsafeManagedPtrCastPtr search + result <- gtk_source_search_context_get_regex_error search' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed GError) result' + return result'' + touchManagedPtr search + return maybeResult + +#if ENABLE_OVERLOADING +data SearchContextGetRegexErrorMethodInfo +instance (signature ~ (m (Maybe GError)), MonadIO m, IsSearchContext a) => O.MethodInfo SearchContextGetRegexErrorMethodInfo a signature where + overloadedMethod _ = searchContextGetRegexError + +#endif + +-- method SearchContext::get_settings +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "search", argType = TInterface (Name {namespace = "GtkSource", name = "SearchContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchContext.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "SearchSettings"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_search_context_get_settings" gtk_source_search_context_get_settings :: + Ptr SearchContext -> -- search : TInterface (Name {namespace = "GtkSource", name = "SearchContext"}) + IO (Ptr GtkSource.SearchSettings.SearchSettings) + +{- | +/No description available in the introspection data./ + +/Since: 3.10/ +-} +searchContextGetSettings :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchContext a) => + a + {- ^ /@search@/: a 'GI.GtkSource.Objects.SearchContext.SearchContext'. -} + -> m GtkSource.SearchSettings.SearchSettings + {- ^ __Returns:__ the search settings. -} +searchContextGetSettings search = liftIO $ do + search' <- unsafeManagedPtrCastPtr search + result <- gtk_source_search_context_get_settings search' + checkUnexpectedReturnNULL "searchContextGetSettings" result + result' <- (newObject GtkSource.SearchSettings.SearchSettings) result + touchManagedPtr search + return result' + +#if ENABLE_OVERLOADING +data SearchContextGetSettingsMethodInfo +instance (signature ~ (m GtkSource.SearchSettings.SearchSettings), MonadIO m, IsSearchContext a) => O.MethodInfo SearchContextGetSettingsMethodInfo a signature where + overloadedMethod _ = searchContextGetSettings + +#endif + +-- method SearchContext::replace +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "search", argType = TInterface (Name {namespace = "GtkSource", name = "SearchContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchContext.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "match_start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the start of the match to replace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "match_end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the end of the match to replace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "replace", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the replacement text.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "replace_length", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of @replace in bytes, or -1.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "gtk_source_search_context_replace" gtk_source_search_context_replace :: + Ptr SearchContext -> -- search : TInterface (Name {namespace = "GtkSource", name = "SearchContext"}) + Ptr Gtk.TextIter.TextIter -> -- match_start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- match_end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + CString -> -- replace : TBasicType TUTF8 + Int32 -> -- replace_length : TBasicType TInt + Ptr (Ptr GError) -> -- error + IO CInt + +{-# DEPRECATED searchContextReplace ["(Since version 3.22)","Use 'GI.GtkSource.Objects.SearchContext.searchContextReplace2' instead."] #-} +{- | +Replaces a search match by another text. If /@matchStart@/ and /@matchEnd@/ +doesn\'t correspond to a search match, 'False' is returned. + +For a regular expression replacement, you can check if /@replace@/ is valid by +calling 'GI.GLib.Functions.regexCheckReplacement'. The /@replace@/ text can contain +backreferences; read the 'GI.GLib.Structs.Regex.regexReplace' documentation for more details. + +/Since: 3.10/ +-} +searchContextReplace :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchContext a) => + a + {- ^ /@search@/: a 'GI.GtkSource.Objects.SearchContext.SearchContext'. -} + -> Gtk.TextIter.TextIter + {- ^ /@matchStart@/: the start of the match to replace. -} + -> Gtk.TextIter.TextIter + {- ^ /@matchEnd@/: the end of the match to replace. -} + -> T.Text + {- ^ /@replace@/: the replacement text. -} + -> Int32 + {- ^ /@replaceLength@/: the length of /@replace@/ in bytes, or -1. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +searchContextReplace search matchStart matchEnd replace replaceLength = liftIO $ do + search' <- unsafeManagedPtrCastPtr search + matchStart' <- unsafeManagedPtrGetPtr matchStart + matchEnd' <- unsafeManagedPtrGetPtr matchEnd + replace' <- textToCString replace + onException (do + _ <- propagateGError $ gtk_source_search_context_replace search' matchStart' matchEnd' replace' replaceLength + touchManagedPtr search + touchManagedPtr matchStart + touchManagedPtr matchEnd + freeMem replace' + return () + ) (do + freeMem replace' + ) + +#if ENABLE_OVERLOADING +data SearchContextReplaceMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> T.Text -> Int32 -> m ()), MonadIO m, IsSearchContext a) => O.MethodInfo SearchContextReplaceMethodInfo a signature where + overloadedMethod _ = searchContextReplace + +#endif + +-- method SearchContext::replace2 +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "search", argType = TInterface (Name {namespace = "GtkSource", name = "SearchContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchContext.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "match_start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the start of the match to replace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "match_end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the end of the match to replace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "replace", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the replacement text.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "replace_length", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of @replace in bytes, or -1.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "gtk_source_search_context_replace2" gtk_source_search_context_replace2 :: + Ptr SearchContext -> -- search : TInterface (Name {namespace = "GtkSource", name = "SearchContext"}) + Ptr Gtk.TextIter.TextIter -> -- match_start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- match_end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + CString -> -- replace : TBasicType TUTF8 + Int32 -> -- replace_length : TBasicType TInt + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Replaces a search match by another text. If /@matchStart@/ and /@matchEnd@/ +doesn\'t correspond to a search match, 'False' is returned. + +Unlike with 'GI.GtkSource.Objects.SearchContext.searchContextReplace', the /@matchStart@/ and +/@matchEnd@/ iters are revalidated to point to the replacement text boundaries. + +For a regular expression replacement, you can check if /@replace@/ is valid by +calling 'GI.GLib.Functions.regexCheckReplacement'. The /@replace@/ text can contain +backreferences; read the 'GI.GLib.Structs.Regex.regexReplace' documentation for more details. + +/Since: 3.22/ +-} +searchContextReplace2 :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchContext a) => + a + {- ^ /@search@/: a 'GI.GtkSource.Objects.SearchContext.SearchContext'. -} + -> Gtk.TextIter.TextIter + {- ^ /@matchStart@/: the start of the match to replace. -} + -> Gtk.TextIter.TextIter + {- ^ /@matchEnd@/: the end of the match to replace. -} + -> T.Text + {- ^ /@replace@/: the replacement text. -} + -> Int32 + {- ^ /@replaceLength@/: the length of /@replace@/ in bytes, or -1. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +searchContextReplace2 search matchStart matchEnd replace replaceLength = liftIO $ do + search' <- unsafeManagedPtrCastPtr search + matchStart' <- unsafeManagedPtrGetPtr matchStart + matchEnd' <- unsafeManagedPtrGetPtr matchEnd + replace' <- textToCString replace + onException (do + _ <- propagateGError $ gtk_source_search_context_replace2 search' matchStart' matchEnd' replace' replaceLength + touchManagedPtr search + touchManagedPtr matchStart + touchManagedPtr matchEnd + freeMem replace' + return () + ) (do + freeMem replace' + ) + +#if ENABLE_OVERLOADING +data SearchContextReplace2MethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> T.Text -> Int32 -> m ()), MonadIO m, IsSearchContext a) => O.MethodInfo SearchContextReplace2MethodInfo a signature where + overloadedMethod _ = searchContextReplace2 + +#endif + +-- method SearchContext::replace_all +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "search", argType = TInterface (Name {namespace = "GtkSource", name = "SearchContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchContext.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "replace", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the replacement text.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "replace_length", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of @replace in bytes, or -1.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : True +-- Skip return : False + +foreign import ccall "gtk_source_search_context_replace_all" gtk_source_search_context_replace_all :: + Ptr SearchContext -> -- search : TInterface (Name {namespace = "GtkSource", name = "SearchContext"}) + CString -> -- replace : TBasicType TUTF8 + Int32 -> -- replace_length : TBasicType TInt + Ptr (Ptr GError) -> -- error + IO Word32 + +{- | +Replaces all search matches by another text. It is a synchronous function, so +it can block the user interface. + +For a regular expression replacement, you can check if /@replace@/ is valid by +calling 'GI.GLib.Functions.regexCheckReplacement'. The /@replace@/ text can contain +backreferences; read the 'GI.GLib.Structs.Regex.regexReplace' documentation for more details. + +/Since: 3.10/ +-} +searchContextReplaceAll :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchContext a) => + a + {- ^ /@search@/: a 'GI.GtkSource.Objects.SearchContext.SearchContext'. -} + -> T.Text + {- ^ /@replace@/: the replacement text. -} + -> Int32 + {- ^ /@replaceLength@/: the length of /@replace@/ in bytes, or -1. -} + -> m Word32 + {- ^ __Returns:__ the number of replaced matches. /(Can throw 'Data.GI.Base.GError.GError')/ -} +searchContextReplaceAll search replace replaceLength = liftIO $ do + search' <- unsafeManagedPtrCastPtr search + replace' <- textToCString replace + onException (do + result <- propagateGError $ gtk_source_search_context_replace_all search' replace' replaceLength + touchManagedPtr search + freeMem replace' + return result + ) (do + freeMem replace' + ) + +#if ENABLE_OVERLOADING +data SearchContextReplaceAllMethodInfo +instance (signature ~ (T.Text -> Int32 -> m Word32), MonadIO m, IsSearchContext a) => O.MethodInfo SearchContextReplaceAllMethodInfo a signature where + overloadedMethod _ = searchContextReplaceAll + +#endif + +-- method SearchContext::set_highlight +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "search", argType = TInterface (Name {namespace = "GtkSource", name = "SearchContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchContext.", 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 "the setting.", 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_search_context_set_highlight" gtk_source_search_context_set_highlight :: + Ptr SearchContext -> -- search : TInterface (Name {namespace = "GtkSource", name = "SearchContext"}) + CInt -> -- highlight : TBasicType TBoolean + IO () + +{- | +Enables or disables the search occurrences highlighting. + +/Since: 3.10/ +-} +searchContextSetHighlight :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchContext a) => + a + {- ^ /@search@/: a 'GI.GtkSource.Objects.SearchContext.SearchContext'. -} + -> Bool + {- ^ /@highlight@/: the setting. -} + -> m () +searchContextSetHighlight search highlight = liftIO $ do + search' <- unsafeManagedPtrCastPtr search + let highlight' = (fromIntegral . fromEnum) highlight + gtk_source_search_context_set_highlight search' highlight' + touchManagedPtr search + return () + +#if ENABLE_OVERLOADING +data SearchContextSetHighlightMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSearchContext a) => O.MethodInfo SearchContextSetHighlightMethodInfo a signature where + overloadedMethod _ = searchContextSetHighlight + +#endif + +-- method SearchContext::set_match_style +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "search", argType = TInterface (Name {namespace = "GtkSource", name = "SearchContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchContext.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "match_style", argType = TInterface (Name {namespace = "GtkSource", name = "Style"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkSourceStyle, 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_search_context_set_match_style" gtk_source_search_context_set_match_style :: + Ptr SearchContext -> -- search : TInterface (Name {namespace = "GtkSource", name = "SearchContext"}) + Ptr GtkSource.Style.Style -> -- match_style : TInterface (Name {namespace = "GtkSource", name = "Style"}) + IO () + +{- | +Set the style to apply on search matches. If /@matchStyle@/ is 'Nothing', default +theme\'s scheme \'match-style\' will be used. +To enable or disable the search highlighting, use +'GI.GtkSource.Objects.SearchContext.searchContextSetHighlight'. + +/Since: 3.16/ +-} +searchContextSetMatchStyle :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchContext a, GtkSource.Style.IsStyle b) => + a + {- ^ /@search@/: a 'GI.GtkSource.Objects.SearchContext.SearchContext'. -} + -> Maybe (b) + {- ^ /@matchStyle@/: a 'GI.GtkSource.Objects.Style.Style', or 'Nothing'. -} + -> m () +searchContextSetMatchStyle search matchStyle = liftIO $ do + search' <- unsafeManagedPtrCastPtr search + maybeMatchStyle <- case matchStyle of + Nothing -> return nullPtr + Just jMatchStyle -> do + jMatchStyle' <- unsafeManagedPtrCastPtr jMatchStyle + return jMatchStyle' + gtk_source_search_context_set_match_style search' maybeMatchStyle + touchManagedPtr search + whenJust matchStyle touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data SearchContextSetMatchStyleMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsSearchContext a, GtkSource.Style.IsStyle b) => O.MethodInfo SearchContextSetMatchStyleMethodInfo a signature where + overloadedMethod _ = searchContextSetMatchStyle + +#endif + +-- method SearchContext::set_settings +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "search", argType = TInterface (Name {namespace = "GtkSource", name = "SearchContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchContext.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "settings", argType = TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the new #GtkSourceSearchSettings, 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_search_context_set_settings" gtk_source_search_context_set_settings :: + Ptr SearchContext -> -- search : TInterface (Name {namespace = "GtkSource", name = "SearchContext"}) + Ptr GtkSource.SearchSettings.SearchSettings -> -- settings : TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}) + IO () + +{-# DEPRECATED searchContextSetSettings ["(Since version 3.24)","The 'GI.GtkSource.Objects.SearchContext.SearchContext':@/settings/@ property will become a","construct-only property in a future version. Create a new","'GI.GtkSource.Objects.SearchContext.SearchContext' instead, or change the 'GI.GtkSource.Objects.SearchSettings.SearchSettings'","properties. When the 'GI.GtkSource.Objects.SearchContext.SearchContext':@/settings/@ property will become","construct-only, it will be possible to simplify some code that needed to","listen to the notify::settings signal."] #-} +{- | +Associate a 'GI.GtkSource.Objects.SearchSettings.SearchSettings' with the search context. If /@settings@/ is +'Nothing', a new one will be created. + +The search context holds a reference to /@settings@/. + +/Since: 3.10/ +-} +searchContextSetSettings :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchContext a, GtkSource.SearchSettings.IsSearchSettings b) => + a + {- ^ /@search@/: a 'GI.GtkSource.Objects.SearchContext.SearchContext'. -} + -> Maybe (b) + {- ^ /@settings@/: the new 'GI.GtkSource.Objects.SearchSettings.SearchSettings', or 'Nothing'. -} + -> m () +searchContextSetSettings search settings = liftIO $ do + search' <- unsafeManagedPtrCastPtr search + maybeSettings <- case settings of + Nothing -> return nullPtr + Just jSettings -> do + jSettings' <- unsafeManagedPtrCastPtr jSettings + return jSettings' + gtk_source_search_context_set_settings search' maybeSettings + touchManagedPtr search + whenJust settings touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data SearchContextSetSettingsMethodInfo +instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsSearchContext a, GtkSource.SearchSettings.IsSearchSettings b) => O.MethodInfo SearchContextSetSettingsMethodInfo a signature where + overloadedMethod _ = searchContextSetSettings + +#endif + + diff --git a/GI/GtkSource/Objects/SearchContext.hs-boot b/GI/GtkSource/Objects/SearchContext.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/SearchContext.hs-boot @@ -0,0 +1,116 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.SearchContext 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 SearchContext = SearchContext (ManagedPtr SearchContext) +instance GObject SearchContext where +class (GObject o, O.IsDescendantOf SearchContext o) => IsSearchContext o +instance (GObject o, O.IsDescendantOf SearchContext o) => IsSearchContext o +instance O.HasParentTypes SearchContext +#if ENABLE_OVERLOADING +data SearchContextBufferPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextHighlightPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextMatchStylePropertyInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextOccurrencesCountPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextRegexErrorPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextSettingsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextBackwardMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextBackward2MethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextBackwardAsyncMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextBackwardFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextBackwardFinish2MethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextForwardMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextForward2MethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextForwardAsyncMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextForwardFinishMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextForwardFinish2MethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextGetBufferMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextGetHighlightMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextGetMatchStyleMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextGetOccurrencePositionMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextGetOccurrencesCountMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextGetRegexErrorMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextGetSettingsMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextReplaceMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextReplace2MethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextReplaceAllMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextSetHighlightMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextSetMatchStyleMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchContextSetSettingsMethodInfo +#endif diff --git a/GI/GtkSource/Objects/SearchSettings.hs b/GI/GtkSource/Objects/SearchSettings.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/SearchSettings.hs @@ -0,0 +1,1011 @@ + + +{- | +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.SearchSettings + ( + +-- * Exported types + SearchSettings(..) , + IsSearchSettings , + toSearchSettings , + noSearchSettings , + + + -- * Methods +-- ** getAtWordBoundaries #method:getAtWordBoundaries# + +#if ENABLE_OVERLOADING + SearchSettingsGetAtWordBoundariesMethodInfo, +#endif + searchSettingsGetAtWordBoundaries , + + +-- ** getCaseSensitive #method:getCaseSensitive# + +#if ENABLE_OVERLOADING + SearchSettingsGetCaseSensitiveMethodInfo, +#endif + searchSettingsGetCaseSensitive , + + +-- ** getRegexEnabled #method:getRegexEnabled# + +#if ENABLE_OVERLOADING + SearchSettingsGetRegexEnabledMethodInfo , +#endif + searchSettingsGetRegexEnabled , + + +-- ** getSearchText #method:getSearchText# + +#if ENABLE_OVERLOADING + SearchSettingsGetSearchTextMethodInfo , +#endif + searchSettingsGetSearchText , + + +-- ** getWrapAround #method:getWrapAround# + +#if ENABLE_OVERLOADING + SearchSettingsGetWrapAroundMethodInfo , +#endif + searchSettingsGetWrapAround , + + +-- ** new #method:new# + + searchSettingsNew , + + +-- ** setAtWordBoundaries #method:setAtWordBoundaries# + +#if ENABLE_OVERLOADING + SearchSettingsSetAtWordBoundariesMethodInfo, +#endif + searchSettingsSetAtWordBoundaries , + + +-- ** setCaseSensitive #method:setCaseSensitive# + +#if ENABLE_OVERLOADING + SearchSettingsSetCaseSensitiveMethodInfo, +#endif + searchSettingsSetCaseSensitive , + + +-- ** setRegexEnabled #method:setRegexEnabled# + +#if ENABLE_OVERLOADING + SearchSettingsSetRegexEnabledMethodInfo , +#endif + searchSettingsSetRegexEnabled , + + +-- ** setSearchText #method:setSearchText# + +#if ENABLE_OVERLOADING + SearchSettingsSetSearchTextMethodInfo , +#endif + searchSettingsSetSearchText , + + +-- ** setWrapAround #method:setWrapAround# + +#if ENABLE_OVERLOADING + SearchSettingsSetWrapAroundMethodInfo , +#endif + searchSettingsSetWrapAround , + + + + + -- * Properties +-- ** atWordBoundaries #attr:atWordBoundaries# +{- | If 'True', a search match must start and end a word. The match can +span multiple words. + +/Since: 3.10/ +-} +#if ENABLE_OVERLOADING + SearchSettingsAtWordBoundariesPropertyInfo, +#endif + constructSearchSettingsAtWordBoundaries , + getSearchSettingsAtWordBoundaries , +#if ENABLE_OVERLOADING + searchSettingsAtWordBoundaries , +#endif + setSearchSettingsAtWordBoundaries , + + +-- ** caseSensitive #attr:caseSensitive# +{- | Whether the search is case sensitive. + +/Since: 3.10/ +-} +#if ENABLE_OVERLOADING + SearchSettingsCaseSensitivePropertyInfo , +#endif + constructSearchSettingsCaseSensitive , + getSearchSettingsCaseSensitive , +#if ENABLE_OVERLOADING + searchSettingsCaseSensitive , +#endif + setSearchSettingsCaseSensitive , + + +-- ** regexEnabled #attr:regexEnabled# +{- | Search by regular expressions with +'GI.GtkSource.Objects.SearchSettings.SearchSettings':@/search-text/@ as the pattern. + +/Since: 3.10/ +-} +#if ENABLE_OVERLOADING + SearchSettingsRegexEnabledPropertyInfo , +#endif + constructSearchSettingsRegexEnabled , + getSearchSettingsRegexEnabled , +#if ENABLE_OVERLOADING + searchSettingsRegexEnabled , +#endif + setSearchSettingsRegexEnabled , + + +-- ** searchText #attr:searchText# +{- | A search string, or 'Nothing' if the search is disabled. If the regular +expression search is enabled, 'GI.GtkSource.Objects.SearchSettings.SearchSettings':@/search-text/@ is +the pattern. + +/Since: 3.10/ +-} +#if ENABLE_OVERLOADING + SearchSettingsSearchTextPropertyInfo , +#endif + clearSearchSettingsSearchText , + constructSearchSettingsSearchText , + getSearchSettingsSearchText , +#if ENABLE_OVERLOADING + searchSettingsSearchText , +#endif + setSearchSettingsSearchText , + + +-- ** wrapAround #attr:wrapAround# +{- | For a forward search, continue at the beginning of the buffer if no +search occurrence is found. For a backward search, continue at the +end of the buffer. + +/Since: 3.10/ +-} +#if ENABLE_OVERLOADING + SearchSettingsWrapAroundPropertyInfo , +#endif + constructSearchSettingsWrapAround , + getSearchSettingsWrapAround , +#if ENABLE_OVERLOADING + searchSettingsWrapAround , +#endif + setSearchSettingsWrapAround , + + + + + ) 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 + +-- | Memory-managed wrapper type. +newtype SearchSettings = SearchSettings (ManagedPtr SearchSettings) +foreign import ccall "gtk_source_search_settings_get_type" + c_gtk_source_search_settings_get_type :: IO GType + +instance GObject SearchSettings where + gobjectType = c_gtk_source_search_settings_get_type + + +-- | Type class for types which can be safely cast to `SearchSettings`, for instance with `toSearchSettings`. +class (GObject o, O.IsDescendantOf SearchSettings o) => IsSearchSettings o +instance (GObject o, O.IsDescendantOf SearchSettings o) => IsSearchSettings o + +instance O.HasParentTypes SearchSettings +type instance O.ParentTypes SearchSettings = '[GObject.Object.Object] + +-- | Cast to `SearchSettings`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toSearchSettings :: (MonadIO m, IsSearchSettings o) => o -> m SearchSettings +toSearchSettings = liftIO . unsafeCastTo SearchSettings + +-- | A convenience alias for `Nothing` :: `Maybe` `SearchSettings`. +noSearchSettings :: Maybe SearchSettings +noSearchSettings = Nothing + +#if ENABLE_OVERLOADING +type family ResolveSearchSettingsMethod (t :: Symbol) (o :: *) :: * where + ResolveSearchSettingsMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveSearchSettingsMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveSearchSettingsMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveSearchSettingsMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveSearchSettingsMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveSearchSettingsMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveSearchSettingsMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveSearchSettingsMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveSearchSettingsMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveSearchSettingsMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveSearchSettingsMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveSearchSettingsMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveSearchSettingsMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveSearchSettingsMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveSearchSettingsMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveSearchSettingsMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveSearchSettingsMethod "getAtWordBoundaries" o = SearchSettingsGetAtWordBoundariesMethodInfo + ResolveSearchSettingsMethod "getCaseSensitive" o = SearchSettingsGetCaseSensitiveMethodInfo + ResolveSearchSettingsMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveSearchSettingsMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveSearchSettingsMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveSearchSettingsMethod "getRegexEnabled" o = SearchSettingsGetRegexEnabledMethodInfo + ResolveSearchSettingsMethod "getSearchText" o = SearchSettingsGetSearchTextMethodInfo + ResolveSearchSettingsMethod "getWrapAround" o = SearchSettingsGetWrapAroundMethodInfo + ResolveSearchSettingsMethod "setAtWordBoundaries" o = SearchSettingsSetAtWordBoundariesMethodInfo + ResolveSearchSettingsMethod "setCaseSensitive" o = SearchSettingsSetCaseSensitiveMethodInfo + ResolveSearchSettingsMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveSearchSettingsMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveSearchSettingsMethod "setRegexEnabled" o = SearchSettingsSetRegexEnabledMethodInfo + ResolveSearchSettingsMethod "setSearchText" o = SearchSettingsSetSearchTextMethodInfo + ResolveSearchSettingsMethod "setWrapAround" o = SearchSettingsSetWrapAroundMethodInfo + ResolveSearchSettingsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSearchSettingsMethod t SearchSettings, O.MethodInfo info SearchSettings p) => OL.IsLabel t (SearchSettings -> 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 + +-- VVV Prop "at-word-boundaries" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@at-word-boundaries@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' searchSettings #atWordBoundaries +@ +-} +getSearchSettingsAtWordBoundaries :: (MonadIO m, IsSearchSettings o) => o -> m Bool +getSearchSettingsAtWordBoundaries obj = liftIO $ B.Properties.getObjectPropertyBool obj "at-word-boundaries" + +{- | +Set the value of the “@at-word-boundaries@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' searchSettings [ #atWordBoundaries 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSearchSettingsAtWordBoundaries :: (MonadIO m, IsSearchSettings o) => o -> Bool -> m () +setSearchSettingsAtWordBoundaries obj val = liftIO $ B.Properties.setObjectPropertyBool obj "at-word-boundaries" val + +{- | +Construct a `GValueConstruct` with valid value for the “@at-word-boundaries@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSearchSettingsAtWordBoundaries :: (IsSearchSettings o) => Bool -> IO (GValueConstruct o) +constructSearchSettingsAtWordBoundaries val = B.Properties.constructObjectPropertyBool "at-word-boundaries" val + +#if ENABLE_OVERLOADING +data SearchSettingsAtWordBoundariesPropertyInfo +instance AttrInfo SearchSettingsAtWordBoundariesPropertyInfo where + type AttrAllowedOps SearchSettingsAtWordBoundariesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SearchSettingsAtWordBoundariesPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SearchSettingsAtWordBoundariesPropertyInfo = IsSearchSettings + type AttrGetType SearchSettingsAtWordBoundariesPropertyInfo = Bool + type AttrLabel SearchSettingsAtWordBoundariesPropertyInfo = "at-word-boundaries" + type AttrOrigin SearchSettingsAtWordBoundariesPropertyInfo = SearchSettings + attrGet _ = getSearchSettingsAtWordBoundaries + attrSet _ = setSearchSettingsAtWordBoundaries + attrConstruct _ = constructSearchSettingsAtWordBoundaries + attrClear _ = undefined +#endif + +-- VVV Prop "case-sensitive" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@case-sensitive@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' searchSettings #caseSensitive +@ +-} +getSearchSettingsCaseSensitive :: (MonadIO m, IsSearchSettings o) => o -> m Bool +getSearchSettingsCaseSensitive obj = liftIO $ B.Properties.getObjectPropertyBool obj "case-sensitive" + +{- | +Set the value of the “@case-sensitive@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' searchSettings [ #caseSensitive 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSearchSettingsCaseSensitive :: (MonadIO m, IsSearchSettings o) => o -> Bool -> m () +setSearchSettingsCaseSensitive obj val = liftIO $ B.Properties.setObjectPropertyBool obj "case-sensitive" val + +{- | +Construct a `GValueConstruct` with valid value for the “@case-sensitive@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSearchSettingsCaseSensitive :: (IsSearchSettings o) => Bool -> IO (GValueConstruct o) +constructSearchSettingsCaseSensitive val = B.Properties.constructObjectPropertyBool "case-sensitive" val + +#if ENABLE_OVERLOADING +data SearchSettingsCaseSensitivePropertyInfo +instance AttrInfo SearchSettingsCaseSensitivePropertyInfo where + type AttrAllowedOps SearchSettingsCaseSensitivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SearchSettingsCaseSensitivePropertyInfo = (~) Bool + type AttrBaseTypeConstraint SearchSettingsCaseSensitivePropertyInfo = IsSearchSettings + type AttrGetType SearchSettingsCaseSensitivePropertyInfo = Bool + type AttrLabel SearchSettingsCaseSensitivePropertyInfo = "case-sensitive" + type AttrOrigin SearchSettingsCaseSensitivePropertyInfo = SearchSettings + attrGet _ = getSearchSettingsCaseSensitive + attrSet _ = setSearchSettingsCaseSensitive + attrConstruct _ = constructSearchSettingsCaseSensitive + attrClear _ = undefined +#endif + +-- VVV Prop "regex-enabled" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@regex-enabled@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' searchSettings #regexEnabled +@ +-} +getSearchSettingsRegexEnabled :: (MonadIO m, IsSearchSettings o) => o -> m Bool +getSearchSettingsRegexEnabled obj = liftIO $ B.Properties.getObjectPropertyBool obj "regex-enabled" + +{- | +Set the value of the “@regex-enabled@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' searchSettings [ #regexEnabled 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSearchSettingsRegexEnabled :: (MonadIO m, IsSearchSettings o) => o -> Bool -> m () +setSearchSettingsRegexEnabled obj val = liftIO $ B.Properties.setObjectPropertyBool obj "regex-enabled" val + +{- | +Construct a `GValueConstruct` with valid value for the “@regex-enabled@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSearchSettingsRegexEnabled :: (IsSearchSettings o) => Bool -> IO (GValueConstruct o) +constructSearchSettingsRegexEnabled val = B.Properties.constructObjectPropertyBool "regex-enabled" val + +#if ENABLE_OVERLOADING +data SearchSettingsRegexEnabledPropertyInfo +instance AttrInfo SearchSettingsRegexEnabledPropertyInfo where + type AttrAllowedOps SearchSettingsRegexEnabledPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SearchSettingsRegexEnabledPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SearchSettingsRegexEnabledPropertyInfo = IsSearchSettings + type AttrGetType SearchSettingsRegexEnabledPropertyInfo = Bool + type AttrLabel SearchSettingsRegexEnabledPropertyInfo = "regex-enabled" + type AttrOrigin SearchSettingsRegexEnabledPropertyInfo = SearchSettings + attrGet _ = getSearchSettingsRegexEnabled + attrSet _ = setSearchSettingsRegexEnabled + attrConstruct _ = constructSearchSettingsRegexEnabled + attrClear _ = undefined +#endif + +-- VVV Prop "search-text" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just True,Just True) + +{- | +Get the value of the “@search-text@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' searchSettings #searchText +@ +-} +getSearchSettingsSearchText :: (MonadIO m, IsSearchSettings o) => o -> m (Maybe T.Text) +getSearchSettingsSearchText obj = liftIO $ B.Properties.getObjectPropertyString obj "search-text" + +{- | +Set the value of the “@search-text@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' searchSettings [ #searchText 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSearchSettingsSearchText :: (MonadIO m, IsSearchSettings o) => o -> T.Text -> m () +setSearchSettingsSearchText obj val = liftIO $ B.Properties.setObjectPropertyString obj "search-text" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@search-text@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSearchSettingsSearchText :: (IsSearchSettings o) => T.Text -> IO (GValueConstruct o) +constructSearchSettingsSearchText val = B.Properties.constructObjectPropertyString "search-text" (Just val) + +{- | +Set the value of the “@search-text@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #searchText +@ +-} +clearSearchSettingsSearchText :: (MonadIO m, IsSearchSettings o) => o -> m () +clearSearchSettingsSearchText obj = liftIO $ B.Properties.setObjectPropertyString obj "search-text" (Nothing :: Maybe T.Text) + +#if ENABLE_OVERLOADING +data SearchSettingsSearchTextPropertyInfo +instance AttrInfo SearchSettingsSearchTextPropertyInfo where + type AttrAllowedOps SearchSettingsSearchTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint SearchSettingsSearchTextPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint SearchSettingsSearchTextPropertyInfo = IsSearchSettings + type AttrGetType SearchSettingsSearchTextPropertyInfo = (Maybe T.Text) + type AttrLabel SearchSettingsSearchTextPropertyInfo = "search-text" + type AttrOrigin SearchSettingsSearchTextPropertyInfo = SearchSettings + attrGet _ = getSearchSettingsSearchText + attrSet _ = setSearchSettingsSearchText + attrConstruct _ = constructSearchSettingsSearchText + attrClear _ = clearSearchSettingsSearchText +#endif + +-- VVV Prop "wrap-around" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@wrap-around@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' searchSettings #wrapAround +@ +-} +getSearchSettingsWrapAround :: (MonadIO m, IsSearchSettings o) => o -> m Bool +getSearchSettingsWrapAround obj = liftIO $ B.Properties.getObjectPropertyBool obj "wrap-around" + +{- | +Set the value of the “@wrap-around@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' searchSettings [ #wrapAround 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSearchSettingsWrapAround :: (MonadIO m, IsSearchSettings o) => o -> Bool -> m () +setSearchSettingsWrapAround obj val = liftIO $ B.Properties.setObjectPropertyBool obj "wrap-around" val + +{- | +Construct a `GValueConstruct` with valid value for the “@wrap-around@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSearchSettingsWrapAround :: (IsSearchSettings o) => Bool -> IO (GValueConstruct o) +constructSearchSettingsWrapAround val = B.Properties.constructObjectPropertyBool "wrap-around" val + +#if ENABLE_OVERLOADING +data SearchSettingsWrapAroundPropertyInfo +instance AttrInfo SearchSettingsWrapAroundPropertyInfo where + type AttrAllowedOps SearchSettingsWrapAroundPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SearchSettingsWrapAroundPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SearchSettingsWrapAroundPropertyInfo = IsSearchSettings + type AttrGetType SearchSettingsWrapAroundPropertyInfo = Bool + type AttrLabel SearchSettingsWrapAroundPropertyInfo = "wrap-around" + type AttrOrigin SearchSettingsWrapAroundPropertyInfo = SearchSettings + attrGet _ = getSearchSettingsWrapAround + attrSet _ = setSearchSettingsWrapAround + attrConstruct _ = constructSearchSettingsWrapAround + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList SearchSettings +type instance O.AttributeList SearchSettings = SearchSettingsAttributeList +type SearchSettingsAttributeList = ('[ '("atWordBoundaries", SearchSettingsAtWordBoundariesPropertyInfo), '("caseSensitive", SearchSettingsCaseSensitivePropertyInfo), '("regexEnabled", SearchSettingsRegexEnabledPropertyInfo), '("searchText", SearchSettingsSearchTextPropertyInfo), '("wrapAround", SearchSettingsWrapAroundPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +searchSettingsAtWordBoundaries :: AttrLabelProxy "atWordBoundaries" +searchSettingsAtWordBoundaries = AttrLabelProxy + +searchSettingsCaseSensitive :: AttrLabelProxy "caseSensitive" +searchSettingsCaseSensitive = AttrLabelProxy + +searchSettingsRegexEnabled :: AttrLabelProxy "regexEnabled" +searchSettingsRegexEnabled = AttrLabelProxy + +searchSettingsSearchText :: AttrLabelProxy "searchText" +searchSettingsSearchText = AttrLabelProxy + +searchSettingsWrapAround :: AttrLabelProxy "wrapAround" +searchSettingsWrapAround = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList SearchSettings = SearchSettingsSignalList +type SearchSettingsSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method SearchSettings::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "SearchSettings"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_search_settings_new" gtk_source_search_settings_new :: + IO (Ptr SearchSettings) + +{- | +Creates a new search settings object. + +/Since: 3.10/ +-} +searchSettingsNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m SearchSettings + {- ^ __Returns:__ a new search settings object. -} +searchSettingsNew = liftIO $ do + result <- gtk_source_search_settings_new + checkUnexpectedReturnNULL "searchSettingsNew" result + result' <- (wrapObject SearchSettings) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method SearchSettings::get_at_word_boundaries +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchSettings.", 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_search_settings_get_at_word_boundaries" gtk_source_search_settings_get_at_word_boundaries :: + Ptr SearchSettings -> -- settings : TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}) + IO CInt + +{- | +/No description available in the introspection data./ + +/Since: 3.10/ +-} +searchSettingsGetAtWordBoundaries :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchSettings a) => + a + {- ^ /@settings@/: a 'GI.GtkSource.Objects.SearchSettings.SearchSettings'. -} + -> m Bool + {- ^ __Returns:__ whether to search at word boundaries. -} +searchSettingsGetAtWordBoundaries settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- gtk_source_search_settings_get_at_word_boundaries settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SearchSettingsGetAtWordBoundariesMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSearchSettings a) => O.MethodInfo SearchSettingsGetAtWordBoundariesMethodInfo a signature where + overloadedMethod _ = searchSettingsGetAtWordBoundaries + +#endif + +-- method SearchSettings::get_case_sensitive +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchSettings.", 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_search_settings_get_case_sensitive" gtk_source_search_settings_get_case_sensitive :: + Ptr SearchSettings -> -- settings : TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}) + IO CInt + +{- | +/No description available in the introspection data./ + +/Since: 3.10/ +-} +searchSettingsGetCaseSensitive :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchSettings a) => + a + {- ^ /@settings@/: a 'GI.GtkSource.Objects.SearchSettings.SearchSettings'. -} + -> m Bool + {- ^ __Returns:__ whether the search is case sensitive. -} +searchSettingsGetCaseSensitive settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- gtk_source_search_settings_get_case_sensitive settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SearchSettingsGetCaseSensitiveMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSearchSettings a) => O.MethodInfo SearchSettingsGetCaseSensitiveMethodInfo a signature where + overloadedMethod _ = searchSettingsGetCaseSensitive + +#endif + +-- method SearchSettings::get_regex_enabled +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchSettings.", 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_search_settings_get_regex_enabled" gtk_source_search_settings_get_regex_enabled :: + Ptr SearchSettings -> -- settings : TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}) + IO CInt + +{- | +/No description available in the introspection data./ + +/Since: 3.10/ +-} +searchSettingsGetRegexEnabled :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchSettings a) => + a + {- ^ /@settings@/: a 'GI.GtkSource.Objects.SearchSettings.SearchSettings'. -} + -> m Bool + {- ^ __Returns:__ whether to search by regular expressions. -} +searchSettingsGetRegexEnabled settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- gtk_source_search_settings_get_regex_enabled settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SearchSettingsGetRegexEnabledMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSearchSettings a) => O.MethodInfo SearchSettingsGetRegexEnabledMethodInfo a signature where + overloadedMethod _ = searchSettingsGetRegexEnabled + +#endif + +-- method SearchSettings::get_search_text +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchSettings.", 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_search_settings_get_search_text" gtk_source_search_settings_get_search_text :: + Ptr SearchSettings -> -- settings : TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}) + IO CString + +{- | +Gets the text to search. The return value must not be freed. + +You may be interested to call 'GI.GtkSource.Functions.utilsEscapeSearchText' after +this function. + +/Since: 3.10/ +-} +searchSettingsGetSearchText :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchSettings a) => + a + {- ^ /@settings@/: a 'GI.GtkSource.Objects.SearchSettings.SearchSettings'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ the text to search, or 'Nothing' if the search is disabled. -} +searchSettingsGetSearchText settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- gtk_source_search_settings_get_search_text settings' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr settings + return maybeResult + +#if ENABLE_OVERLOADING +data SearchSettingsGetSearchTextMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsSearchSettings a) => O.MethodInfo SearchSettingsGetSearchTextMethodInfo a signature where + overloadedMethod _ = searchSettingsGetSearchText + +#endif + +-- method SearchSettings::get_wrap_around +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchSettings.", 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_search_settings_get_wrap_around" gtk_source_search_settings_get_wrap_around :: + Ptr SearchSettings -> -- settings : TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}) + IO CInt + +{- | +/No description available in the introspection data./ + +/Since: 3.10/ +-} +searchSettingsGetWrapAround :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchSettings a) => + a + {- ^ /@settings@/: a 'GI.GtkSource.Objects.SearchSettings.SearchSettings'. -} + -> m Bool + {- ^ __Returns:__ whether to wrap around the search. -} +searchSettingsGetWrapAround settings = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + result <- gtk_source_search_settings_get_wrap_around settings' + let result' = (/= 0) result + touchManagedPtr settings + return result' + +#if ENABLE_OVERLOADING +data SearchSettingsGetWrapAroundMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSearchSettings a) => O.MethodInfo SearchSettingsGetWrapAroundMethodInfo a signature where + overloadedMethod _ = searchSettingsGetWrapAround + +#endif + +-- method SearchSettings::set_at_word_boundaries +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchSettings.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "at_word_boundaries", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the setting.", 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_search_settings_set_at_word_boundaries" gtk_source_search_settings_set_at_word_boundaries :: + Ptr SearchSettings -> -- settings : TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}) + CInt -> -- at_word_boundaries : TBasicType TBoolean + IO () + +{- | +Change whether the search is done at word boundaries. If /@atWordBoundaries@/ +is 'True', a search match must start and end a word. The match can span +multiple words. See also 'GI.Gtk.Structs.TextIter.textIterStartsWord' and +'GI.Gtk.Structs.TextIter.textIterEndsWord'. + +/Since: 3.10/ +-} +searchSettingsSetAtWordBoundaries :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchSettings a) => + a + {- ^ /@settings@/: a 'GI.GtkSource.Objects.SearchSettings.SearchSettings'. -} + -> Bool + {- ^ /@atWordBoundaries@/: the setting. -} + -> m () +searchSettingsSetAtWordBoundaries settings atWordBoundaries = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let atWordBoundaries' = (fromIntegral . fromEnum) atWordBoundaries + gtk_source_search_settings_set_at_word_boundaries settings' atWordBoundaries' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SearchSettingsSetAtWordBoundariesMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSearchSettings a) => O.MethodInfo SearchSettingsSetAtWordBoundariesMethodInfo a signature where + overloadedMethod _ = searchSettingsSetAtWordBoundaries + +#endif + +-- method SearchSettings::set_case_sensitive +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchSettings.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "case_sensitive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the setting.", 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_search_settings_set_case_sensitive" gtk_source_search_settings_set_case_sensitive :: + Ptr SearchSettings -> -- settings : TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}) + CInt -> -- case_sensitive : TBasicType TBoolean + IO () + +{- | +Enables or disables the case sensitivity for the search. + +/Since: 3.10/ +-} +searchSettingsSetCaseSensitive :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchSettings a) => + a + {- ^ /@settings@/: a 'GI.GtkSource.Objects.SearchSettings.SearchSettings'. -} + -> Bool + {- ^ /@caseSensitive@/: the setting. -} + -> m () +searchSettingsSetCaseSensitive settings caseSensitive = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let caseSensitive' = (fromIntegral . fromEnum) caseSensitive + gtk_source_search_settings_set_case_sensitive settings' caseSensitive' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SearchSettingsSetCaseSensitiveMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSearchSettings a) => O.MethodInfo SearchSettingsSetCaseSensitiveMethodInfo a signature where + overloadedMethod _ = searchSettingsSetCaseSensitive + +#endif + +-- method SearchSettings::set_regex_enabled +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchSettings.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "regex_enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the setting.", 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_search_settings_set_regex_enabled" gtk_source_search_settings_set_regex_enabled :: + Ptr SearchSettings -> -- settings : TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}) + CInt -> -- regex_enabled : TBasicType TBoolean + IO () + +{- | +Enables or disables whether to search by regular expressions. +If enabled, the 'GI.GtkSource.Objects.SearchSettings.SearchSettings':@/search-text/@ property contains the +pattern of the regular expression. + +'GI.GtkSource.Objects.SearchContext.SearchContext' uses 'GI.GLib.Structs.Regex.Regex' when regex search is enabled. See the + +page in the GLib reference manual. + +/Since: 3.10/ +-} +searchSettingsSetRegexEnabled :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchSettings a) => + a + {- ^ /@settings@/: a 'GI.GtkSource.Objects.SearchSettings.SearchSettings'. -} + -> Bool + {- ^ /@regexEnabled@/: the setting. -} + -> m () +searchSettingsSetRegexEnabled settings regexEnabled = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let regexEnabled' = (fromIntegral . fromEnum) regexEnabled + gtk_source_search_settings_set_regex_enabled settings' regexEnabled' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SearchSettingsSetRegexEnabledMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSearchSettings a) => O.MethodInfo SearchSettingsSetRegexEnabledMethodInfo a signature where + overloadedMethod _ = searchSettingsSetRegexEnabled + +#endif + +-- method SearchSettings::set_search_text +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchSettings.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "search_text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the nul-terminated text to search, or %NULL to disable the search.", 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_search_settings_set_search_text" gtk_source_search_settings_set_search_text :: + Ptr SearchSettings -> -- settings : TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}) + CString -> -- search_text : TBasicType TUTF8 + IO () + +{- | +Sets the text to search. If /@searchText@/ is 'Nothing' or is empty, the search +will be disabled. A copy of /@searchText@/ will be made, so you can safely free +/@searchText@/ after a call to this function. + +You may be interested to call 'GI.GtkSource.Functions.utilsUnescapeSearchText' before +this function. + +/Since: 3.10/ +-} +searchSettingsSetSearchText :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchSettings a) => + a + {- ^ /@settings@/: a 'GI.GtkSource.Objects.SearchSettings.SearchSettings'. -} + -> Maybe (T.Text) + {- ^ /@searchText@/: the nul-terminated text to search, or 'Nothing' to disable the search. -} + -> m () +searchSettingsSetSearchText settings searchText = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + maybeSearchText <- case searchText of + Nothing -> return nullPtr + Just jSearchText -> do + jSearchText' <- textToCString jSearchText + return jSearchText' + gtk_source_search_settings_set_search_text settings' maybeSearchText + touchManagedPtr settings + freeMem maybeSearchText + return () + +#if ENABLE_OVERLOADING +data SearchSettingsSetSearchTextMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsSearchSettings a) => O.MethodInfo SearchSettingsSetSearchTextMethodInfo a signature where + overloadedMethod _ = searchSettingsSetSearchText + +#endif + +-- method SearchSettings::set_wrap_around +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "settings", argType = TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSearchSettings.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "wrap_around", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the setting.", 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_search_settings_set_wrap_around" gtk_source_search_settings_set_wrap_around :: + Ptr SearchSettings -> -- settings : TInterface (Name {namespace = "GtkSource", name = "SearchSettings"}) + CInt -> -- wrap_around : TBasicType TBoolean + IO () + +{- | +Enables or disables the wrap around search. If /@wrapAround@/ is 'True', the +forward search continues at the beginning of the buffer if no search +occurrences are found. Similarly, the backward search continues to search at +the end of the buffer. + +/Since: 3.10/ +-} +searchSettingsSetWrapAround :: + (B.CallStack.HasCallStack, MonadIO m, IsSearchSettings a) => + a + {- ^ /@settings@/: a 'GI.GtkSource.Objects.SearchSettings.SearchSettings'. -} + -> Bool + {- ^ /@wrapAround@/: the setting. -} + -> m () +searchSettingsSetWrapAround settings wrapAround = liftIO $ do + settings' <- unsafeManagedPtrCastPtr settings + let wrapAround' = (fromIntegral . fromEnum) wrapAround + gtk_source_search_settings_set_wrap_around settings' wrapAround' + touchManagedPtr settings + return () + +#if ENABLE_OVERLOADING +data SearchSettingsSetWrapAroundMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSearchSettings a) => O.MethodInfo SearchSettingsSetWrapAroundMethodInfo a signature where + overloadedMethod _ = searchSettingsSetWrapAround + +#endif + + diff --git a/GI/GtkSource/Objects/SearchSettings.hs-boot b/GI/GtkSource/Objects/SearchSettings.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/SearchSettings.hs-boot @@ -0,0 +1,74 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.SearchSettings 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 SearchSettings = SearchSettings (ManagedPtr SearchSettings) +instance GObject SearchSettings where +class (GObject o, O.IsDescendantOf SearchSettings o) => IsSearchSettings o +instance (GObject o, O.IsDescendantOf SearchSettings o) => IsSearchSettings o +instance O.HasParentTypes SearchSettings +#if ENABLE_OVERLOADING +data SearchSettingsAtWordBoundariesPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SearchSettingsCaseSensitivePropertyInfo +#endif +#if ENABLE_OVERLOADING +data SearchSettingsRegexEnabledPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SearchSettingsSearchTextPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SearchSettingsWrapAroundPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SearchSettingsGetAtWordBoundariesMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchSettingsGetCaseSensitiveMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchSettingsGetRegexEnabledMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchSettingsGetSearchTextMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchSettingsGetWrapAroundMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchSettingsSetAtWordBoundariesMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchSettingsSetCaseSensitiveMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchSettingsSetRegexEnabledMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchSettingsSetSearchTextMethodInfo +#endif +#if ENABLE_OVERLOADING +data SearchSettingsSetWrapAroundMethodInfo +#endif diff --git a/GI/GtkSource/Objects/SpaceDrawer.hs b/GI/GtkSource/Objects/SpaceDrawer.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/SpaceDrawer.hs @@ -0,0 +1,704 @@ + + +{- | +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.SpaceDrawer + ( + +-- * Exported types + SpaceDrawer(..) , + IsSpaceDrawer , + toSpaceDrawer , + noSpaceDrawer , + + + -- * Methods +-- ** bindMatrixSetting #method:bindMatrixSetting# + +#if ENABLE_OVERLOADING + SpaceDrawerBindMatrixSettingMethodInfo , +#endif + spaceDrawerBindMatrixSetting , + + +-- ** getEnableMatrix #method:getEnableMatrix# + +#if ENABLE_OVERLOADING + SpaceDrawerGetEnableMatrixMethodInfo , +#endif + spaceDrawerGetEnableMatrix , + + +-- ** getMatrix #method:getMatrix# + +#if ENABLE_OVERLOADING + SpaceDrawerGetMatrixMethodInfo , +#endif + spaceDrawerGetMatrix , + + +-- ** getTypesForLocations #method:getTypesForLocations# + +#if ENABLE_OVERLOADING + SpaceDrawerGetTypesForLocationsMethodInfo, +#endif + spaceDrawerGetTypesForLocations , + + +-- ** new #method:new# + + spaceDrawerNew , + + +-- ** setEnableMatrix #method:setEnableMatrix# + +#if ENABLE_OVERLOADING + SpaceDrawerSetEnableMatrixMethodInfo , +#endif + spaceDrawerSetEnableMatrix , + + +-- ** setMatrix #method:setMatrix# + +#if ENABLE_OVERLOADING + SpaceDrawerSetMatrixMethodInfo , +#endif + spaceDrawerSetMatrix , + + +-- ** setTypesForLocations #method:setTypesForLocations# + +#if ENABLE_OVERLOADING + SpaceDrawerSetTypesForLocationsMethodInfo, +#endif + spaceDrawerSetTypesForLocations , + + + + + -- * Properties +-- ** enableMatrix #attr:enableMatrix# +{- | Whether the 'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer':@/matrix/@ property is enabled. + +/Since: 3.24/ +-} +#if ENABLE_OVERLOADING + SpaceDrawerEnableMatrixPropertyInfo , +#endif + constructSpaceDrawerEnableMatrix , + getSpaceDrawerEnableMatrix , + setSpaceDrawerEnableMatrix , +#if ENABLE_OVERLOADING + spaceDrawerEnableMatrix , +#endif + + +-- ** matrix #attr:matrix# +{- | The :matrix property is a 'GVariant' property to specify where and +what kind of white spaces to draw. + +The 'GVariant' is of type @\"au\"@, an array of unsigned integers. Each +integer is a combination of 'GI.GtkSource.Flags.SpaceTypeFlags'. There is one +integer for each 'GI.GtkSource.Flags.SpaceLocationFlags', in the same order as +they are defined in the enum ('GI.GtkSource.Flags.SpaceLocationFlagsNone' and +'GI.GtkSource.Flags.SpaceLocationFlagsAll' are not taken into account). + +If the array is shorter than the number of locations, then the value +for the missing locations will be 'GI.GtkSource.Flags.SpaceTypeFlagsNone'. + +By default, 'GI.GtkSource.Flags.SpaceTypeFlagsAll' is set for all locations. + +/Since: 3.24/ +-} +#if ENABLE_OVERLOADING + SpaceDrawerMatrixPropertyInfo , +#endif + clearSpaceDrawerMatrix , + constructSpaceDrawerMatrix , + getSpaceDrawerMatrix , + setSpaceDrawerMatrix , +#if ENABLE_OVERLOADING + spaceDrawerMatrix , +#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 qualified GI.Gio.Flags as Gio.Flags +import qualified GI.Gio.Objects.Settings as Gio.Settings +import {-# SOURCE #-} qualified GI.GtkSource.Flags as GtkSource.Flags + +-- | Memory-managed wrapper type. +newtype SpaceDrawer = SpaceDrawer (ManagedPtr SpaceDrawer) +foreign import ccall "gtk_source_space_drawer_get_type" + c_gtk_source_space_drawer_get_type :: IO GType + +instance GObject SpaceDrawer where + gobjectType = c_gtk_source_space_drawer_get_type + + +-- | Type class for types which can be safely cast to `SpaceDrawer`, for instance with `toSpaceDrawer`. +class (GObject o, O.IsDescendantOf SpaceDrawer o) => IsSpaceDrawer o +instance (GObject o, O.IsDescendantOf SpaceDrawer o) => IsSpaceDrawer o + +instance O.HasParentTypes SpaceDrawer +type instance O.ParentTypes SpaceDrawer = '[GObject.Object.Object] + +-- | Cast to `SpaceDrawer`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toSpaceDrawer :: (MonadIO m, IsSpaceDrawer o) => o -> m SpaceDrawer +toSpaceDrawer = liftIO . unsafeCastTo SpaceDrawer + +-- | A convenience alias for `Nothing` :: `Maybe` `SpaceDrawer`. +noSpaceDrawer :: Maybe SpaceDrawer +noSpaceDrawer = Nothing + +#if ENABLE_OVERLOADING +type family ResolveSpaceDrawerMethod (t :: Symbol) (o :: *) :: * where + ResolveSpaceDrawerMethod "bindMatrixSetting" o = SpaceDrawerBindMatrixSettingMethodInfo + ResolveSpaceDrawerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveSpaceDrawerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveSpaceDrawerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveSpaceDrawerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveSpaceDrawerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveSpaceDrawerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveSpaceDrawerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveSpaceDrawerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveSpaceDrawerMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveSpaceDrawerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveSpaceDrawerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveSpaceDrawerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveSpaceDrawerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveSpaceDrawerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveSpaceDrawerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveSpaceDrawerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveSpaceDrawerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveSpaceDrawerMethod "getEnableMatrix" o = SpaceDrawerGetEnableMatrixMethodInfo + ResolveSpaceDrawerMethod "getMatrix" o = SpaceDrawerGetMatrixMethodInfo + ResolveSpaceDrawerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveSpaceDrawerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveSpaceDrawerMethod "getTypesForLocations" o = SpaceDrawerGetTypesForLocationsMethodInfo + ResolveSpaceDrawerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveSpaceDrawerMethod "setEnableMatrix" o = SpaceDrawerSetEnableMatrixMethodInfo + ResolveSpaceDrawerMethod "setMatrix" o = SpaceDrawerSetMatrixMethodInfo + ResolveSpaceDrawerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveSpaceDrawerMethod "setTypesForLocations" o = SpaceDrawerSetTypesForLocationsMethodInfo + ResolveSpaceDrawerMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSpaceDrawerMethod t SpaceDrawer, O.MethodInfo info SpaceDrawer p) => OL.IsLabel t (SpaceDrawer -> 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 + +-- VVV Prop "enable-matrix" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@enable-matrix@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' spaceDrawer #enableMatrix +@ +-} +getSpaceDrawerEnableMatrix :: (MonadIO m, IsSpaceDrawer o) => o -> m Bool +getSpaceDrawerEnableMatrix obj = liftIO $ B.Properties.getObjectPropertyBool obj "enable-matrix" + +{- | +Set the value of the “@enable-matrix@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' spaceDrawer [ #enableMatrix 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSpaceDrawerEnableMatrix :: (MonadIO m, IsSpaceDrawer o) => o -> Bool -> m () +setSpaceDrawerEnableMatrix obj val = liftIO $ B.Properties.setObjectPropertyBool obj "enable-matrix" val + +{- | +Construct a `GValueConstruct` with valid value for the “@enable-matrix@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSpaceDrawerEnableMatrix :: (IsSpaceDrawer o) => Bool -> IO (GValueConstruct o) +constructSpaceDrawerEnableMatrix val = B.Properties.constructObjectPropertyBool "enable-matrix" val + +#if ENABLE_OVERLOADING +data SpaceDrawerEnableMatrixPropertyInfo +instance AttrInfo SpaceDrawerEnableMatrixPropertyInfo where + type AttrAllowedOps SpaceDrawerEnableMatrixPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint SpaceDrawerEnableMatrixPropertyInfo = (~) Bool + type AttrBaseTypeConstraint SpaceDrawerEnableMatrixPropertyInfo = IsSpaceDrawer + type AttrGetType SpaceDrawerEnableMatrixPropertyInfo = Bool + type AttrLabel SpaceDrawerEnableMatrixPropertyInfo = "enable-matrix" + type AttrOrigin SpaceDrawerEnableMatrixPropertyInfo = SpaceDrawer + attrGet _ = getSpaceDrawerEnableMatrix + attrSet _ = setSpaceDrawerEnableMatrix + attrConstruct _ = constructSpaceDrawerEnableMatrix + attrClear _ = undefined +#endif + +-- VVV Prop "matrix" + -- Type: TVariant + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] + -- Nullable: (Nothing,Just True) + +{- | +Get the value of the “@matrix@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' spaceDrawer #matrix +@ +-} +getSpaceDrawerMatrix :: (MonadIO m, IsSpaceDrawer o) => o -> m (Maybe GVariant) +getSpaceDrawerMatrix obj = liftIO $ B.Properties.getObjectPropertyVariant obj "matrix" + +{- | +Set the value of the “@matrix@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' spaceDrawer [ #matrix 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setSpaceDrawerMatrix :: (MonadIO m, IsSpaceDrawer o) => o -> GVariant -> m () +setSpaceDrawerMatrix obj val = liftIO $ B.Properties.setObjectPropertyVariant obj "matrix" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@matrix@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructSpaceDrawerMatrix :: (IsSpaceDrawer o) => GVariant -> IO (GValueConstruct o) +constructSpaceDrawerMatrix val = B.Properties.constructObjectPropertyVariant "matrix" (Just val) + +{- | +Set the value of the “@matrix@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #matrix +@ +-} +clearSpaceDrawerMatrix :: (MonadIO m, IsSpaceDrawer o) => o -> m () +clearSpaceDrawerMatrix obj = liftIO $ B.Properties.setObjectPropertyVariant obj "matrix" (Nothing :: Maybe GVariant) + +#if ENABLE_OVERLOADING +data SpaceDrawerMatrixPropertyInfo +instance AttrInfo SpaceDrawerMatrixPropertyInfo where + type AttrAllowedOps SpaceDrawerMatrixPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint SpaceDrawerMatrixPropertyInfo = (~) GVariant + type AttrBaseTypeConstraint SpaceDrawerMatrixPropertyInfo = IsSpaceDrawer + type AttrGetType SpaceDrawerMatrixPropertyInfo = (Maybe GVariant) + type AttrLabel SpaceDrawerMatrixPropertyInfo = "matrix" + type AttrOrigin SpaceDrawerMatrixPropertyInfo = SpaceDrawer + attrGet _ = getSpaceDrawerMatrix + attrSet _ = setSpaceDrawerMatrix + attrConstruct _ = constructSpaceDrawerMatrix + attrClear _ = clearSpaceDrawerMatrix +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList SpaceDrawer +type instance O.AttributeList SpaceDrawer = SpaceDrawerAttributeList +type SpaceDrawerAttributeList = ('[ '("enableMatrix", SpaceDrawerEnableMatrixPropertyInfo), '("matrix", SpaceDrawerMatrixPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +spaceDrawerEnableMatrix :: AttrLabelProxy "enableMatrix" +spaceDrawerEnableMatrix = AttrLabelProxy + +spaceDrawerMatrix :: AttrLabelProxy "matrix" +spaceDrawerMatrix = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList SpaceDrawer = SpaceDrawerSignalList +type SpaceDrawerSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method SpaceDrawer::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "SpaceDrawer"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_space_drawer_new" gtk_source_space_drawer_new :: + IO (Ptr SpaceDrawer) + +{- | +Creates a new 'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer' object. Useful for storing space drawing +settings independently of a 'GI.GtkSource.Objects.View.View'. + +/Since: 3.24/ +-} +spaceDrawerNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m SpaceDrawer + {- ^ __Returns:__ a new 'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer'. -} +spaceDrawerNew = liftIO $ do + result <- gtk_source_space_drawer_new + checkUnexpectedReturnNULL "spaceDrawerNew" result + result' <- (wrapObject SpaceDrawer) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method SpaceDrawer::bind_matrix_setting +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "drawer", argType = TInterface (Name {namespace = "GtkSource", name = "SpaceDrawer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSpaceDrawer object.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "settings", argType = TInterface (Name {namespace = "Gio", name = "Settings"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSettings object.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the @settings key to bind.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "SettingsBindFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags for the binding.", 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_space_drawer_bind_matrix_setting" gtk_source_space_drawer_bind_matrix_setting :: + Ptr SpaceDrawer -> -- drawer : TInterface (Name {namespace = "GtkSource", name = "SpaceDrawer"}) + Ptr Gio.Settings.Settings -> -- settings : TInterface (Name {namespace = "Gio", name = "Settings"}) + CString -> -- key : TBasicType TUTF8 + CUInt -> -- flags : TInterface (Name {namespace = "Gio", name = "SettingsBindFlags"}) + IO () + +{- | +Binds the 'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer':@/matrix/@ property to a 'GI.Gio.Objects.Settings.Settings' key. + +The 'GI.Gio.Objects.Settings.Settings' key must be of the same type as the +'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer':@/matrix/@ property, that is, @\"au\"@. + +The 'GI.Gio.Objects.Settings.settingsBind' function cannot be used, because the default GIO +mapping functions don\'t support 'GVariant' properties (maybe it will be +supported by a future GIO version, in which case this function can be +deprecated). + +/Since: 3.24/ +-} +spaceDrawerBindMatrixSetting :: + (B.CallStack.HasCallStack, MonadIO m, IsSpaceDrawer a, Gio.Settings.IsSettings b) => + a + {- ^ /@drawer@/: a 'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer' object. -} + -> b + {- ^ /@settings@/: a 'GI.Gio.Objects.Settings.Settings' object. -} + -> T.Text + {- ^ /@key@/: the /@settings@/ key to bind. -} + -> [Gio.Flags.SettingsBindFlags] + {- ^ /@flags@/: flags for the binding. -} + -> m () +spaceDrawerBindMatrixSetting drawer settings key flags = liftIO $ do + drawer' <- unsafeManagedPtrCastPtr drawer + settings' <- unsafeManagedPtrCastPtr settings + key' <- textToCString key + let flags' = gflagsToWord flags + gtk_source_space_drawer_bind_matrix_setting drawer' settings' key' flags' + touchManagedPtr drawer + touchManagedPtr settings + freeMem key' + return () + +#if ENABLE_OVERLOADING +data SpaceDrawerBindMatrixSettingMethodInfo +instance (signature ~ (b -> T.Text -> [Gio.Flags.SettingsBindFlags] -> m ()), MonadIO m, IsSpaceDrawer a, Gio.Settings.IsSettings b) => O.MethodInfo SpaceDrawerBindMatrixSettingMethodInfo a signature where + overloadedMethod _ = spaceDrawerBindMatrixSetting + +#endif + +-- method SpaceDrawer::get_enable_matrix +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "drawer", argType = TInterface (Name {namespace = "GtkSource", name = "SpaceDrawer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSpaceDrawer.", 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_space_drawer_get_enable_matrix" gtk_source_space_drawer_get_enable_matrix :: + Ptr SpaceDrawer -> -- drawer : TInterface (Name {namespace = "GtkSource", name = "SpaceDrawer"}) + IO CInt + +{- | +/No description available in the introspection data./ + +/Since: 3.24/ +-} +spaceDrawerGetEnableMatrix :: + (B.CallStack.HasCallStack, MonadIO m, IsSpaceDrawer a) => + a + {- ^ /@drawer@/: a 'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer'. -} + -> m Bool + {- ^ __Returns:__ whether the 'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer':@/matrix/@ property is enabled. -} +spaceDrawerGetEnableMatrix drawer = liftIO $ do + drawer' <- unsafeManagedPtrCastPtr drawer + result <- gtk_source_space_drawer_get_enable_matrix drawer' + let result' = (/= 0) result + touchManagedPtr drawer + return result' + +#if ENABLE_OVERLOADING +data SpaceDrawerGetEnableMatrixMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSpaceDrawer a) => O.MethodInfo SpaceDrawerGetEnableMatrixMethodInfo a signature where + overloadedMethod _ = spaceDrawerGetEnableMatrix + +#endif + +-- method SpaceDrawer::get_matrix +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "drawer", argType = TInterface (Name {namespace = "GtkSource", name = "SpaceDrawer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSpaceDrawer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just TVariant +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_space_drawer_get_matrix" gtk_source_space_drawer_get_matrix :: + Ptr SpaceDrawer -> -- drawer : TInterface (Name {namespace = "GtkSource", name = "SpaceDrawer"}) + IO (Ptr GVariant) + +{- | +Gets the value of the 'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer':@/matrix/@ property, as a 'GVariant'. +An empty array can be returned in case the matrix is a zero matrix. + +The 'GI.GtkSource.Objects.SpaceDrawer.spaceDrawerGetTypesForLocations' function may be more +convenient to use. + +/Since: 3.24/ +-} +spaceDrawerGetMatrix :: + (B.CallStack.HasCallStack, MonadIO m, IsSpaceDrawer a) => + a + {- ^ /@drawer@/: a 'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer'. -} + -> m GVariant + {- ^ __Returns:__ the 'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer':@/matrix/@ value as a new floating 'GVariant' + instance. -} +spaceDrawerGetMatrix drawer = liftIO $ do + drawer' <- unsafeManagedPtrCastPtr drawer + result <- gtk_source_space_drawer_get_matrix drawer' + checkUnexpectedReturnNULL "spaceDrawerGetMatrix" result + result' <- B.GVariant.wrapGVariantPtr result + touchManagedPtr drawer + return result' + +#if ENABLE_OVERLOADING +data SpaceDrawerGetMatrixMethodInfo +instance (signature ~ (m GVariant), MonadIO m, IsSpaceDrawer a) => O.MethodInfo SpaceDrawerGetMatrixMethodInfo a signature where + overloadedMethod _ = spaceDrawerGetMatrix + +#endif + +-- method SpaceDrawer::get_types_for_locations +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "drawer", argType = TInterface (Name {namespace = "GtkSource", name = "SpaceDrawer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSpaceDrawer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "locations", argType = TInterface (Name {namespace = "GtkSource", name = "SpaceLocationFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "one or several #GtkSourceSpaceLocationFlags.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "SpaceTypeFlags"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_space_drawer_get_types_for_locations" gtk_source_space_drawer_get_types_for_locations :: + Ptr SpaceDrawer -> -- drawer : TInterface (Name {namespace = "GtkSource", name = "SpaceDrawer"}) + CUInt -> -- locations : TInterface (Name {namespace = "GtkSource", name = "SpaceLocationFlags"}) + IO CUInt + +{- | +If only one location is specified, this function returns what kind of +white spaces are drawn at that location. The value is retrieved from the +'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer':@/matrix/@ property. + +If several locations are specified, this function returns the logical AND for +those locations. Which means that if a certain kind of white space is present +in the return value, then that kind of white space is drawn at all the +specified /@locations@/. + +/Since: 3.24/ +-} +spaceDrawerGetTypesForLocations :: + (B.CallStack.HasCallStack, MonadIO m, IsSpaceDrawer a) => + a + {- ^ /@drawer@/: a 'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer'. -} + -> [GtkSource.Flags.SpaceLocationFlags] + {- ^ /@locations@/: one or several 'GI.GtkSource.Flags.SpaceLocationFlags'. -} + -> m [GtkSource.Flags.SpaceTypeFlags] + {- ^ __Returns:__ a combination of 'GI.GtkSource.Flags.SpaceTypeFlags'. -} +spaceDrawerGetTypesForLocations drawer locations = liftIO $ do + drawer' <- unsafeManagedPtrCastPtr drawer + let locations' = gflagsToWord locations + result <- gtk_source_space_drawer_get_types_for_locations drawer' locations' + let result' = wordToGFlags result + touchManagedPtr drawer + return result' + +#if ENABLE_OVERLOADING +data SpaceDrawerGetTypesForLocationsMethodInfo +instance (signature ~ ([GtkSource.Flags.SpaceLocationFlags] -> m [GtkSource.Flags.SpaceTypeFlags]), MonadIO m, IsSpaceDrawer a) => O.MethodInfo SpaceDrawerGetTypesForLocationsMethodInfo a signature where + overloadedMethod _ = spaceDrawerGetTypesForLocations + +#endif + +-- method SpaceDrawer::set_enable_matrix +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "drawer", argType = TInterface (Name {namespace = "GtkSource", name = "SpaceDrawer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSpaceDrawer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enable_matrix", 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_space_drawer_set_enable_matrix" gtk_source_space_drawer_set_enable_matrix :: + Ptr SpaceDrawer -> -- drawer : TInterface (Name {namespace = "GtkSource", name = "SpaceDrawer"}) + CInt -> -- enable_matrix : TBasicType TBoolean + IO () + +{- | +Sets whether the 'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer':@/matrix/@ property is enabled. + +/Since: 3.24/ +-} +spaceDrawerSetEnableMatrix :: + (B.CallStack.HasCallStack, MonadIO m, IsSpaceDrawer a) => + a + {- ^ /@drawer@/: a 'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer'. -} + -> Bool + {- ^ /@enableMatrix@/: the new value. -} + -> m () +spaceDrawerSetEnableMatrix drawer enableMatrix = liftIO $ do + drawer' <- unsafeManagedPtrCastPtr drawer + let enableMatrix' = (fromIntegral . fromEnum) enableMatrix + gtk_source_space_drawer_set_enable_matrix drawer' enableMatrix' + touchManagedPtr drawer + return () + +#if ENABLE_OVERLOADING +data SpaceDrawerSetEnableMatrixMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsSpaceDrawer a) => O.MethodInfo SpaceDrawerSetEnableMatrixMethodInfo a signature where + overloadedMethod _ = spaceDrawerSetEnableMatrix + +#endif + +-- method SpaceDrawer::set_matrix +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "drawer", argType = TInterface (Name {namespace = "GtkSource", name = "SpaceDrawer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSpaceDrawer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "matrix", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the new matrix value, 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_space_drawer_set_matrix" gtk_source_space_drawer_set_matrix :: + Ptr SpaceDrawer -> -- drawer : TInterface (Name {namespace = "GtkSource", name = "SpaceDrawer"}) + Ptr GVariant -> -- matrix : TVariant + IO () + +{- | +Sets a new value to the 'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer':@/matrix/@ property, as a +'GVariant'. If /@matrix@/ is 'Nothing', then an empty array is set. + +If /@matrix@/ is floating, it is consumed. + +The 'GI.GtkSource.Objects.SpaceDrawer.spaceDrawerSetTypesForLocations' function may be more +convenient to use. + +/Since: 3.24/ +-} +spaceDrawerSetMatrix :: + (B.CallStack.HasCallStack, MonadIO m, IsSpaceDrawer a) => + a + {- ^ /@drawer@/: a 'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer'. -} + -> Maybe (GVariant) + {- ^ /@matrix@/: the new matrix value, or 'Nothing'. -} + -> m () +spaceDrawerSetMatrix drawer matrix = liftIO $ do + drawer' <- unsafeManagedPtrCastPtr drawer + maybeMatrix <- case matrix of + Nothing -> return nullPtr + Just jMatrix -> do + jMatrix' <- unsafeManagedPtrGetPtr jMatrix + return jMatrix' + gtk_source_space_drawer_set_matrix drawer' maybeMatrix + touchManagedPtr drawer + whenJust matrix touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data SpaceDrawerSetMatrixMethodInfo +instance (signature ~ (Maybe (GVariant) -> m ()), MonadIO m, IsSpaceDrawer a) => O.MethodInfo SpaceDrawerSetMatrixMethodInfo a signature where + overloadedMethod _ = spaceDrawerSetMatrix + +#endif + +-- method SpaceDrawer::set_types_for_locations +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "drawer", argType = TInterface (Name {namespace = "GtkSource", name = "SpaceDrawer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceSpaceDrawer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "locations", argType = TInterface (Name {namespace = "GtkSource", name = "SpaceLocationFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "one or several #GtkSourceSpaceLocationFlags.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "types", argType = TInterface (Name {namespace = "GtkSource", name = "SpaceTypeFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a combination of #GtkSourceSpaceTypeFlags.", 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_space_drawer_set_types_for_locations" gtk_source_space_drawer_set_types_for_locations :: + Ptr SpaceDrawer -> -- drawer : TInterface (Name {namespace = "GtkSource", name = "SpaceDrawer"}) + CUInt -> -- locations : TInterface (Name {namespace = "GtkSource", name = "SpaceLocationFlags"}) + CUInt -> -- types : TInterface (Name {namespace = "GtkSource", name = "SpaceTypeFlags"}) + IO () + +{- | +Modifies the 'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer':@/matrix/@ property at the specified +/@locations@/. + +/Since: 3.24/ +-} +spaceDrawerSetTypesForLocations :: + (B.CallStack.HasCallStack, MonadIO m, IsSpaceDrawer a) => + a + {- ^ /@drawer@/: a 'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer'. -} + -> [GtkSource.Flags.SpaceLocationFlags] + {- ^ /@locations@/: one or several 'GI.GtkSource.Flags.SpaceLocationFlags'. -} + -> [GtkSource.Flags.SpaceTypeFlags] + {- ^ /@types@/: a combination of 'GI.GtkSource.Flags.SpaceTypeFlags'. -} + -> m () +spaceDrawerSetTypesForLocations drawer locations types = liftIO $ do + drawer' <- unsafeManagedPtrCastPtr drawer + let locations' = gflagsToWord locations + let types' = gflagsToWord types + gtk_source_space_drawer_set_types_for_locations drawer' locations' types' + touchManagedPtr drawer + return () + +#if ENABLE_OVERLOADING +data SpaceDrawerSetTypesForLocationsMethodInfo +instance (signature ~ ([GtkSource.Flags.SpaceLocationFlags] -> [GtkSource.Flags.SpaceTypeFlags] -> m ()), MonadIO m, IsSpaceDrawer a) => O.MethodInfo SpaceDrawerSetTypesForLocationsMethodInfo a signature where + overloadedMethod _ = spaceDrawerSetTypesForLocations + +#endif + + diff --git a/GI/GtkSource/Objects/SpaceDrawer.hs-boot b/GI/GtkSource/Objects/SpaceDrawer.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/SpaceDrawer.hs-boot @@ -0,0 +1,56 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.SpaceDrawer 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 SpaceDrawer = SpaceDrawer (ManagedPtr SpaceDrawer) +instance GObject SpaceDrawer where +class (GObject o, O.IsDescendantOf SpaceDrawer o) => IsSpaceDrawer o +instance (GObject o, O.IsDescendantOf SpaceDrawer o) => IsSpaceDrawer o +instance O.HasParentTypes SpaceDrawer +#if ENABLE_OVERLOADING +data SpaceDrawerEnableMatrixPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SpaceDrawerMatrixPropertyInfo +#endif +#if ENABLE_OVERLOADING +data SpaceDrawerBindMatrixSettingMethodInfo +#endif +#if ENABLE_OVERLOADING +data SpaceDrawerGetEnableMatrixMethodInfo +#endif +#if ENABLE_OVERLOADING +data SpaceDrawerGetMatrixMethodInfo +#endif +#if ENABLE_OVERLOADING +data SpaceDrawerGetTypesForLocationsMethodInfo +#endif +#if ENABLE_OVERLOADING +data SpaceDrawerSetEnableMatrixMethodInfo +#endif +#if ENABLE_OVERLOADING +data SpaceDrawerSetMatrixMethodInfo +#endif +#if ENABLE_OVERLOADING +data SpaceDrawerSetTypesForLocationsMethodInfo +#endif diff --git a/GI/GtkSource/Objects/Style.hs b/GI/GtkSource/Objects/Style.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/Style.hs @@ -0,0 +1,1240 @@ + + +{- | +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.Style + ( + +-- * Exported types + Style(..) , + IsStyle , + toStyle , + noStyle , + + + -- * Methods +-- ** apply #method:apply# + +#if ENABLE_OVERLOADING + StyleApplyMethodInfo , +#endif + styleApply , + + +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + StyleCopyMethodInfo , +#endif + styleCopy , + + + + + -- * Properties +-- ** background #attr:background# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + StyleBackgroundPropertyInfo , +#endif + constructStyleBackground , + getStyleBackground , +#if ENABLE_OVERLOADING + styleBackground , +#endif + + +-- ** backgroundSet #attr:backgroundSet# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + StyleBackgroundSetPropertyInfo , +#endif + constructStyleBackgroundSet , + getStyleBackgroundSet , +#if ENABLE_OVERLOADING + styleBackgroundSet , +#endif + + +-- ** bold #attr:bold# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + StyleBoldPropertyInfo , +#endif + constructStyleBold , + getStyleBold , +#if ENABLE_OVERLOADING + styleBold , +#endif + + +-- ** boldSet #attr:boldSet# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + StyleBoldSetPropertyInfo , +#endif + constructStyleBoldSet , + getStyleBoldSet , +#if ENABLE_OVERLOADING + styleBoldSet , +#endif + + +-- ** foreground #attr:foreground# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + StyleForegroundPropertyInfo , +#endif + constructStyleForeground , + getStyleForeground , +#if ENABLE_OVERLOADING + styleForeground , +#endif + + +-- ** foregroundSet #attr:foregroundSet# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + StyleForegroundSetPropertyInfo , +#endif + constructStyleForegroundSet , + getStyleForegroundSet , +#if ENABLE_OVERLOADING + styleForegroundSet , +#endif + + +-- ** italic #attr:italic# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + StyleItalicPropertyInfo , +#endif + constructStyleItalic , + getStyleItalic , +#if ENABLE_OVERLOADING + styleItalic , +#endif + + +-- ** italicSet #attr:italicSet# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + StyleItalicSetPropertyInfo , +#endif + constructStyleItalicSet , + getStyleItalicSet , +#if ENABLE_OVERLOADING + styleItalicSet , +#endif + + +-- ** lineBackground #attr:lineBackground# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + StyleLineBackgroundPropertyInfo , +#endif + constructStyleLineBackground , + getStyleLineBackground , +#if ENABLE_OVERLOADING + styleLineBackground , +#endif + + +-- ** lineBackgroundSet #attr:lineBackgroundSet# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + StyleLineBackgroundSetPropertyInfo , +#endif + constructStyleLineBackgroundSet , + getStyleLineBackgroundSet , +#if ENABLE_OVERLOADING + styleLineBackgroundSet , +#endif + + +-- ** pangoUnderline #attr:pangoUnderline# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + StylePangoUnderlinePropertyInfo , +#endif + constructStylePangoUnderline , + getStylePangoUnderline , +#if ENABLE_OVERLOADING + stylePangoUnderline , +#endif + + +-- ** scale #attr:scale# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + StyleScalePropertyInfo , +#endif + constructStyleScale , + getStyleScale , +#if ENABLE_OVERLOADING + styleScale , +#endif + + +-- ** scaleSet #attr:scaleSet# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + StyleScaleSetPropertyInfo , +#endif + constructStyleScaleSet , + getStyleScaleSet , +#if ENABLE_OVERLOADING + styleScaleSet , +#endif + + +-- ** strikethrough #attr:strikethrough# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + StyleStrikethroughPropertyInfo , +#endif + constructStyleStrikethrough , + getStyleStrikethrough , +#if ENABLE_OVERLOADING + styleStrikethrough , +#endif + + +-- ** strikethroughSet #attr:strikethroughSet# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + StyleStrikethroughSetPropertyInfo , +#endif + constructStyleStrikethroughSet , + getStyleStrikethroughSet , +#if ENABLE_OVERLOADING + styleStrikethroughSet , +#endif + + +-- ** underline #attr:underline# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + StyleUnderlinePropertyInfo , +#endif + constructStyleUnderline , + getStyleUnderline , +#if ENABLE_OVERLOADING + styleUnderline , +#endif + + +-- ** underlineColor #attr:underlineColor# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + StyleUnderlineColorPropertyInfo , +#endif + constructStyleUnderlineColor , + getStyleUnderlineColor , +#if ENABLE_OVERLOADING + styleUnderlineColor , +#endif + + +-- ** underlineColorSet #attr:underlineColorSet# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + StyleUnderlineColorSetPropertyInfo , +#endif + constructStyleUnderlineColorSet , + getStyleUnderlineColorSet , +#if ENABLE_OVERLOADING + styleUnderlineColorSet , +#endif + + +-- ** underlineSet #attr:underlineSet# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + StyleUnderlineSetPropertyInfo , +#endif + constructStyleUnderlineSet , + getStyleUnderlineSet , +#if ENABLE_OVERLOADING + styleUnderlineSet , +#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 qualified GI.Gtk.Objects.TextTag as Gtk.TextTag +import qualified GI.Pango.Enums as Pango.Enums + +-- | Memory-managed wrapper type. +newtype Style = Style (ManagedPtr Style) +foreign import ccall "gtk_source_style_get_type" + c_gtk_source_style_get_type :: IO GType + +instance GObject Style where + gobjectType = c_gtk_source_style_get_type + + +-- | Type class for types which can be safely cast to `Style`, for instance with `toStyle`. +class (GObject o, O.IsDescendantOf Style o) => IsStyle o +instance (GObject o, O.IsDescendantOf Style o) => IsStyle o + +instance O.HasParentTypes Style +type instance O.ParentTypes Style = '[GObject.Object.Object] + +-- | Cast to `Style`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toStyle :: (MonadIO m, IsStyle o) => o -> m Style +toStyle = liftIO . unsafeCastTo Style + +-- | A convenience alias for `Nothing` :: `Maybe` `Style`. +noStyle :: Maybe Style +noStyle = Nothing + +#if ENABLE_OVERLOADING +type family ResolveStyleMethod (t :: Symbol) (o :: *) :: * where + ResolveStyleMethod "apply" o = StyleApplyMethodInfo + ResolveStyleMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveStyleMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveStyleMethod "copy" o = StyleCopyMethodInfo + ResolveStyleMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveStyleMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveStyleMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveStyleMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveStyleMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveStyleMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveStyleMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveStyleMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveStyleMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveStyleMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveStyleMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveStyleMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveStyleMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveStyleMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveStyleMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveStyleMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveStyleMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveStyleMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveStyleMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveStyleMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveStyleMethod t Style, O.MethodInfo info Style p) => OL.IsLabel t (Style -> 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 + +-- VVV Prop "background" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@background@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' style #background +@ +-} +getStyleBackground :: (MonadIO m, IsStyle o) => o -> m (Maybe T.Text) +getStyleBackground obj = liftIO $ B.Properties.getObjectPropertyString obj "background" + +{- | +Construct a `GValueConstruct` with valid value for the “@background@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructStyleBackground :: (IsStyle o) => T.Text -> IO (GValueConstruct o) +constructStyleBackground val = B.Properties.constructObjectPropertyString "background" (Just val) + +#if ENABLE_OVERLOADING +data StyleBackgroundPropertyInfo +instance AttrInfo StyleBackgroundPropertyInfo where + type AttrAllowedOps StyleBackgroundPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint StyleBackgroundPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint StyleBackgroundPropertyInfo = IsStyle + type AttrGetType StyleBackgroundPropertyInfo = (Maybe T.Text) + type AttrLabel StyleBackgroundPropertyInfo = "background" + type AttrOrigin StyleBackgroundPropertyInfo = Style + attrGet _ = getStyleBackground + attrSet _ = undefined + attrConstruct _ = constructStyleBackground + attrClear _ = undefined +#endif + +-- VVV Prop "background-set" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@background-set@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' style #backgroundSet +@ +-} +getStyleBackgroundSet :: (MonadIO m, IsStyle o) => o -> m Bool +getStyleBackgroundSet obj = liftIO $ B.Properties.getObjectPropertyBool obj "background-set" + +{- | +Construct a `GValueConstruct` with valid value for the “@background-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructStyleBackgroundSet :: (IsStyle o) => Bool -> IO (GValueConstruct o) +constructStyleBackgroundSet val = B.Properties.constructObjectPropertyBool "background-set" val + +#if ENABLE_OVERLOADING +data StyleBackgroundSetPropertyInfo +instance AttrInfo StyleBackgroundSetPropertyInfo where + type AttrAllowedOps StyleBackgroundSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint StyleBackgroundSetPropertyInfo = (~) Bool + type AttrBaseTypeConstraint StyleBackgroundSetPropertyInfo = IsStyle + type AttrGetType StyleBackgroundSetPropertyInfo = Bool + type AttrLabel StyleBackgroundSetPropertyInfo = "background-set" + type AttrOrigin StyleBackgroundSetPropertyInfo = Style + attrGet _ = getStyleBackgroundSet + attrSet _ = undefined + attrConstruct _ = constructStyleBackgroundSet + attrClear _ = undefined +#endif + +-- VVV Prop "bold" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@bold@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' style #bold +@ +-} +getStyleBold :: (MonadIO m, IsStyle o) => o -> m Bool +getStyleBold obj = liftIO $ B.Properties.getObjectPropertyBool obj "bold" + +{- | +Construct a `GValueConstruct` with valid value for the “@bold@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructStyleBold :: (IsStyle o) => Bool -> IO (GValueConstruct o) +constructStyleBold val = B.Properties.constructObjectPropertyBool "bold" val + +#if ENABLE_OVERLOADING +data StyleBoldPropertyInfo +instance AttrInfo StyleBoldPropertyInfo where + type AttrAllowedOps StyleBoldPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint StyleBoldPropertyInfo = (~) Bool + type AttrBaseTypeConstraint StyleBoldPropertyInfo = IsStyle + type AttrGetType StyleBoldPropertyInfo = Bool + type AttrLabel StyleBoldPropertyInfo = "bold" + type AttrOrigin StyleBoldPropertyInfo = Style + attrGet _ = getStyleBold + attrSet _ = undefined + attrConstruct _ = constructStyleBold + attrClear _ = undefined +#endif + +-- VVV Prop "bold-set" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@bold-set@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' style #boldSet +@ +-} +getStyleBoldSet :: (MonadIO m, IsStyle o) => o -> m Bool +getStyleBoldSet obj = liftIO $ B.Properties.getObjectPropertyBool obj "bold-set" + +{- | +Construct a `GValueConstruct` with valid value for the “@bold-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructStyleBoldSet :: (IsStyle o) => Bool -> IO (GValueConstruct o) +constructStyleBoldSet val = B.Properties.constructObjectPropertyBool "bold-set" val + +#if ENABLE_OVERLOADING +data StyleBoldSetPropertyInfo +instance AttrInfo StyleBoldSetPropertyInfo where + type AttrAllowedOps StyleBoldSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint StyleBoldSetPropertyInfo = (~) Bool + type AttrBaseTypeConstraint StyleBoldSetPropertyInfo = IsStyle + type AttrGetType StyleBoldSetPropertyInfo = Bool + type AttrLabel StyleBoldSetPropertyInfo = "bold-set" + type AttrOrigin StyleBoldSetPropertyInfo = Style + attrGet _ = getStyleBoldSet + attrSet _ = undefined + attrConstruct _ = constructStyleBoldSet + attrClear _ = undefined +#endif + +-- VVV Prop "foreground" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@foreground@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' style #foreground +@ +-} +getStyleForeground :: (MonadIO m, IsStyle o) => o -> m (Maybe T.Text) +getStyleForeground obj = liftIO $ B.Properties.getObjectPropertyString obj "foreground" + +{- | +Construct a `GValueConstruct` with valid value for the “@foreground@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructStyleForeground :: (IsStyle o) => T.Text -> IO (GValueConstruct o) +constructStyleForeground val = B.Properties.constructObjectPropertyString "foreground" (Just val) + +#if ENABLE_OVERLOADING +data StyleForegroundPropertyInfo +instance AttrInfo StyleForegroundPropertyInfo where + type AttrAllowedOps StyleForegroundPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint StyleForegroundPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint StyleForegroundPropertyInfo = IsStyle + type AttrGetType StyleForegroundPropertyInfo = (Maybe T.Text) + type AttrLabel StyleForegroundPropertyInfo = "foreground" + type AttrOrigin StyleForegroundPropertyInfo = Style + attrGet _ = getStyleForeground + attrSet _ = undefined + attrConstruct _ = constructStyleForeground + attrClear _ = undefined +#endif + +-- VVV Prop "foreground-set" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@foreground-set@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' style #foregroundSet +@ +-} +getStyleForegroundSet :: (MonadIO m, IsStyle o) => o -> m Bool +getStyleForegroundSet obj = liftIO $ B.Properties.getObjectPropertyBool obj "foreground-set" + +{- | +Construct a `GValueConstruct` with valid value for the “@foreground-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructStyleForegroundSet :: (IsStyle o) => Bool -> IO (GValueConstruct o) +constructStyleForegroundSet val = B.Properties.constructObjectPropertyBool "foreground-set" val + +#if ENABLE_OVERLOADING +data StyleForegroundSetPropertyInfo +instance AttrInfo StyleForegroundSetPropertyInfo where + type AttrAllowedOps StyleForegroundSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint StyleForegroundSetPropertyInfo = (~) Bool + type AttrBaseTypeConstraint StyleForegroundSetPropertyInfo = IsStyle + type AttrGetType StyleForegroundSetPropertyInfo = Bool + type AttrLabel StyleForegroundSetPropertyInfo = "foreground-set" + type AttrOrigin StyleForegroundSetPropertyInfo = Style + attrGet _ = getStyleForegroundSet + attrSet _ = undefined + attrConstruct _ = constructStyleForegroundSet + attrClear _ = undefined +#endif + +-- VVV Prop "italic" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@italic@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' style #italic +@ +-} +getStyleItalic :: (MonadIO m, IsStyle o) => o -> m Bool +getStyleItalic obj = liftIO $ B.Properties.getObjectPropertyBool obj "italic" + +{- | +Construct a `GValueConstruct` with valid value for the “@italic@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructStyleItalic :: (IsStyle o) => Bool -> IO (GValueConstruct o) +constructStyleItalic val = B.Properties.constructObjectPropertyBool "italic" val + +#if ENABLE_OVERLOADING +data StyleItalicPropertyInfo +instance AttrInfo StyleItalicPropertyInfo where + type AttrAllowedOps StyleItalicPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint StyleItalicPropertyInfo = (~) Bool + type AttrBaseTypeConstraint StyleItalicPropertyInfo = IsStyle + type AttrGetType StyleItalicPropertyInfo = Bool + type AttrLabel StyleItalicPropertyInfo = "italic" + type AttrOrigin StyleItalicPropertyInfo = Style + attrGet _ = getStyleItalic + attrSet _ = undefined + attrConstruct _ = constructStyleItalic + attrClear _ = undefined +#endif + +-- VVV Prop "italic-set" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@italic-set@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' style #italicSet +@ +-} +getStyleItalicSet :: (MonadIO m, IsStyle o) => o -> m Bool +getStyleItalicSet obj = liftIO $ B.Properties.getObjectPropertyBool obj "italic-set" + +{- | +Construct a `GValueConstruct` with valid value for the “@italic-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructStyleItalicSet :: (IsStyle o) => Bool -> IO (GValueConstruct o) +constructStyleItalicSet val = B.Properties.constructObjectPropertyBool "italic-set" val + +#if ENABLE_OVERLOADING +data StyleItalicSetPropertyInfo +instance AttrInfo StyleItalicSetPropertyInfo where + type AttrAllowedOps StyleItalicSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint StyleItalicSetPropertyInfo = (~) Bool + type AttrBaseTypeConstraint StyleItalicSetPropertyInfo = IsStyle + type AttrGetType StyleItalicSetPropertyInfo = Bool + type AttrLabel StyleItalicSetPropertyInfo = "italic-set" + type AttrOrigin StyleItalicSetPropertyInfo = Style + attrGet _ = getStyleItalicSet + attrSet _ = undefined + attrConstruct _ = constructStyleItalicSet + attrClear _ = undefined +#endif + +-- VVV Prop "line-background" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@line-background@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' style #lineBackground +@ +-} +getStyleLineBackground :: (MonadIO m, IsStyle o) => o -> m (Maybe T.Text) +getStyleLineBackground obj = liftIO $ B.Properties.getObjectPropertyString obj "line-background" + +{- | +Construct a `GValueConstruct` with valid value for the “@line-background@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructStyleLineBackground :: (IsStyle o) => T.Text -> IO (GValueConstruct o) +constructStyleLineBackground val = B.Properties.constructObjectPropertyString "line-background" (Just val) + +#if ENABLE_OVERLOADING +data StyleLineBackgroundPropertyInfo +instance AttrInfo StyleLineBackgroundPropertyInfo where + type AttrAllowedOps StyleLineBackgroundPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint StyleLineBackgroundPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint StyleLineBackgroundPropertyInfo = IsStyle + type AttrGetType StyleLineBackgroundPropertyInfo = (Maybe T.Text) + type AttrLabel StyleLineBackgroundPropertyInfo = "line-background" + type AttrOrigin StyleLineBackgroundPropertyInfo = Style + attrGet _ = getStyleLineBackground + attrSet _ = undefined + attrConstruct _ = constructStyleLineBackground + attrClear _ = undefined +#endif + +-- VVV Prop "line-background-set" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@line-background-set@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' style #lineBackgroundSet +@ +-} +getStyleLineBackgroundSet :: (MonadIO m, IsStyle o) => o -> m Bool +getStyleLineBackgroundSet obj = liftIO $ B.Properties.getObjectPropertyBool obj "line-background-set" + +{- | +Construct a `GValueConstruct` with valid value for the “@line-background-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructStyleLineBackgroundSet :: (IsStyle o) => Bool -> IO (GValueConstruct o) +constructStyleLineBackgroundSet val = B.Properties.constructObjectPropertyBool "line-background-set" val + +#if ENABLE_OVERLOADING +data StyleLineBackgroundSetPropertyInfo +instance AttrInfo StyleLineBackgroundSetPropertyInfo where + type AttrAllowedOps StyleLineBackgroundSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint StyleLineBackgroundSetPropertyInfo = (~) Bool + type AttrBaseTypeConstraint StyleLineBackgroundSetPropertyInfo = IsStyle + type AttrGetType StyleLineBackgroundSetPropertyInfo = Bool + type AttrLabel StyleLineBackgroundSetPropertyInfo = "line-background-set" + type AttrOrigin StyleLineBackgroundSetPropertyInfo = Style + attrGet _ = getStyleLineBackgroundSet + attrSet _ = undefined + attrConstruct _ = constructStyleLineBackgroundSet + attrClear _ = undefined +#endif + +-- VVV Prop "pango-underline" + -- Type: TInterface (Name {namespace = "Pango", name = "Underline"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@pango-underline@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' style #pangoUnderline +@ +-} +getStylePangoUnderline :: (MonadIO m, IsStyle o) => o -> m Pango.Enums.Underline +getStylePangoUnderline obj = liftIO $ B.Properties.getObjectPropertyEnum obj "pango-underline" + +{- | +Construct a `GValueConstruct` with valid value for the “@pango-underline@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructStylePangoUnderline :: (IsStyle o) => Pango.Enums.Underline -> IO (GValueConstruct o) +constructStylePangoUnderline val = B.Properties.constructObjectPropertyEnum "pango-underline" val + +#if ENABLE_OVERLOADING +data StylePangoUnderlinePropertyInfo +instance AttrInfo StylePangoUnderlinePropertyInfo where + type AttrAllowedOps StylePangoUnderlinePropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint StylePangoUnderlinePropertyInfo = (~) Pango.Enums.Underline + type AttrBaseTypeConstraint StylePangoUnderlinePropertyInfo = IsStyle + type AttrGetType StylePangoUnderlinePropertyInfo = Pango.Enums.Underline + type AttrLabel StylePangoUnderlinePropertyInfo = "pango-underline" + type AttrOrigin StylePangoUnderlinePropertyInfo = Style + attrGet _ = getStylePangoUnderline + attrSet _ = undefined + attrConstruct _ = constructStylePangoUnderline + attrClear _ = undefined +#endif + +-- VVV Prop "scale" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@scale@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' style #scale +@ +-} +getStyleScale :: (MonadIO m, IsStyle o) => o -> m (Maybe T.Text) +getStyleScale obj = liftIO $ B.Properties.getObjectPropertyString obj "scale" + +{- | +Construct a `GValueConstruct` with valid value for the “@scale@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructStyleScale :: (IsStyle o) => T.Text -> IO (GValueConstruct o) +constructStyleScale val = B.Properties.constructObjectPropertyString "scale" (Just val) + +#if ENABLE_OVERLOADING +data StyleScalePropertyInfo +instance AttrInfo StyleScalePropertyInfo where + type AttrAllowedOps StyleScalePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint StyleScalePropertyInfo = (~) T.Text + type AttrBaseTypeConstraint StyleScalePropertyInfo = IsStyle + type AttrGetType StyleScalePropertyInfo = (Maybe T.Text) + type AttrLabel StyleScalePropertyInfo = "scale" + type AttrOrigin StyleScalePropertyInfo = Style + attrGet _ = getStyleScale + attrSet _ = undefined + attrConstruct _ = constructStyleScale + attrClear _ = undefined +#endif + +-- VVV Prop "scale-set" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@scale-set@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' style #scaleSet +@ +-} +getStyleScaleSet :: (MonadIO m, IsStyle o) => o -> m Bool +getStyleScaleSet obj = liftIO $ B.Properties.getObjectPropertyBool obj "scale-set" + +{- | +Construct a `GValueConstruct` with valid value for the “@scale-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructStyleScaleSet :: (IsStyle o) => Bool -> IO (GValueConstruct o) +constructStyleScaleSet val = B.Properties.constructObjectPropertyBool "scale-set" val + +#if ENABLE_OVERLOADING +data StyleScaleSetPropertyInfo +instance AttrInfo StyleScaleSetPropertyInfo where + type AttrAllowedOps StyleScaleSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint StyleScaleSetPropertyInfo = (~) Bool + type AttrBaseTypeConstraint StyleScaleSetPropertyInfo = IsStyle + type AttrGetType StyleScaleSetPropertyInfo = Bool + type AttrLabel StyleScaleSetPropertyInfo = "scale-set" + type AttrOrigin StyleScaleSetPropertyInfo = Style + attrGet _ = getStyleScaleSet + attrSet _ = undefined + attrConstruct _ = constructStyleScaleSet + attrClear _ = undefined +#endif + +-- VVV Prop "strikethrough" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@strikethrough@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' style #strikethrough +@ +-} +getStyleStrikethrough :: (MonadIO m, IsStyle o) => o -> m Bool +getStyleStrikethrough obj = liftIO $ B.Properties.getObjectPropertyBool obj "strikethrough" + +{- | +Construct a `GValueConstruct` with valid value for the “@strikethrough@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructStyleStrikethrough :: (IsStyle o) => Bool -> IO (GValueConstruct o) +constructStyleStrikethrough val = B.Properties.constructObjectPropertyBool "strikethrough" val + +#if ENABLE_OVERLOADING +data StyleStrikethroughPropertyInfo +instance AttrInfo StyleStrikethroughPropertyInfo where + type AttrAllowedOps StyleStrikethroughPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint StyleStrikethroughPropertyInfo = (~) Bool + type AttrBaseTypeConstraint StyleStrikethroughPropertyInfo = IsStyle + type AttrGetType StyleStrikethroughPropertyInfo = Bool + type AttrLabel StyleStrikethroughPropertyInfo = "strikethrough" + type AttrOrigin StyleStrikethroughPropertyInfo = Style + attrGet _ = getStyleStrikethrough + attrSet _ = undefined + attrConstruct _ = constructStyleStrikethrough + attrClear _ = undefined +#endif + +-- VVV Prop "strikethrough-set" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@strikethrough-set@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' style #strikethroughSet +@ +-} +getStyleStrikethroughSet :: (MonadIO m, IsStyle o) => o -> m Bool +getStyleStrikethroughSet obj = liftIO $ B.Properties.getObjectPropertyBool obj "strikethrough-set" + +{- | +Construct a `GValueConstruct` with valid value for the “@strikethrough-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructStyleStrikethroughSet :: (IsStyle o) => Bool -> IO (GValueConstruct o) +constructStyleStrikethroughSet val = B.Properties.constructObjectPropertyBool "strikethrough-set" val + +#if ENABLE_OVERLOADING +data StyleStrikethroughSetPropertyInfo +instance AttrInfo StyleStrikethroughSetPropertyInfo where + type AttrAllowedOps StyleStrikethroughSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint StyleStrikethroughSetPropertyInfo = (~) Bool + type AttrBaseTypeConstraint StyleStrikethroughSetPropertyInfo = IsStyle + type AttrGetType StyleStrikethroughSetPropertyInfo = Bool + type AttrLabel StyleStrikethroughSetPropertyInfo = "strikethrough-set" + type AttrOrigin StyleStrikethroughSetPropertyInfo = Style + attrGet _ = getStyleStrikethroughSet + attrSet _ = undefined + attrConstruct _ = constructStyleStrikethroughSet + attrClear _ = undefined +#endif + +-- VVV Prop "underline" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@underline@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' style #underline +@ +-} +getStyleUnderline :: (MonadIO m, IsStyle o) => o -> m Bool +getStyleUnderline obj = liftIO $ B.Properties.getObjectPropertyBool obj "underline" + +{- | +Construct a `GValueConstruct` with valid value for the “@underline@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructStyleUnderline :: (IsStyle o) => Bool -> IO (GValueConstruct o) +constructStyleUnderline val = B.Properties.constructObjectPropertyBool "underline" val + +#if ENABLE_OVERLOADING +data StyleUnderlinePropertyInfo +instance AttrInfo StyleUnderlinePropertyInfo where + type AttrAllowedOps StyleUnderlinePropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint StyleUnderlinePropertyInfo = (~) Bool + type AttrBaseTypeConstraint StyleUnderlinePropertyInfo = IsStyle + type AttrGetType StyleUnderlinePropertyInfo = Bool + type AttrLabel StyleUnderlinePropertyInfo = "underline" + type AttrOrigin StyleUnderlinePropertyInfo = Style + attrGet _ = getStyleUnderline + attrSet _ = undefined + attrConstruct _ = constructStyleUnderline + attrClear _ = undefined +#endif + +-- VVV Prop "underline-color" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@underline-color@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' style #underlineColor +@ +-} +getStyleUnderlineColor :: (MonadIO m, IsStyle o) => o -> m (Maybe T.Text) +getStyleUnderlineColor obj = liftIO $ B.Properties.getObjectPropertyString obj "underline-color" + +{- | +Construct a `GValueConstruct` with valid value for the “@underline-color@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructStyleUnderlineColor :: (IsStyle o) => T.Text -> IO (GValueConstruct o) +constructStyleUnderlineColor val = B.Properties.constructObjectPropertyString "underline-color" (Just val) + +#if ENABLE_OVERLOADING +data StyleUnderlineColorPropertyInfo +instance AttrInfo StyleUnderlineColorPropertyInfo where + type AttrAllowedOps StyleUnderlineColorPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint StyleUnderlineColorPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint StyleUnderlineColorPropertyInfo = IsStyle + type AttrGetType StyleUnderlineColorPropertyInfo = (Maybe T.Text) + type AttrLabel StyleUnderlineColorPropertyInfo = "underline-color" + type AttrOrigin StyleUnderlineColorPropertyInfo = Style + attrGet _ = getStyleUnderlineColor + attrSet _ = undefined + attrConstruct _ = constructStyleUnderlineColor + attrClear _ = undefined +#endif + +-- VVV Prop "underline-color-set" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@underline-color-set@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' style #underlineColorSet +@ +-} +getStyleUnderlineColorSet :: (MonadIO m, IsStyle o) => o -> m Bool +getStyleUnderlineColorSet obj = liftIO $ B.Properties.getObjectPropertyBool obj "underline-color-set" + +{- | +Construct a `GValueConstruct` with valid value for the “@underline-color-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructStyleUnderlineColorSet :: (IsStyle o) => Bool -> IO (GValueConstruct o) +constructStyleUnderlineColorSet val = B.Properties.constructObjectPropertyBool "underline-color-set" val + +#if ENABLE_OVERLOADING +data StyleUnderlineColorSetPropertyInfo +instance AttrInfo StyleUnderlineColorSetPropertyInfo where + type AttrAllowedOps StyleUnderlineColorSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint StyleUnderlineColorSetPropertyInfo = (~) Bool + type AttrBaseTypeConstraint StyleUnderlineColorSetPropertyInfo = IsStyle + type AttrGetType StyleUnderlineColorSetPropertyInfo = Bool + type AttrLabel StyleUnderlineColorSetPropertyInfo = "underline-color-set" + type AttrOrigin StyleUnderlineColorSetPropertyInfo = Style + attrGet _ = getStyleUnderlineColorSet + attrSet _ = undefined + attrConstruct _ = constructStyleUnderlineColorSet + attrClear _ = undefined +#endif + +-- VVV Prop "underline-set" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@underline-set@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' style #underlineSet +@ +-} +getStyleUnderlineSet :: (MonadIO m, IsStyle o) => o -> m Bool +getStyleUnderlineSet obj = liftIO $ B.Properties.getObjectPropertyBool obj "underline-set" + +{- | +Construct a `GValueConstruct` with valid value for the “@underline-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructStyleUnderlineSet :: (IsStyle o) => Bool -> IO (GValueConstruct o) +constructStyleUnderlineSet val = B.Properties.constructObjectPropertyBool "underline-set" val + +#if ENABLE_OVERLOADING +data StyleUnderlineSetPropertyInfo +instance AttrInfo StyleUnderlineSetPropertyInfo where + type AttrAllowedOps StyleUnderlineSetPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint StyleUnderlineSetPropertyInfo = (~) Bool + type AttrBaseTypeConstraint StyleUnderlineSetPropertyInfo = IsStyle + type AttrGetType StyleUnderlineSetPropertyInfo = Bool + type AttrLabel StyleUnderlineSetPropertyInfo = "underline-set" + type AttrOrigin StyleUnderlineSetPropertyInfo = Style + attrGet _ = getStyleUnderlineSet + attrSet _ = undefined + attrConstruct _ = constructStyleUnderlineSet + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Style +type instance O.AttributeList Style = StyleAttributeList +type StyleAttributeList = ('[ '("background", StyleBackgroundPropertyInfo), '("backgroundSet", StyleBackgroundSetPropertyInfo), '("bold", StyleBoldPropertyInfo), '("boldSet", StyleBoldSetPropertyInfo), '("foreground", StyleForegroundPropertyInfo), '("foregroundSet", StyleForegroundSetPropertyInfo), '("italic", StyleItalicPropertyInfo), '("italicSet", StyleItalicSetPropertyInfo), '("lineBackground", StyleLineBackgroundPropertyInfo), '("lineBackgroundSet", StyleLineBackgroundSetPropertyInfo), '("pangoUnderline", StylePangoUnderlinePropertyInfo), '("scale", StyleScalePropertyInfo), '("scaleSet", StyleScaleSetPropertyInfo), '("strikethrough", StyleStrikethroughPropertyInfo), '("strikethroughSet", StyleStrikethroughSetPropertyInfo), '("underline", StyleUnderlinePropertyInfo), '("underlineColor", StyleUnderlineColorPropertyInfo), '("underlineColorSet", StyleUnderlineColorSetPropertyInfo), '("underlineSet", StyleUnderlineSetPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +styleBackground :: AttrLabelProxy "background" +styleBackground = AttrLabelProxy + +styleBackgroundSet :: AttrLabelProxy "backgroundSet" +styleBackgroundSet = AttrLabelProxy + +styleBold :: AttrLabelProxy "bold" +styleBold = AttrLabelProxy + +styleBoldSet :: AttrLabelProxy "boldSet" +styleBoldSet = AttrLabelProxy + +styleForeground :: AttrLabelProxy "foreground" +styleForeground = AttrLabelProxy + +styleForegroundSet :: AttrLabelProxy "foregroundSet" +styleForegroundSet = AttrLabelProxy + +styleItalic :: AttrLabelProxy "italic" +styleItalic = AttrLabelProxy + +styleItalicSet :: AttrLabelProxy "italicSet" +styleItalicSet = AttrLabelProxy + +styleLineBackground :: AttrLabelProxy "lineBackground" +styleLineBackground = AttrLabelProxy + +styleLineBackgroundSet :: AttrLabelProxy "lineBackgroundSet" +styleLineBackgroundSet = AttrLabelProxy + +stylePangoUnderline :: AttrLabelProxy "pangoUnderline" +stylePangoUnderline = AttrLabelProxy + +styleScale :: AttrLabelProxy "scale" +styleScale = AttrLabelProxy + +styleScaleSet :: AttrLabelProxy "scaleSet" +styleScaleSet = AttrLabelProxy + +styleStrikethrough :: AttrLabelProxy "strikethrough" +styleStrikethrough = AttrLabelProxy + +styleStrikethroughSet :: AttrLabelProxy "strikethroughSet" +styleStrikethroughSet = AttrLabelProxy + +styleUnderline :: AttrLabelProxy "underline" +styleUnderline = AttrLabelProxy + +styleUnderlineColor :: AttrLabelProxy "underlineColor" +styleUnderlineColor = AttrLabelProxy + +styleUnderlineColorSet :: AttrLabelProxy "underlineColorSet" +styleUnderlineColorSet = AttrLabelProxy + +styleUnderlineSet :: AttrLabelProxy "underlineSet" +styleUnderlineSet = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Style = StyleSignalList +type StyleSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Style::apply +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "style", argType = TInterface (Name {namespace = "GtkSource", name = "Style"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceStyle to apply, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TInterface (Name {namespace = "Gtk", name = "TextTag"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextTag to apply styles to.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_style_apply" gtk_source_style_apply :: + Ptr Style -> -- style : TInterface (Name {namespace = "GtkSource", name = "Style"}) + Ptr Gtk.TextTag.TextTag -> -- tag : TInterface (Name {namespace = "Gtk", name = "TextTag"}) + IO () + +{- | +This function modifies the 'GI.Gtk.Objects.TextTag.TextTag' properties that are related to the +'GI.GtkSource.Objects.Style.Style' properties. Other 'GI.Gtk.Objects.TextTag.TextTag' properties are left untouched. + +If /@style@/ is non-'Nothing', applies /@style@/ to /@tag@/. + +If /@style@/ is 'Nothing', the related *-set properties of 'GI.Gtk.Objects.TextTag.TextTag' are set to +'False'. + +/Since: 3.22/ +-} +styleApply :: + (B.CallStack.HasCallStack, MonadIO m, IsStyle a, Gtk.TextTag.IsTextTag b) => + a + {- ^ /@style@/: a 'GI.GtkSource.Objects.Style.Style' to apply, or 'Nothing'. -} + -> b + {- ^ /@tag@/: a 'GI.Gtk.Objects.TextTag.TextTag' to apply styles to. -} + -> m () +styleApply style tag = liftIO $ do + style' <- unsafeManagedPtrCastPtr style + tag' <- unsafeManagedPtrCastPtr tag + gtk_source_style_apply style' tag' + touchManagedPtr style + touchManagedPtr tag + return () + +#if ENABLE_OVERLOADING +data StyleApplyMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsStyle a, Gtk.TextTag.IsTextTag b) => O.MethodInfo StyleApplyMethodInfo a signature where + overloadedMethod _ = styleApply + +#endif + +-- method Style::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "style", argType = TInterface (Name {namespace = "GtkSource", name = "Style"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceStyle structure to copy.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Style"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_style_copy" gtk_source_style_copy :: + Ptr Style -> -- style : TInterface (Name {namespace = "GtkSource", name = "Style"}) + IO (Ptr Style) + +{- | +Creates a copy of /@style@/, that is a new 'GI.GtkSource.Objects.Style.Style' instance which +has the same attributes set. + +/Since: 2.0/ +-} +styleCopy :: + (B.CallStack.HasCallStack, MonadIO m, IsStyle a) => + a + {- ^ /@style@/: a 'GI.GtkSource.Objects.Style.Style' structure to copy. -} + -> m Style + {- ^ __Returns:__ copy of /@style@/, call 'GI.GObject.Objects.Object.objectUnref' +when you are done with it. -} +styleCopy style = liftIO $ do + style' <- unsafeManagedPtrCastPtr style + result <- gtk_source_style_copy style' + checkUnexpectedReturnNULL "styleCopy" result + result' <- (wrapObject Style) result + touchManagedPtr style + return result' + +#if ENABLE_OVERLOADING +data StyleCopyMethodInfo +instance (signature ~ (m Style), MonadIO m, IsStyle a) => O.MethodInfo StyleCopyMethodInfo a signature where + overloadedMethod _ = styleCopy + +#endif + + diff --git a/GI/GtkSource/Objects/Style.hs-boot b/GI/GtkSource/Objects/Style.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/Style.hs-boot @@ -0,0 +1,92 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.Style 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 Style = Style (ManagedPtr Style) +instance GObject Style where +class (GObject o, O.IsDescendantOf Style o) => IsStyle o +instance (GObject o, O.IsDescendantOf Style o) => IsStyle o +instance O.HasParentTypes Style +#if ENABLE_OVERLOADING +data StyleBackgroundPropertyInfo +#endif +#if ENABLE_OVERLOADING +data StyleBackgroundSetPropertyInfo +#endif +#if ENABLE_OVERLOADING +data StyleBoldPropertyInfo +#endif +#if ENABLE_OVERLOADING +data StyleBoldSetPropertyInfo +#endif +#if ENABLE_OVERLOADING +data StyleForegroundPropertyInfo +#endif +#if ENABLE_OVERLOADING +data StyleForegroundSetPropertyInfo +#endif +#if ENABLE_OVERLOADING +data StyleItalicPropertyInfo +#endif +#if ENABLE_OVERLOADING +data StyleItalicSetPropertyInfo +#endif +#if ENABLE_OVERLOADING +data StyleLineBackgroundPropertyInfo +#endif +#if ENABLE_OVERLOADING +data StyleLineBackgroundSetPropertyInfo +#endif +#if ENABLE_OVERLOADING +data StylePangoUnderlinePropertyInfo +#endif +#if ENABLE_OVERLOADING +data StyleScalePropertyInfo +#endif +#if ENABLE_OVERLOADING +data StyleScaleSetPropertyInfo +#endif +#if ENABLE_OVERLOADING +data StyleStrikethroughPropertyInfo +#endif +#if ENABLE_OVERLOADING +data StyleStrikethroughSetPropertyInfo +#endif +#if ENABLE_OVERLOADING +data StyleUnderlinePropertyInfo +#endif +#if ENABLE_OVERLOADING +data StyleUnderlineColorPropertyInfo +#endif +#if ENABLE_OVERLOADING +data StyleUnderlineColorSetPropertyInfo +#endif +#if ENABLE_OVERLOADING +data StyleUnderlineSetPropertyInfo +#endif +#if ENABLE_OVERLOADING +data StyleApplyMethodInfo +#endif +#if ENABLE_OVERLOADING +data StyleCopyMethodInfo +#endif diff --git a/GI/GtkSource/Objects/StyleScheme.hs b/GI/GtkSource/Objects/StyleScheme.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/StyleScheme.hs @@ -0,0 +1,616 @@ + + +{- | +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.StyleScheme + ( + +-- * Exported types + StyleScheme(..) , + IsStyleScheme , + toStyleScheme , + noStyleScheme , + + + -- * Methods +-- ** getAuthors #method:getAuthors# + +#if ENABLE_OVERLOADING + StyleSchemeGetAuthorsMethodInfo , +#endif + styleSchemeGetAuthors , + + +-- ** getDescription #method:getDescription# + +#if ENABLE_OVERLOADING + StyleSchemeGetDescriptionMethodInfo , +#endif + styleSchemeGetDescription , + + +-- ** getFilename #method:getFilename# + +#if ENABLE_OVERLOADING + StyleSchemeGetFilenameMethodInfo , +#endif + styleSchemeGetFilename , + + +-- ** getId #method:getId# + +#if ENABLE_OVERLOADING + StyleSchemeGetIdMethodInfo , +#endif + styleSchemeGetId , + + +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + StyleSchemeGetNameMethodInfo , +#endif + styleSchemeGetName , + + +-- ** getStyle #method:getStyle# + +#if ENABLE_OVERLOADING + StyleSchemeGetStyleMethodInfo , +#endif + styleSchemeGetStyle , + + + + + -- * Properties +-- ** description #attr:description# +{- | Style scheme description, a translatable string to present to the user. +-} +#if ENABLE_OVERLOADING + StyleSchemeDescriptionPropertyInfo , +#endif + getStyleSchemeDescription , +#if ENABLE_OVERLOADING + styleSchemeDescription , +#endif + + +-- ** filename #attr:filename# +{- | Style scheme filename or 'Nothing'. +-} +#if ENABLE_OVERLOADING + StyleSchemeFilenamePropertyInfo , +#endif + getStyleSchemeFilename , +#if ENABLE_OVERLOADING + styleSchemeFilename , +#endif + + +-- ** id #attr:id# +{- | Style scheme id, a unique string used to identify the style scheme +in 'GI.GtkSource.Objects.StyleSchemeManager.StyleSchemeManager'. +-} +#if ENABLE_OVERLOADING + StyleSchemeIdPropertyInfo , +#endif + constructStyleSchemeId , + getStyleSchemeId , +#if ENABLE_OVERLOADING + styleSchemeId , +#endif + + +-- ** name #attr:name# +{- | Style scheme name, a translatable string to present to the user. +-} +#if ENABLE_OVERLOADING + StyleSchemeNamePropertyInfo , +#endif + getStyleSchemeName , +#if ENABLE_OVERLOADING + styleSchemeName , +#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.Style as GtkSource.Style + +-- | Memory-managed wrapper type. +newtype StyleScheme = StyleScheme (ManagedPtr StyleScheme) +foreign import ccall "gtk_source_style_scheme_get_type" + c_gtk_source_style_scheme_get_type :: IO GType + +instance GObject StyleScheme where + gobjectType = c_gtk_source_style_scheme_get_type + + +-- | Type class for types which can be safely cast to `StyleScheme`, for instance with `toStyleScheme`. +class (GObject o, O.IsDescendantOf StyleScheme o) => IsStyleScheme o +instance (GObject o, O.IsDescendantOf StyleScheme o) => IsStyleScheme o + +instance O.HasParentTypes StyleScheme +type instance O.ParentTypes StyleScheme = '[GObject.Object.Object] + +-- | Cast to `StyleScheme`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toStyleScheme :: (MonadIO m, IsStyleScheme o) => o -> m StyleScheme +toStyleScheme = liftIO . unsafeCastTo StyleScheme + +-- | A convenience alias for `Nothing` :: `Maybe` `StyleScheme`. +noStyleScheme :: Maybe StyleScheme +noStyleScheme = Nothing + +#if ENABLE_OVERLOADING +type family ResolveStyleSchemeMethod (t :: Symbol) (o :: *) :: * where + ResolveStyleSchemeMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveStyleSchemeMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveStyleSchemeMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveStyleSchemeMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveStyleSchemeMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveStyleSchemeMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveStyleSchemeMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveStyleSchemeMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveStyleSchemeMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveStyleSchemeMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveStyleSchemeMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveStyleSchemeMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveStyleSchemeMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveStyleSchemeMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveStyleSchemeMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveStyleSchemeMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveStyleSchemeMethod "getAuthors" o = StyleSchemeGetAuthorsMethodInfo + ResolveStyleSchemeMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveStyleSchemeMethod "getDescription" o = StyleSchemeGetDescriptionMethodInfo + ResolveStyleSchemeMethod "getFilename" o = StyleSchemeGetFilenameMethodInfo + ResolveStyleSchemeMethod "getId" o = StyleSchemeGetIdMethodInfo + ResolveStyleSchemeMethod "getName" o = StyleSchemeGetNameMethodInfo + ResolveStyleSchemeMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveStyleSchemeMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveStyleSchemeMethod "getStyle" o = StyleSchemeGetStyleMethodInfo + ResolveStyleSchemeMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveStyleSchemeMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveStyleSchemeMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveStyleSchemeMethod t StyleScheme, O.MethodInfo info StyleScheme p) => OL.IsLabel t (StyleScheme -> 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 + +-- VVV Prop "description" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@description@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' styleScheme #description +@ +-} +getStyleSchemeDescription :: (MonadIO m, IsStyleScheme o) => o -> m (Maybe T.Text) +getStyleSchemeDescription obj = liftIO $ B.Properties.getObjectPropertyString obj "description" + +#if ENABLE_OVERLOADING +data StyleSchemeDescriptionPropertyInfo +instance AttrInfo StyleSchemeDescriptionPropertyInfo where + type AttrAllowedOps StyleSchemeDescriptionPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint StyleSchemeDescriptionPropertyInfo = (~) () + type AttrBaseTypeConstraint StyleSchemeDescriptionPropertyInfo = IsStyleScheme + type AttrGetType StyleSchemeDescriptionPropertyInfo = (Maybe T.Text) + type AttrLabel StyleSchemeDescriptionPropertyInfo = "description" + type AttrOrigin StyleSchemeDescriptionPropertyInfo = StyleScheme + attrGet _ = getStyleSchemeDescription + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "filename" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@filename@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' styleScheme #filename +@ +-} +getStyleSchemeFilename :: (MonadIO m, IsStyleScheme o) => o -> m (Maybe T.Text) +getStyleSchemeFilename obj = liftIO $ B.Properties.getObjectPropertyString obj "filename" + +#if ENABLE_OVERLOADING +data StyleSchemeFilenamePropertyInfo +instance AttrInfo StyleSchemeFilenamePropertyInfo where + type AttrAllowedOps StyleSchemeFilenamePropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint StyleSchemeFilenamePropertyInfo = (~) () + type AttrBaseTypeConstraint StyleSchemeFilenamePropertyInfo = IsStyleScheme + type AttrGetType StyleSchemeFilenamePropertyInfo = (Maybe T.Text) + type AttrLabel StyleSchemeFilenamePropertyInfo = "filename" + type AttrOrigin StyleSchemeFilenamePropertyInfo = StyleScheme + attrGet _ = getStyleSchemeFilename + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "id" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@id@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' styleScheme #id +@ +-} +getStyleSchemeId :: (MonadIO m, IsStyleScheme o) => o -> m T.Text +getStyleSchemeId obj = liftIO $ checkUnexpectedNothing "getStyleSchemeId" $ B.Properties.getObjectPropertyString obj "id" + +{- | +Construct a `GValueConstruct` with valid value for the “@id@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructStyleSchemeId :: (IsStyleScheme o) => T.Text -> IO (GValueConstruct o) +constructStyleSchemeId val = B.Properties.constructObjectPropertyString "id" (Just val) + +#if ENABLE_OVERLOADING +data StyleSchemeIdPropertyInfo +instance AttrInfo StyleSchemeIdPropertyInfo where + type AttrAllowedOps StyleSchemeIdPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint StyleSchemeIdPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint StyleSchemeIdPropertyInfo = IsStyleScheme + type AttrGetType StyleSchemeIdPropertyInfo = T.Text + type AttrLabel StyleSchemeIdPropertyInfo = "id" + type AttrOrigin StyleSchemeIdPropertyInfo = StyleScheme + attrGet _ = getStyleSchemeId + attrSet _ = undefined + attrConstruct _ = constructStyleSchemeId + attrClear _ = undefined +#endif + +-- VVV Prop "name" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@name@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' styleScheme #name +@ +-} +getStyleSchemeName :: (MonadIO m, IsStyleScheme o) => o -> m T.Text +getStyleSchemeName obj = liftIO $ checkUnexpectedNothing "getStyleSchemeName" $ B.Properties.getObjectPropertyString obj "name" + +#if ENABLE_OVERLOADING +data StyleSchemeNamePropertyInfo +instance AttrInfo StyleSchemeNamePropertyInfo where + type AttrAllowedOps StyleSchemeNamePropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint StyleSchemeNamePropertyInfo = (~) () + type AttrBaseTypeConstraint StyleSchemeNamePropertyInfo = IsStyleScheme + type AttrGetType StyleSchemeNamePropertyInfo = T.Text + type AttrLabel StyleSchemeNamePropertyInfo = "name" + type AttrOrigin StyleSchemeNamePropertyInfo = StyleScheme + attrGet _ = getStyleSchemeName + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList StyleScheme +type instance O.AttributeList StyleScheme = StyleSchemeAttributeList +type StyleSchemeAttributeList = ('[ '("description", StyleSchemeDescriptionPropertyInfo), '("filename", StyleSchemeFilenamePropertyInfo), '("id", StyleSchemeIdPropertyInfo), '("name", StyleSchemeNamePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +styleSchemeDescription :: AttrLabelProxy "description" +styleSchemeDescription = AttrLabelProxy + +styleSchemeFilename :: AttrLabelProxy "filename" +styleSchemeFilename = AttrLabelProxy + +styleSchemeId :: AttrLabelProxy "id" +styleSchemeId = AttrLabelProxy + +styleSchemeName :: AttrLabelProxy "name" +styleSchemeName = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList StyleScheme = StyleSchemeSignalList +type StyleSchemeSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method StyleScheme::get_authors +-- method type : OrdinaryMethod +-- Args : [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 : Just (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_style_scheme_get_authors" gtk_source_style_scheme_get_authors :: + Ptr StyleScheme -> -- scheme : TInterface (Name {namespace = "GtkSource", name = "StyleScheme"}) + IO (Ptr CString) + +{- | +/No description available in the introspection data./ + +/Since: 2.0/ +-} +styleSchemeGetAuthors :: + (B.CallStack.HasCallStack, MonadIO m, IsStyleScheme a) => + a + {- ^ /@scheme@/: a 'GI.GtkSource.Objects.StyleScheme.StyleScheme'. -} + -> m (Maybe [T.Text]) + {- ^ __Returns:__ a +'Nothing'-terminated array containing the /@scheme@/ authors or 'Nothing' if +no author is specified by the style scheme. -} +styleSchemeGetAuthors scheme = liftIO $ do + scheme' <- unsafeManagedPtrCastPtr scheme + result <- gtk_source_style_scheme_get_authors scheme' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- unpackZeroTerminatedUTF8CArray result' + return result'' + touchManagedPtr scheme + return maybeResult + +#if ENABLE_OVERLOADING +data StyleSchemeGetAuthorsMethodInfo +instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsStyleScheme a) => O.MethodInfo StyleSchemeGetAuthorsMethodInfo a signature where + overloadedMethod _ = styleSchemeGetAuthors + +#endif + +-- method StyleScheme::get_description +-- method type : OrdinaryMethod +-- Args : [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 : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_style_scheme_get_description" gtk_source_style_scheme_get_description :: + Ptr StyleScheme -> -- scheme : TInterface (Name {namespace = "GtkSource", name = "StyleScheme"}) + IO CString + +{- | +/No description available in the introspection data./ + +/Since: 2.0/ +-} +styleSchemeGetDescription :: + (B.CallStack.HasCallStack, MonadIO m, IsStyleScheme a) => + a + {- ^ /@scheme@/: a 'GI.GtkSource.Objects.StyleScheme.StyleScheme'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ /@scheme@/ description (if defined), or 'Nothing'. -} +styleSchemeGetDescription scheme = liftIO $ do + scheme' <- unsafeManagedPtrCastPtr scheme + result <- gtk_source_style_scheme_get_description scheme' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr scheme + return maybeResult + +#if ENABLE_OVERLOADING +data StyleSchemeGetDescriptionMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsStyleScheme a) => O.MethodInfo StyleSchemeGetDescriptionMethodInfo a signature where + overloadedMethod _ = styleSchemeGetDescription + +#endif + +-- method StyleScheme::get_filename +-- method type : OrdinaryMethod +-- Args : [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 : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_style_scheme_get_filename" gtk_source_style_scheme_get_filename :: + Ptr StyleScheme -> -- scheme : TInterface (Name {namespace = "GtkSource", name = "StyleScheme"}) + IO CString + +{- | +/No description available in the introspection data./ + +/Since: 2.0/ +-} +styleSchemeGetFilename :: + (B.CallStack.HasCallStack, MonadIO m, IsStyleScheme a) => + a + {- ^ /@scheme@/: a 'GI.GtkSource.Objects.StyleScheme.StyleScheme'. -} + -> m (Maybe T.Text) + {- ^ __Returns:__ /@scheme@/ file name if the scheme was created +parsing a style scheme file or 'Nothing' in the other cases. -} +styleSchemeGetFilename scheme = liftIO $ do + scheme' <- unsafeManagedPtrCastPtr scheme + result <- gtk_source_style_scheme_get_filename scheme' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr scheme + return maybeResult + +#if ENABLE_OVERLOADING +data StyleSchemeGetFilenameMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsStyleScheme a) => O.MethodInfo StyleSchemeGetFilenameMethodInfo a signature where + overloadedMethod _ = styleSchemeGetFilename + +#endif + +-- method StyleScheme::get_id +-- method type : OrdinaryMethod +-- Args : [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 : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_style_scheme_get_id" gtk_source_style_scheme_get_id :: + Ptr StyleScheme -> -- scheme : TInterface (Name {namespace = "GtkSource", name = "StyleScheme"}) + IO CString + +{- | +/No description available in the introspection data./ + +/Since: 2.0/ +-} +styleSchemeGetId :: + (B.CallStack.HasCallStack, MonadIO m, IsStyleScheme a) => + a + {- ^ /@scheme@/: a 'GI.GtkSource.Objects.StyleScheme.StyleScheme'. -} + -> m T.Text + {- ^ __Returns:__ /@scheme@/ id. -} +styleSchemeGetId scheme = liftIO $ do + scheme' <- unsafeManagedPtrCastPtr scheme + result <- gtk_source_style_scheme_get_id scheme' + checkUnexpectedReturnNULL "styleSchemeGetId" result + result' <- cstringToText result + touchManagedPtr scheme + return result' + +#if ENABLE_OVERLOADING +data StyleSchemeGetIdMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsStyleScheme a) => O.MethodInfo StyleSchemeGetIdMethodInfo a signature where + overloadedMethod _ = styleSchemeGetId + +#endif + +-- method StyleScheme::get_name +-- method type : OrdinaryMethod +-- Args : [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 : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_style_scheme_get_name" gtk_source_style_scheme_get_name :: + Ptr StyleScheme -> -- scheme : TInterface (Name {namespace = "GtkSource", name = "StyleScheme"}) + IO CString + +{- | +/No description available in the introspection data./ + +/Since: 2.0/ +-} +styleSchemeGetName :: + (B.CallStack.HasCallStack, MonadIO m, IsStyleScheme a) => + a + {- ^ /@scheme@/: a 'GI.GtkSource.Objects.StyleScheme.StyleScheme'. -} + -> m T.Text + {- ^ __Returns:__ /@scheme@/ name. -} +styleSchemeGetName scheme = liftIO $ do + scheme' <- unsafeManagedPtrCastPtr scheme + result <- gtk_source_style_scheme_get_name scheme' + checkUnexpectedReturnNULL "styleSchemeGetName" result + result' <- cstringToText result + touchManagedPtr scheme + return result' + +#if ENABLE_OVERLOADING +data StyleSchemeGetNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsStyleScheme a) => O.MethodInfo StyleSchemeGetNameMethodInfo a signature where + overloadedMethod _ = styleSchemeGetName + +#endif + +-- method StyleScheme::get_style +-- method type : OrdinaryMethod +-- Args : [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},Arg {argCName = "style_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "id of the style to retrieve.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Style"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_style_scheme_get_style" gtk_source_style_scheme_get_style :: + Ptr StyleScheme -> -- scheme : TInterface (Name {namespace = "GtkSource", name = "StyleScheme"}) + CString -> -- style_id : TBasicType TUTF8 + IO (Ptr GtkSource.Style.Style) + +{- | +/No description available in the introspection data./ + +/Since: 2.0/ +-} +styleSchemeGetStyle :: + (B.CallStack.HasCallStack, MonadIO m, IsStyleScheme a) => + a + {- ^ /@scheme@/: a 'GI.GtkSource.Objects.StyleScheme.StyleScheme'. -} + -> T.Text + {- ^ /@styleId@/: id of the style to retrieve. -} + -> m (Maybe GtkSource.Style.Style) + {- ^ __Returns:__ style which corresponds to /@styleId@/ in +the /@scheme@/, or 'Nothing' when no style with this name found. It is owned by +/@scheme@/ and may not be unref\'ed. -} +styleSchemeGetStyle scheme styleId = liftIO $ do + scheme' <- unsafeManagedPtrCastPtr scheme + styleId' <- textToCString styleId + result <- gtk_source_style_scheme_get_style scheme' styleId' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject GtkSource.Style.Style) result' + return result'' + touchManagedPtr scheme + freeMem styleId' + return maybeResult + +#if ENABLE_OVERLOADING +data StyleSchemeGetStyleMethodInfo +instance (signature ~ (T.Text -> m (Maybe GtkSource.Style.Style)), MonadIO m, IsStyleScheme a) => O.MethodInfo StyleSchemeGetStyleMethodInfo a signature where + overloadedMethod _ = styleSchemeGetStyle + +#endif + + diff --git a/GI/GtkSource/Objects/StyleScheme.hs-boot b/GI/GtkSource/Objects/StyleScheme.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/StyleScheme.hs-boot @@ -0,0 +1,59 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.StyleScheme 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 StyleScheme = StyleScheme (ManagedPtr StyleScheme) +instance GObject StyleScheme where +class (GObject o, O.IsDescendantOf StyleScheme o) => IsStyleScheme o +instance (GObject o, O.IsDescendantOf StyleScheme o) => IsStyleScheme o +instance O.HasParentTypes StyleScheme +#if ENABLE_OVERLOADING +data StyleSchemeDescriptionPropertyInfo +#endif +#if ENABLE_OVERLOADING +data StyleSchemeFilenamePropertyInfo +#endif +#if ENABLE_OVERLOADING +data StyleSchemeIdPropertyInfo +#endif +#if ENABLE_OVERLOADING +data StyleSchemeNamePropertyInfo +#endif +#if ENABLE_OVERLOADING +data StyleSchemeGetAuthorsMethodInfo +#endif +#if ENABLE_OVERLOADING +data StyleSchemeGetDescriptionMethodInfo +#endif +#if ENABLE_OVERLOADING +data StyleSchemeGetFilenameMethodInfo +#endif +#if ENABLE_OVERLOADING +data StyleSchemeGetIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data StyleSchemeGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data StyleSchemeGetStyleMethodInfo +#endif diff --git a/GI/GtkSource/Objects/StyleSchemeChooserButton.hs b/GI/GtkSource/Objects/StyleSchemeChooserButton.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/StyleSchemeChooserButton.hs @@ -0,0 +1,499 @@ + + +{- | +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.StyleSchemeChooserButton + ( + +-- * Exported types + StyleSchemeChooserButton(..) , + IsStyleSchemeChooserButton , + toStyleSchemeChooserButton , + noStyleSchemeChooserButton , + + + -- * Methods +-- ** new #method:new# + + styleSchemeChooserButtonNew , + + + + + ) 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.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gtk.Interfaces.Actionable as Gtk.Actionable +import qualified GI.Gtk.Interfaces.Activatable as Gtk.Activatable +import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable +import qualified GI.Gtk.Objects.Bin as Gtk.Bin +import qualified GI.Gtk.Objects.Button as Gtk.Button +import qualified GI.Gtk.Objects.Container as Gtk.Container +import qualified GI.Gtk.Objects.Widget as Gtk.Widget +import {-# SOURCE #-} qualified GI.GtkSource.Interfaces.StyleSchemeChooser as GtkSource.StyleSchemeChooser + +-- | Memory-managed wrapper type. +newtype StyleSchemeChooserButton = StyleSchemeChooserButton (ManagedPtr StyleSchemeChooserButton) +foreign import ccall "gtk_source_style_scheme_chooser_button_get_type" + c_gtk_source_style_scheme_chooser_button_get_type :: IO GType + +instance GObject StyleSchemeChooserButton where + gobjectType = c_gtk_source_style_scheme_chooser_button_get_type + + +-- | Type class for types which can be safely cast to `StyleSchemeChooserButton`, for instance with `toStyleSchemeChooserButton`. +class (GObject o, O.IsDescendantOf StyleSchemeChooserButton o) => IsStyleSchemeChooserButton o +instance (GObject o, O.IsDescendantOf StyleSchemeChooserButton o) => IsStyleSchemeChooserButton o + +instance O.HasParentTypes StyleSchemeChooserButton +type instance O.ParentTypes StyleSchemeChooserButton = '[Gtk.Button.Button, Gtk.Bin.Bin, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Actionable.Actionable, Gtk.Activatable.Activatable, Gtk.Buildable.Buildable, GtkSource.StyleSchemeChooser.StyleSchemeChooser] + +-- | Cast to `StyleSchemeChooserButton`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toStyleSchemeChooserButton :: (MonadIO m, IsStyleSchemeChooserButton o) => o -> m StyleSchemeChooserButton +toStyleSchemeChooserButton = liftIO . unsafeCastTo StyleSchemeChooserButton + +-- | A convenience alias for `Nothing` :: `Maybe` `StyleSchemeChooserButton`. +noStyleSchemeChooserButton :: Maybe StyleSchemeChooserButton +noStyleSchemeChooserButton = Nothing + +#if ENABLE_OVERLOADING +type family ResolveStyleSchemeChooserButtonMethod (t :: Symbol) (o :: *) :: * where + ResolveStyleSchemeChooserButtonMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo + ResolveStyleSchemeChooserButtonMethod "add" o = Gtk.Container.ContainerAddMethodInfo + ResolveStyleSchemeChooserButtonMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo + ResolveStyleSchemeChooserButtonMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo + ResolveStyleSchemeChooserButtonMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo + ResolveStyleSchemeChooserButtonMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo + ResolveStyleSchemeChooserButtonMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo + ResolveStyleSchemeChooserButtonMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo + ResolveStyleSchemeChooserButtonMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveStyleSchemeChooserButtonMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveStyleSchemeChooserButtonMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo + ResolveStyleSchemeChooserButtonMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo + ResolveStyleSchemeChooserButtonMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo + ResolveStyleSchemeChooserButtonMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo + ResolveStyleSchemeChooserButtonMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo + ResolveStyleSchemeChooserButtonMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo + ResolveStyleSchemeChooserButtonMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo + ResolveStyleSchemeChooserButtonMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo + ResolveStyleSchemeChooserButtonMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo + ResolveStyleSchemeChooserButtonMethod "clicked" o = Gtk.Button.ButtonClickedMethodInfo + ResolveStyleSchemeChooserButtonMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo + ResolveStyleSchemeChooserButtonMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo + ResolveStyleSchemeChooserButtonMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo + ResolveStyleSchemeChooserButtonMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo + ResolveStyleSchemeChooserButtonMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo + ResolveStyleSchemeChooserButtonMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo + ResolveStyleSchemeChooserButtonMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo + ResolveStyleSchemeChooserButtonMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo + ResolveStyleSchemeChooserButtonMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo + ResolveStyleSchemeChooserButtonMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo + ResolveStyleSchemeChooserButtonMethod "doSetRelatedAction" o = Gtk.Activatable.ActivatableDoSetRelatedActionMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo + ResolveStyleSchemeChooserButtonMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo + ResolveStyleSchemeChooserButtonMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo + ResolveStyleSchemeChooserButtonMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo + ResolveStyleSchemeChooserButtonMethod "enter" o = Gtk.Button.ButtonEnterMethodInfo + ResolveStyleSchemeChooserButtonMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo + ResolveStyleSchemeChooserButtonMethod "event" o = Gtk.Widget.WidgetEventMethodInfo + ResolveStyleSchemeChooserButtonMethod "forall" o = Gtk.Container.ContainerForallMethodInfo + ResolveStyleSchemeChooserButtonMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveStyleSchemeChooserButtonMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo + ResolveStyleSchemeChooserButtonMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo + ResolveStyleSchemeChooserButtonMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveStyleSchemeChooserButtonMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveStyleSchemeChooserButtonMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo + ResolveStyleSchemeChooserButtonMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo + ResolveStyleSchemeChooserButtonMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo + ResolveStyleSchemeChooserButtonMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo + ResolveStyleSchemeChooserButtonMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo + ResolveStyleSchemeChooserButtonMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo + ResolveStyleSchemeChooserButtonMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo + ResolveStyleSchemeChooserButtonMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo + ResolveStyleSchemeChooserButtonMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo + ResolveStyleSchemeChooserButtonMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo + ResolveStyleSchemeChooserButtonMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo + ResolveStyleSchemeChooserButtonMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo + ResolveStyleSchemeChooserButtonMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo + ResolveStyleSchemeChooserButtonMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo + ResolveStyleSchemeChooserButtonMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo + ResolveStyleSchemeChooserButtonMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo + ResolveStyleSchemeChooserButtonMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo + ResolveStyleSchemeChooserButtonMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo + ResolveStyleSchemeChooserButtonMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo + ResolveStyleSchemeChooserButtonMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo + ResolveStyleSchemeChooserButtonMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveStyleSchemeChooserButtonMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo + ResolveStyleSchemeChooserButtonMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo + ResolveStyleSchemeChooserButtonMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo + ResolveStyleSchemeChooserButtonMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo + ResolveStyleSchemeChooserButtonMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo + ResolveStyleSchemeChooserButtonMethod "leave" o = Gtk.Button.ButtonLeaveMethodInfo + ResolveStyleSchemeChooserButtonMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo + ResolveStyleSchemeChooserButtonMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo + ResolveStyleSchemeChooserButtonMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo + ResolveStyleSchemeChooserButtonMethod "map" o = Gtk.Widget.WidgetMapMethodInfo + ResolveStyleSchemeChooserButtonMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo + ResolveStyleSchemeChooserButtonMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo + ResolveStyleSchemeChooserButtonMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo + ResolveStyleSchemeChooserButtonMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo + ResolveStyleSchemeChooserButtonMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo + ResolveStyleSchemeChooserButtonMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo + ResolveStyleSchemeChooserButtonMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo + ResolveStyleSchemeChooserButtonMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo + ResolveStyleSchemeChooserButtonMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveStyleSchemeChooserButtonMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveStyleSchemeChooserButtonMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo + ResolveStyleSchemeChooserButtonMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo + ResolveStyleSchemeChooserButtonMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo + ResolveStyleSchemeChooserButtonMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo + ResolveStyleSchemeChooserButtonMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo + ResolveStyleSchemeChooserButtonMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo + ResolveStyleSchemeChooserButtonMethod "path" o = Gtk.Widget.WidgetPathMethodInfo + ResolveStyleSchemeChooserButtonMethod "pressed" o = Gtk.Button.ButtonPressedMethodInfo + ResolveStyleSchemeChooserButtonMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo + ResolveStyleSchemeChooserButtonMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo + ResolveStyleSchemeChooserButtonMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo + ResolveStyleSchemeChooserButtonMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo + ResolveStyleSchemeChooserButtonMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo + ResolveStyleSchemeChooserButtonMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo + ResolveStyleSchemeChooserButtonMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo + ResolveStyleSchemeChooserButtonMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo + ResolveStyleSchemeChooserButtonMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo + ResolveStyleSchemeChooserButtonMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveStyleSchemeChooserButtonMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveStyleSchemeChooserButtonMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo + ResolveStyleSchemeChooserButtonMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo + ResolveStyleSchemeChooserButtonMethod "released" o = Gtk.Button.ButtonReleasedMethodInfo + ResolveStyleSchemeChooserButtonMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo + ResolveStyleSchemeChooserButtonMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo + ResolveStyleSchemeChooserButtonMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo + ResolveStyleSchemeChooserButtonMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo + ResolveStyleSchemeChooserButtonMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo + ResolveStyleSchemeChooserButtonMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo + ResolveStyleSchemeChooserButtonMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo + ResolveStyleSchemeChooserButtonMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo + ResolveStyleSchemeChooserButtonMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo + ResolveStyleSchemeChooserButtonMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo + ResolveStyleSchemeChooserButtonMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveStyleSchemeChooserButtonMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo + ResolveStyleSchemeChooserButtonMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo + ResolveStyleSchemeChooserButtonMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo + ResolveStyleSchemeChooserButtonMethod "show" o = Gtk.Widget.WidgetShowMethodInfo + ResolveStyleSchemeChooserButtonMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo + ResolveStyleSchemeChooserButtonMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo + ResolveStyleSchemeChooserButtonMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo + ResolveStyleSchemeChooserButtonMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo + ResolveStyleSchemeChooserButtonMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo + ResolveStyleSchemeChooserButtonMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveStyleSchemeChooserButtonMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveStyleSchemeChooserButtonMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo + ResolveStyleSchemeChooserButtonMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo + ResolveStyleSchemeChooserButtonMethod "syncActionProperties" o = Gtk.Activatable.ActivatableSyncActionPropertiesMethodInfo + ResolveStyleSchemeChooserButtonMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo + ResolveStyleSchemeChooserButtonMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveStyleSchemeChooserButtonMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo + ResolveStyleSchemeChooserButtonMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo + ResolveStyleSchemeChooserButtonMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo + ResolveStyleSchemeChooserButtonMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo + ResolveStyleSchemeChooserButtonMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo + ResolveStyleSchemeChooserButtonMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveStyleSchemeChooserButtonMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo + ResolveStyleSchemeChooserButtonMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo + ResolveStyleSchemeChooserButtonMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo + ResolveStyleSchemeChooserButtonMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveStyleSchemeChooserButtonMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo + ResolveStyleSchemeChooserButtonMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo + ResolveStyleSchemeChooserButtonMethod "getActionName" o = Gtk.Actionable.ActionableGetActionNameMethodInfo + ResolveStyleSchemeChooserButtonMethod "getActionTargetValue" o = Gtk.Actionable.ActionableGetActionTargetValueMethodInfo + ResolveStyleSchemeChooserButtonMethod "getAlignment" o = Gtk.Button.ButtonGetAlignmentMethodInfo + ResolveStyleSchemeChooserButtonMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo + ResolveStyleSchemeChooserButtonMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo + ResolveStyleSchemeChooserButtonMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo + ResolveStyleSchemeChooserButtonMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo + ResolveStyleSchemeChooserButtonMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo + ResolveStyleSchemeChooserButtonMethod "getAlwaysShowImage" o = Gtk.Button.ButtonGetAlwaysShowImageMethodInfo + ResolveStyleSchemeChooserButtonMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo + ResolveStyleSchemeChooserButtonMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo + ResolveStyleSchemeChooserButtonMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo + ResolveStyleSchemeChooserButtonMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo + ResolveStyleSchemeChooserButtonMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo + ResolveStyleSchemeChooserButtonMethod "getChild" o = Gtk.Bin.BinGetChildMethodInfo + ResolveStyleSchemeChooserButtonMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo + ResolveStyleSchemeChooserButtonMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo + ResolveStyleSchemeChooserButtonMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo + ResolveStyleSchemeChooserButtonMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo + ResolveStyleSchemeChooserButtonMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo + ResolveStyleSchemeChooserButtonMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo + ResolveStyleSchemeChooserButtonMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveStyleSchemeChooserButtonMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo + ResolveStyleSchemeChooserButtonMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo + ResolveStyleSchemeChooserButtonMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo + ResolveStyleSchemeChooserButtonMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo + ResolveStyleSchemeChooserButtonMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo + ResolveStyleSchemeChooserButtonMethod "getEventWindow" o = Gtk.Button.ButtonGetEventWindowMethodInfo + ResolveStyleSchemeChooserButtonMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo + ResolveStyleSchemeChooserButtonMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo + ResolveStyleSchemeChooserButtonMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo + ResolveStyleSchemeChooserButtonMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo + ResolveStyleSchemeChooserButtonMethod "getFocusOnClick" o = Gtk.Button.ButtonGetFocusOnClickMethodInfo + ResolveStyleSchemeChooserButtonMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo + ResolveStyleSchemeChooserButtonMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo + ResolveStyleSchemeChooserButtonMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo + ResolveStyleSchemeChooserButtonMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo + ResolveStyleSchemeChooserButtonMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo + ResolveStyleSchemeChooserButtonMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo + ResolveStyleSchemeChooserButtonMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo + ResolveStyleSchemeChooserButtonMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo + ResolveStyleSchemeChooserButtonMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo + ResolveStyleSchemeChooserButtonMethod "getImage" o = Gtk.Button.ButtonGetImageMethodInfo + ResolveStyleSchemeChooserButtonMethod "getImagePosition" o = Gtk.Button.ButtonGetImagePositionMethodInfo + ResolveStyleSchemeChooserButtonMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo + ResolveStyleSchemeChooserButtonMethod "getLabel" o = Gtk.Button.ButtonGetLabelMethodInfo + ResolveStyleSchemeChooserButtonMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo + ResolveStyleSchemeChooserButtonMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo + ResolveStyleSchemeChooserButtonMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo + ResolveStyleSchemeChooserButtonMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo + ResolveStyleSchemeChooserButtonMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo + ResolveStyleSchemeChooserButtonMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo + ResolveStyleSchemeChooserButtonMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo + ResolveStyleSchemeChooserButtonMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo + ResolveStyleSchemeChooserButtonMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo + ResolveStyleSchemeChooserButtonMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo + ResolveStyleSchemeChooserButtonMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo + ResolveStyleSchemeChooserButtonMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo + ResolveStyleSchemeChooserButtonMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo + ResolveStyleSchemeChooserButtonMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo + ResolveStyleSchemeChooserButtonMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo + ResolveStyleSchemeChooserButtonMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo + ResolveStyleSchemeChooserButtonMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo + ResolveStyleSchemeChooserButtonMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo + ResolveStyleSchemeChooserButtonMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo + ResolveStyleSchemeChooserButtonMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo + ResolveStyleSchemeChooserButtonMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo + ResolveStyleSchemeChooserButtonMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo + ResolveStyleSchemeChooserButtonMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo + ResolveStyleSchemeChooserButtonMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo + ResolveStyleSchemeChooserButtonMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveStyleSchemeChooserButtonMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveStyleSchemeChooserButtonMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo + ResolveStyleSchemeChooserButtonMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo + ResolveStyleSchemeChooserButtonMethod "getRelatedAction" o = Gtk.Activatable.ActivatableGetRelatedActionMethodInfo + ResolveStyleSchemeChooserButtonMethod "getRelief" o = Gtk.Button.ButtonGetReliefMethodInfo + ResolveStyleSchemeChooserButtonMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo + ResolveStyleSchemeChooserButtonMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo + ResolveStyleSchemeChooserButtonMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo + ResolveStyleSchemeChooserButtonMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo + ResolveStyleSchemeChooserButtonMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo + ResolveStyleSchemeChooserButtonMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo + ResolveStyleSchemeChooserButtonMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo + ResolveStyleSchemeChooserButtonMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo + ResolveStyleSchemeChooserButtonMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo + ResolveStyleSchemeChooserButtonMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo + ResolveStyleSchemeChooserButtonMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo + ResolveStyleSchemeChooserButtonMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo + ResolveStyleSchemeChooserButtonMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo + ResolveStyleSchemeChooserButtonMethod "getStyleScheme" o = GtkSource.StyleSchemeChooser.StyleSchemeChooserGetStyleSchemeMethodInfo + ResolveStyleSchemeChooserButtonMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo + ResolveStyleSchemeChooserButtonMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo + ResolveStyleSchemeChooserButtonMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo + ResolveStyleSchemeChooserButtonMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo + ResolveStyleSchemeChooserButtonMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo + ResolveStyleSchemeChooserButtonMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo + ResolveStyleSchemeChooserButtonMethod "getUseActionAppearance" o = Gtk.Activatable.ActivatableGetUseActionAppearanceMethodInfo + ResolveStyleSchemeChooserButtonMethod "getUseStock" o = Gtk.Button.ButtonGetUseStockMethodInfo + ResolveStyleSchemeChooserButtonMethod "getUseUnderline" o = Gtk.Button.ButtonGetUseUnderlineMethodInfo + ResolveStyleSchemeChooserButtonMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo + ResolveStyleSchemeChooserButtonMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo + ResolveStyleSchemeChooserButtonMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo + ResolveStyleSchemeChooserButtonMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo + ResolveStyleSchemeChooserButtonMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo + ResolveStyleSchemeChooserButtonMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo + ResolveStyleSchemeChooserButtonMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo + ResolveStyleSchemeChooserButtonMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo + ResolveStyleSchemeChooserButtonMethod "setActionName" o = Gtk.Actionable.ActionableSetActionNameMethodInfo + ResolveStyleSchemeChooserButtonMethod "setActionTargetValue" o = Gtk.Actionable.ActionableSetActionTargetValueMethodInfo + ResolveStyleSchemeChooserButtonMethod "setAlignment" o = Gtk.Button.ButtonSetAlignmentMethodInfo + ResolveStyleSchemeChooserButtonMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo + ResolveStyleSchemeChooserButtonMethod "setAlwaysShowImage" o = Gtk.Button.ButtonSetAlwaysShowImageMethodInfo + ResolveStyleSchemeChooserButtonMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo + ResolveStyleSchemeChooserButtonMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo + ResolveStyleSchemeChooserButtonMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo + ResolveStyleSchemeChooserButtonMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo + ResolveStyleSchemeChooserButtonMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo + ResolveStyleSchemeChooserButtonMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo + ResolveStyleSchemeChooserButtonMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo + ResolveStyleSchemeChooserButtonMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo + ResolveStyleSchemeChooserButtonMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveStyleSchemeChooserButtonMethod "setDetailedActionName" o = Gtk.Actionable.ActionableSetDetailedActionNameMethodInfo + ResolveStyleSchemeChooserButtonMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo + ResolveStyleSchemeChooserButtonMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo + ResolveStyleSchemeChooserButtonMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo + ResolveStyleSchemeChooserButtonMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo + ResolveStyleSchemeChooserButtonMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo + ResolveStyleSchemeChooserButtonMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo + ResolveStyleSchemeChooserButtonMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo + ResolveStyleSchemeChooserButtonMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo + ResolveStyleSchemeChooserButtonMethod "setFocusOnClick" o = Gtk.Button.ButtonSetFocusOnClickMethodInfo + ResolveStyleSchemeChooserButtonMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo + ResolveStyleSchemeChooserButtonMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo + ResolveStyleSchemeChooserButtonMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo + ResolveStyleSchemeChooserButtonMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo + ResolveStyleSchemeChooserButtonMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo + ResolveStyleSchemeChooserButtonMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo + ResolveStyleSchemeChooserButtonMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo + ResolveStyleSchemeChooserButtonMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo + ResolveStyleSchemeChooserButtonMethod "setImage" o = Gtk.Button.ButtonSetImageMethodInfo + ResolveStyleSchemeChooserButtonMethod "setImagePosition" o = Gtk.Button.ButtonSetImagePositionMethodInfo + ResolveStyleSchemeChooserButtonMethod "setLabel" o = Gtk.Button.ButtonSetLabelMethodInfo + ResolveStyleSchemeChooserButtonMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo + ResolveStyleSchemeChooserButtonMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo + ResolveStyleSchemeChooserButtonMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo + ResolveStyleSchemeChooserButtonMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo + ResolveStyleSchemeChooserButtonMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo + ResolveStyleSchemeChooserButtonMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo + ResolveStyleSchemeChooserButtonMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo + ResolveStyleSchemeChooserButtonMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo + ResolveStyleSchemeChooserButtonMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo + ResolveStyleSchemeChooserButtonMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo + ResolveStyleSchemeChooserButtonMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo + ResolveStyleSchemeChooserButtonMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo + ResolveStyleSchemeChooserButtonMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveStyleSchemeChooserButtonMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo + ResolveStyleSchemeChooserButtonMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo + ResolveStyleSchemeChooserButtonMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo + ResolveStyleSchemeChooserButtonMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo + ResolveStyleSchemeChooserButtonMethod "setRelatedAction" o = Gtk.Activatable.ActivatableSetRelatedActionMethodInfo + ResolveStyleSchemeChooserButtonMethod "setRelief" o = Gtk.Button.ButtonSetReliefMethodInfo + ResolveStyleSchemeChooserButtonMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo + ResolveStyleSchemeChooserButtonMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo + ResolveStyleSchemeChooserButtonMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo + ResolveStyleSchemeChooserButtonMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo + ResolveStyleSchemeChooserButtonMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo + ResolveStyleSchemeChooserButtonMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo + ResolveStyleSchemeChooserButtonMethod "setStyleScheme" o = GtkSource.StyleSchemeChooser.StyleSchemeChooserSetStyleSchemeMethodInfo + ResolveStyleSchemeChooserButtonMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo + ResolveStyleSchemeChooserButtonMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo + ResolveStyleSchemeChooserButtonMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo + ResolveStyleSchemeChooserButtonMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo + ResolveStyleSchemeChooserButtonMethod "setUseActionAppearance" o = Gtk.Activatable.ActivatableSetUseActionAppearanceMethodInfo + ResolveStyleSchemeChooserButtonMethod "setUseStock" o = Gtk.Button.ButtonSetUseStockMethodInfo + ResolveStyleSchemeChooserButtonMethod "setUseUnderline" o = Gtk.Button.ButtonSetUseUnderlineMethodInfo + ResolveStyleSchemeChooserButtonMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo + ResolveStyleSchemeChooserButtonMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo + ResolveStyleSchemeChooserButtonMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo + ResolveStyleSchemeChooserButtonMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo + ResolveStyleSchemeChooserButtonMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo + ResolveStyleSchemeChooserButtonMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo + ResolveStyleSchemeChooserButtonMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveStyleSchemeChooserButtonMethod t StyleSchemeChooserButton, O.MethodInfo info StyleSchemeChooserButton p) => OL.IsLabel t (StyleSchemeChooserButton -> 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 + +#if ENABLE_OVERLOADING +instance O.HasAttributeList StyleSchemeChooserButton +type instance O.AttributeList StyleSchemeChooserButton = StyleSchemeChooserButtonAttributeList +type StyleSchemeChooserButtonAttributeList = ('[ '("actionName", Gtk.Actionable.ActionableActionNamePropertyInfo), '("actionTarget", Gtk.Actionable.ActionableActionTargetPropertyInfo), '("alwaysShowImage", Gtk.Button.ButtonAlwaysShowImagePropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("image", Gtk.Button.ButtonImagePropertyInfo), '("imagePosition", Gtk.Button.ButtonImagePositionPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("label", Gtk.Button.ButtonLabelPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("relatedAction", Gtk.Activatable.ActivatableRelatedActionPropertyInfo), '("relief", Gtk.Button.ButtonReliefPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("styleScheme", GtkSource.StyleSchemeChooser.StyleSchemeChooserStyleSchemePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("useActionAppearance", Gtk.Activatable.ActivatableUseActionAppearancePropertyInfo), '("useStock", Gtk.Button.ButtonUseStockPropertyInfo), '("useUnderline", Gtk.Button.ButtonUseUnderlinePropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo), '("xalign", Gtk.Button.ButtonXalignPropertyInfo), '("yalign", Gtk.Button.ButtonYalignPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList StyleSchemeChooserButton = StyleSchemeChooserButtonSignalList +type StyleSchemeChooserButtonSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("activate", Gtk.Button.ButtonActivateSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("clicked", Gtk.Button.ButtonClickedSignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("enter", Gtk.Button.ButtonEnterSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leave", Gtk.Button.ButtonLeaveSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("pressed", Gtk.Button.ButtonPressedSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("released", Gtk.Button.ButtonReleasedSignalInfo), '("remove", Gtk.Container.ContainerRemoveSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("setFocusChild", Gtk.Container.ContainerSetFocusChildSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method StyleSchemeChooserButton::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "StyleSchemeChooserButton"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_style_scheme_chooser_button_new" gtk_source_style_scheme_chooser_button_new :: + IO (Ptr StyleSchemeChooserButton) + +{- | +Creates a new 'GI.GtkSource.Objects.StyleSchemeChooserButton.StyleSchemeChooserButton'. + +/Since: 3.16/ +-} +styleSchemeChooserButtonNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m StyleSchemeChooserButton + {- ^ __Returns:__ a new 'GI.GtkSource.Objects.StyleSchemeChooserButton.StyleSchemeChooserButton'. -} +styleSchemeChooserButtonNew = liftIO $ do + result <- gtk_source_style_scheme_chooser_button_new + checkUnexpectedReturnNULL "styleSchemeChooserButtonNew" result + result' <- (newObject StyleSchemeChooserButton) result + return result' + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/GtkSource/Objects/StyleSchemeChooserButton.hs-boot b/GI/GtkSource/Objects/StyleSchemeChooserButton.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/StyleSchemeChooserButton.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.StyleSchemeChooserButton 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 StyleSchemeChooserButton = StyleSchemeChooserButton (ManagedPtr StyleSchemeChooserButton) +instance GObject StyleSchemeChooserButton where +class (GObject o, O.IsDescendantOf StyleSchemeChooserButton o) => IsStyleSchemeChooserButton o +instance (GObject o, O.IsDescendantOf StyleSchemeChooserButton o) => IsStyleSchemeChooserButton o +instance O.HasParentTypes StyleSchemeChooserButton diff --git a/GI/GtkSource/Objects/StyleSchemeChooserWidget.hs b/GI/GtkSource/Objects/StyleSchemeChooserWidget.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/StyleSchemeChooserWidget.hs @@ -0,0 +1,463 @@ + + +{- | +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.StyleSchemeChooserWidget + ( + +-- * Exported types + StyleSchemeChooserWidget(..) , + IsStyleSchemeChooserWidget , + toStyleSchemeChooserWidget , + noStyleSchemeChooserWidget , + + + -- * Methods +-- ** new #method:new# + + styleSchemeChooserWidgetNew , + + + + + ) 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.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable +import qualified GI.Gtk.Objects.Bin as Gtk.Bin +import qualified GI.Gtk.Objects.Container as Gtk.Container +import qualified GI.Gtk.Objects.Widget as Gtk.Widget +import {-# SOURCE #-} qualified GI.GtkSource.Interfaces.StyleSchemeChooser as GtkSource.StyleSchemeChooser + +-- | Memory-managed wrapper type. +newtype StyleSchemeChooserWidget = StyleSchemeChooserWidget (ManagedPtr StyleSchemeChooserWidget) +foreign import ccall "gtk_source_style_scheme_chooser_widget_get_type" + c_gtk_source_style_scheme_chooser_widget_get_type :: IO GType + +instance GObject StyleSchemeChooserWidget where + gobjectType = c_gtk_source_style_scheme_chooser_widget_get_type + + +-- | Type class for types which can be safely cast to `StyleSchemeChooserWidget`, for instance with `toStyleSchemeChooserWidget`. +class (GObject o, O.IsDescendantOf StyleSchemeChooserWidget o) => IsStyleSchemeChooserWidget o +instance (GObject o, O.IsDescendantOf StyleSchemeChooserWidget o) => IsStyleSchemeChooserWidget o + +instance O.HasParentTypes StyleSchemeChooserWidget +type instance O.ParentTypes StyleSchemeChooserWidget = '[Gtk.Bin.Bin, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable, GtkSource.StyleSchemeChooser.StyleSchemeChooser] + +-- | Cast to `StyleSchemeChooserWidget`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toStyleSchemeChooserWidget :: (MonadIO m, IsStyleSchemeChooserWidget o) => o -> m StyleSchemeChooserWidget +toStyleSchemeChooserWidget = liftIO . unsafeCastTo StyleSchemeChooserWidget + +-- | A convenience alias for `Nothing` :: `Maybe` `StyleSchemeChooserWidget`. +noStyleSchemeChooserWidget :: Maybe StyleSchemeChooserWidget +noStyleSchemeChooserWidget = Nothing + +#if ENABLE_OVERLOADING +type family ResolveStyleSchemeChooserWidgetMethod (t :: Symbol) (o :: *) :: * where + ResolveStyleSchemeChooserWidgetMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo + ResolveStyleSchemeChooserWidgetMethod "add" o = Gtk.Container.ContainerAddMethodInfo + ResolveStyleSchemeChooserWidgetMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo + ResolveStyleSchemeChooserWidgetMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo + ResolveStyleSchemeChooserWidgetMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo + ResolveStyleSchemeChooserWidgetMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo + ResolveStyleSchemeChooserWidgetMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo + ResolveStyleSchemeChooserWidgetMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo + ResolveStyleSchemeChooserWidgetMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveStyleSchemeChooserWidgetMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveStyleSchemeChooserWidgetMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo + ResolveStyleSchemeChooserWidgetMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo + ResolveStyleSchemeChooserWidgetMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo + ResolveStyleSchemeChooserWidgetMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo + ResolveStyleSchemeChooserWidgetMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo + ResolveStyleSchemeChooserWidgetMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo + ResolveStyleSchemeChooserWidgetMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo + ResolveStyleSchemeChooserWidgetMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo + ResolveStyleSchemeChooserWidgetMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo + ResolveStyleSchemeChooserWidgetMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo + ResolveStyleSchemeChooserWidgetMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo + ResolveStyleSchemeChooserWidgetMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo + ResolveStyleSchemeChooserWidgetMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo + ResolveStyleSchemeChooserWidgetMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo + ResolveStyleSchemeChooserWidgetMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo + ResolveStyleSchemeChooserWidgetMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo + ResolveStyleSchemeChooserWidgetMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo + ResolveStyleSchemeChooserWidgetMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo + ResolveStyleSchemeChooserWidgetMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo + ResolveStyleSchemeChooserWidgetMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo + ResolveStyleSchemeChooserWidgetMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo + ResolveStyleSchemeChooserWidgetMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo + ResolveStyleSchemeChooserWidgetMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo + ResolveStyleSchemeChooserWidgetMethod "event" o = Gtk.Widget.WidgetEventMethodInfo + ResolveStyleSchemeChooserWidgetMethod "forall" o = Gtk.Container.ContainerForallMethodInfo + ResolveStyleSchemeChooserWidgetMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveStyleSchemeChooserWidgetMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo + ResolveStyleSchemeChooserWidgetMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo + ResolveStyleSchemeChooserWidgetMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveStyleSchemeChooserWidgetMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo + ResolveStyleSchemeChooserWidgetMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo + ResolveStyleSchemeChooserWidgetMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo + ResolveStyleSchemeChooserWidgetMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo + ResolveStyleSchemeChooserWidgetMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo + ResolveStyleSchemeChooserWidgetMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo + ResolveStyleSchemeChooserWidgetMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo + ResolveStyleSchemeChooserWidgetMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo + ResolveStyleSchemeChooserWidgetMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo + ResolveStyleSchemeChooserWidgetMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo + ResolveStyleSchemeChooserWidgetMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo + ResolveStyleSchemeChooserWidgetMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo + ResolveStyleSchemeChooserWidgetMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo + ResolveStyleSchemeChooserWidgetMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo + ResolveStyleSchemeChooserWidgetMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo + ResolveStyleSchemeChooserWidgetMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo + ResolveStyleSchemeChooserWidgetMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo + ResolveStyleSchemeChooserWidgetMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo + ResolveStyleSchemeChooserWidgetMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo + ResolveStyleSchemeChooserWidgetMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo + ResolveStyleSchemeChooserWidgetMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveStyleSchemeChooserWidgetMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo + ResolveStyleSchemeChooserWidgetMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo + ResolveStyleSchemeChooserWidgetMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo + ResolveStyleSchemeChooserWidgetMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo + ResolveStyleSchemeChooserWidgetMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo + ResolveStyleSchemeChooserWidgetMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo + ResolveStyleSchemeChooserWidgetMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo + ResolveStyleSchemeChooserWidgetMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo + ResolveStyleSchemeChooserWidgetMethod "map" o = Gtk.Widget.WidgetMapMethodInfo + ResolveStyleSchemeChooserWidgetMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo + ResolveStyleSchemeChooserWidgetMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo + ResolveStyleSchemeChooserWidgetMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo + ResolveStyleSchemeChooserWidgetMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo + ResolveStyleSchemeChooserWidgetMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo + ResolveStyleSchemeChooserWidgetMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo + ResolveStyleSchemeChooserWidgetMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo + ResolveStyleSchemeChooserWidgetMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo + ResolveStyleSchemeChooserWidgetMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveStyleSchemeChooserWidgetMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveStyleSchemeChooserWidgetMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo + ResolveStyleSchemeChooserWidgetMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo + ResolveStyleSchemeChooserWidgetMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo + ResolveStyleSchemeChooserWidgetMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo + ResolveStyleSchemeChooserWidgetMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo + ResolveStyleSchemeChooserWidgetMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo + ResolveStyleSchemeChooserWidgetMethod "path" o = Gtk.Widget.WidgetPathMethodInfo + ResolveStyleSchemeChooserWidgetMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo + ResolveStyleSchemeChooserWidgetMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo + ResolveStyleSchemeChooserWidgetMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo + ResolveStyleSchemeChooserWidgetMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo + ResolveStyleSchemeChooserWidgetMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo + ResolveStyleSchemeChooserWidgetMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo + ResolveStyleSchemeChooserWidgetMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo + ResolveStyleSchemeChooserWidgetMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo + ResolveStyleSchemeChooserWidgetMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo + ResolveStyleSchemeChooserWidgetMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveStyleSchemeChooserWidgetMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveStyleSchemeChooserWidgetMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo + ResolveStyleSchemeChooserWidgetMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo + ResolveStyleSchemeChooserWidgetMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo + ResolveStyleSchemeChooserWidgetMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo + ResolveStyleSchemeChooserWidgetMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo + ResolveStyleSchemeChooserWidgetMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo + ResolveStyleSchemeChooserWidgetMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo + ResolveStyleSchemeChooserWidgetMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo + ResolveStyleSchemeChooserWidgetMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo + ResolveStyleSchemeChooserWidgetMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo + ResolveStyleSchemeChooserWidgetMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo + ResolveStyleSchemeChooserWidgetMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo + ResolveStyleSchemeChooserWidgetMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveStyleSchemeChooserWidgetMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo + ResolveStyleSchemeChooserWidgetMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo + ResolveStyleSchemeChooserWidgetMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo + ResolveStyleSchemeChooserWidgetMethod "show" o = Gtk.Widget.WidgetShowMethodInfo + ResolveStyleSchemeChooserWidgetMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo + ResolveStyleSchemeChooserWidgetMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo + ResolveStyleSchemeChooserWidgetMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo + ResolveStyleSchemeChooserWidgetMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo + ResolveStyleSchemeChooserWidgetMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo + ResolveStyleSchemeChooserWidgetMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveStyleSchemeChooserWidgetMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveStyleSchemeChooserWidgetMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo + ResolveStyleSchemeChooserWidgetMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo + ResolveStyleSchemeChooserWidgetMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo + ResolveStyleSchemeChooserWidgetMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveStyleSchemeChooserWidgetMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo + ResolveStyleSchemeChooserWidgetMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo + ResolveStyleSchemeChooserWidgetMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo + ResolveStyleSchemeChooserWidgetMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo + ResolveStyleSchemeChooserWidgetMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo + ResolveStyleSchemeChooserWidgetMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveStyleSchemeChooserWidgetMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo + ResolveStyleSchemeChooserWidgetMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo + ResolveStyleSchemeChooserWidgetMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo + ResolveStyleSchemeChooserWidgetMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getChild" o = Gtk.Bin.BinGetChildMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getStyleScheme" o = GtkSource.StyleSchemeChooser.StyleSchemeChooserGetStyleSchemeMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo + ResolveStyleSchemeChooserWidgetMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setStyleScheme" o = GtkSource.StyleSchemeChooser.StyleSchemeChooserSetStyleSchemeMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo + ResolveStyleSchemeChooserWidgetMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo + ResolveStyleSchemeChooserWidgetMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveStyleSchemeChooserWidgetMethod t StyleSchemeChooserWidget, O.MethodInfo info StyleSchemeChooserWidget p) => OL.IsLabel t (StyleSchemeChooserWidget -> 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 + +#if ENABLE_OVERLOADING +instance O.HasAttributeList StyleSchemeChooserWidget +type instance O.AttributeList StyleSchemeChooserWidget = StyleSchemeChooserWidgetAttributeList +type StyleSchemeChooserWidgetAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("styleScheme", GtkSource.StyleSchemeChooser.StyleSchemeChooserStyleSchemePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList StyleSchemeChooserWidget = StyleSchemeChooserWidgetSignalList +type StyleSchemeChooserWidgetSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("remove", Gtk.Container.ContainerRemoveSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("setFocusChild", Gtk.Container.ContainerSetFocusChildSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method StyleSchemeChooserWidget::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "StyleSchemeChooserWidget"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_style_scheme_chooser_widget_new" gtk_source_style_scheme_chooser_widget_new :: + IO (Ptr StyleSchemeChooserWidget) + +{- | +Creates a new 'GI.GtkSource.Objects.StyleSchemeChooserWidget.StyleSchemeChooserWidget'. + +/Since: 3.16/ +-} +styleSchemeChooserWidgetNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m StyleSchemeChooserWidget + {- ^ __Returns:__ a new 'GI.GtkSource.Objects.StyleSchemeChooserWidget.StyleSchemeChooserWidget'. -} +styleSchemeChooserWidgetNew = liftIO $ do + result <- gtk_source_style_scheme_chooser_widget_new + checkUnexpectedReturnNULL "styleSchemeChooserWidgetNew" result + result' <- (newObject StyleSchemeChooserWidget) result + return result' + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/GtkSource/Objects/StyleSchemeChooserWidget.hs-boot b/GI/GtkSource/Objects/StyleSchemeChooserWidget.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/StyleSchemeChooserWidget.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.StyleSchemeChooserWidget 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 StyleSchemeChooserWidget = StyleSchemeChooserWidget (ManagedPtr StyleSchemeChooserWidget) +instance GObject StyleSchemeChooserWidget where +class (GObject o, O.IsDescendantOf StyleSchemeChooserWidget o) => IsStyleSchemeChooserWidget o +instance (GObject o, O.IsDescendantOf StyleSchemeChooserWidget o) => IsStyleSchemeChooserWidget o +instance O.HasParentTypes StyleSchemeChooserWidget diff --git a/GI/GtkSource/Objects/StyleSchemeManager.hs b/GI/GtkSource/Objects/StyleSchemeManager.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/StyleSchemeManager.hs @@ -0,0 +1,663 @@ + + +{- | +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.StyleSchemeManager + ( + +-- * Exported types + StyleSchemeManager(..) , + IsStyleSchemeManager , + toStyleSchemeManager , + noStyleSchemeManager , + + + -- * Methods +-- ** appendSearchPath #method:appendSearchPath# + +#if ENABLE_OVERLOADING + StyleSchemeManagerAppendSearchPathMethodInfo, +#endif + styleSchemeManagerAppendSearchPath , + + +-- ** forceRescan #method:forceRescan# + +#if ENABLE_OVERLOADING + StyleSchemeManagerForceRescanMethodInfo , +#endif + styleSchemeManagerForceRescan , + + +-- ** getDefault #method:getDefault# + + styleSchemeManagerGetDefault , + + +-- ** getScheme #method:getScheme# + +#if ENABLE_OVERLOADING + StyleSchemeManagerGetSchemeMethodInfo , +#endif + styleSchemeManagerGetScheme , + + +-- ** getSchemeIds #method:getSchemeIds# + +#if ENABLE_OVERLOADING + StyleSchemeManagerGetSchemeIdsMethodInfo, +#endif + styleSchemeManagerGetSchemeIds , + + +-- ** getSearchPath #method:getSearchPath# + +#if ENABLE_OVERLOADING + StyleSchemeManagerGetSearchPathMethodInfo, +#endif + styleSchemeManagerGetSearchPath , + + +-- ** new #method:new# + + styleSchemeManagerNew , + + +-- ** prependSearchPath #method:prependSearchPath# + +#if ENABLE_OVERLOADING + StyleSchemeManagerPrependSearchPathMethodInfo, +#endif + styleSchemeManagerPrependSearchPath , + + +-- ** setSearchPath #method:setSearchPath# + +#if ENABLE_OVERLOADING + StyleSchemeManagerSetSearchPathMethodInfo, +#endif + styleSchemeManagerSetSearchPath , + + + + + -- * Properties +-- ** schemeIds #attr:schemeIds# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + StyleSchemeManagerSchemeIdsPropertyInfo , +#endif + getStyleSchemeManagerSchemeIds , +#if ENABLE_OVERLOADING + styleSchemeManagerSchemeIds , +#endif + + +-- ** searchPath #attr:searchPath# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + StyleSchemeManagerSearchPathPropertyInfo, +#endif + clearStyleSchemeManagerSearchPath , + constructStyleSchemeManagerSearchPath , + getStyleSchemeManagerSearchPath , + setStyleSchemeManagerSearchPath , +#if ENABLE_OVERLOADING + styleSchemeManagerSearchPath , +#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 + +-- | Memory-managed wrapper type. +newtype StyleSchemeManager = StyleSchemeManager (ManagedPtr StyleSchemeManager) +foreign import ccall "gtk_source_style_scheme_manager_get_type" + c_gtk_source_style_scheme_manager_get_type :: IO GType + +instance GObject StyleSchemeManager where + gobjectType = c_gtk_source_style_scheme_manager_get_type + + +-- | Type class for types which can be safely cast to `StyleSchemeManager`, for instance with `toStyleSchemeManager`. +class (GObject o, O.IsDescendantOf StyleSchemeManager o) => IsStyleSchemeManager o +instance (GObject o, O.IsDescendantOf StyleSchemeManager o) => IsStyleSchemeManager o + +instance O.HasParentTypes StyleSchemeManager +type instance O.ParentTypes StyleSchemeManager = '[GObject.Object.Object] + +-- | Cast to `StyleSchemeManager`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toStyleSchemeManager :: (MonadIO m, IsStyleSchemeManager o) => o -> m StyleSchemeManager +toStyleSchemeManager = liftIO . unsafeCastTo StyleSchemeManager + +-- | A convenience alias for `Nothing` :: `Maybe` `StyleSchemeManager`. +noStyleSchemeManager :: Maybe StyleSchemeManager +noStyleSchemeManager = Nothing + +#if ENABLE_OVERLOADING +type family ResolveStyleSchemeManagerMethod (t :: Symbol) (o :: *) :: * where + ResolveStyleSchemeManagerMethod "appendSearchPath" o = StyleSchemeManagerAppendSearchPathMethodInfo + ResolveStyleSchemeManagerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveStyleSchemeManagerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveStyleSchemeManagerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveStyleSchemeManagerMethod "forceRescan" o = StyleSchemeManagerForceRescanMethodInfo + ResolveStyleSchemeManagerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveStyleSchemeManagerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveStyleSchemeManagerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveStyleSchemeManagerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveStyleSchemeManagerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveStyleSchemeManagerMethod "prependSearchPath" o = StyleSchemeManagerPrependSearchPathMethodInfo + ResolveStyleSchemeManagerMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveStyleSchemeManagerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveStyleSchemeManagerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveStyleSchemeManagerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveStyleSchemeManagerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveStyleSchemeManagerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveStyleSchemeManagerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveStyleSchemeManagerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveStyleSchemeManagerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveStyleSchemeManagerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveStyleSchemeManagerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveStyleSchemeManagerMethod "getScheme" o = StyleSchemeManagerGetSchemeMethodInfo + ResolveStyleSchemeManagerMethod "getSchemeIds" o = StyleSchemeManagerGetSchemeIdsMethodInfo + ResolveStyleSchemeManagerMethod "getSearchPath" o = StyleSchemeManagerGetSearchPathMethodInfo + ResolveStyleSchemeManagerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveStyleSchemeManagerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveStyleSchemeManagerMethod "setSearchPath" o = StyleSchemeManagerSetSearchPathMethodInfo + ResolveStyleSchemeManagerMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveStyleSchemeManagerMethod t StyleSchemeManager, O.MethodInfo info StyleSchemeManager p) => OL.IsLabel t (StyleSchemeManager -> 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 + +-- VVV Prop "scheme-ids" + -- Type: TCArray True (-1) (-1) (TBasicType TUTF8) + -- Flags: [PropertyReadable] + -- Nullable: (Just True,Nothing) + +{- | +Get the value of the “@scheme-ids@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' styleSchemeManager #schemeIds +@ +-} +getStyleSchemeManagerSchemeIds :: (MonadIO m, IsStyleSchemeManager o) => o -> m (Maybe [T.Text]) +getStyleSchemeManagerSchemeIds obj = liftIO $ B.Properties.getObjectPropertyStringArray obj "scheme-ids" + +#if ENABLE_OVERLOADING +data StyleSchemeManagerSchemeIdsPropertyInfo +instance AttrInfo StyleSchemeManagerSchemeIdsPropertyInfo where + type AttrAllowedOps StyleSchemeManagerSchemeIdsPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint StyleSchemeManagerSchemeIdsPropertyInfo = (~) () + type AttrBaseTypeConstraint StyleSchemeManagerSchemeIdsPropertyInfo = IsStyleSchemeManager + type AttrGetType StyleSchemeManagerSchemeIdsPropertyInfo = (Maybe [T.Text]) + type AttrLabel StyleSchemeManagerSchemeIdsPropertyInfo = "scheme-ids" + type AttrOrigin StyleSchemeManagerSchemeIdsPropertyInfo = StyleSchemeManager + attrGet _ = getStyleSchemeManagerSchemeIds + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "search-path" + -- Type: TCArray True (-1) (-1) (TBasicType TUTF8) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just True) + +{- | +Get the value of the “@search-path@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' styleSchemeManager #searchPath +@ +-} +getStyleSchemeManagerSearchPath :: (MonadIO m, IsStyleSchemeManager o) => o -> m [T.Text] +getStyleSchemeManagerSearchPath obj = liftIO $ checkUnexpectedNothing "getStyleSchemeManagerSearchPath" $ B.Properties.getObjectPropertyStringArray obj "search-path" + +{- | +Set the value of the “@search-path@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' styleSchemeManager [ #searchPath 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setStyleSchemeManagerSearchPath :: (MonadIO m, IsStyleSchemeManager o) => o -> [T.Text] -> m () +setStyleSchemeManagerSearchPath obj val = liftIO $ B.Properties.setObjectPropertyStringArray obj "search-path" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@search-path@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructStyleSchemeManagerSearchPath :: (IsStyleSchemeManager o) => [T.Text] -> IO (GValueConstruct o) +constructStyleSchemeManagerSearchPath val = B.Properties.constructObjectPropertyStringArray "search-path" (Just val) + +{- | +Set the value of the “@search-path@” property to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #searchPath +@ +-} +clearStyleSchemeManagerSearchPath :: (MonadIO m, IsStyleSchemeManager o) => o -> m () +clearStyleSchemeManagerSearchPath obj = liftIO $ B.Properties.setObjectPropertyStringArray obj "search-path" (Nothing :: Maybe [T.Text]) + +#if ENABLE_OVERLOADING +data StyleSchemeManagerSearchPathPropertyInfo +instance AttrInfo StyleSchemeManagerSearchPathPropertyInfo where + type AttrAllowedOps StyleSchemeManagerSearchPathPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint StyleSchemeManagerSearchPathPropertyInfo = (~) [T.Text] + type AttrBaseTypeConstraint StyleSchemeManagerSearchPathPropertyInfo = IsStyleSchemeManager + type AttrGetType StyleSchemeManagerSearchPathPropertyInfo = [T.Text] + type AttrLabel StyleSchemeManagerSearchPathPropertyInfo = "search-path" + type AttrOrigin StyleSchemeManagerSearchPathPropertyInfo = StyleSchemeManager + attrGet _ = getStyleSchemeManagerSearchPath + attrSet _ = setStyleSchemeManagerSearchPath + attrConstruct _ = constructStyleSchemeManagerSearchPath + attrClear _ = clearStyleSchemeManagerSearchPath +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList StyleSchemeManager +type instance O.AttributeList StyleSchemeManager = StyleSchemeManagerAttributeList +type StyleSchemeManagerAttributeList = ('[ '("schemeIds", StyleSchemeManagerSchemeIdsPropertyInfo), '("searchPath", StyleSchemeManagerSearchPathPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +styleSchemeManagerSchemeIds :: AttrLabelProxy "schemeIds" +styleSchemeManagerSchemeIds = AttrLabelProxy + +styleSchemeManagerSearchPath :: AttrLabelProxy "searchPath" +styleSchemeManagerSearchPath = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList StyleSchemeManager = StyleSchemeManagerSignalList +type StyleSchemeManagerSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method StyleSchemeManager::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "StyleSchemeManager"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_style_scheme_manager_new" gtk_source_style_scheme_manager_new :: + IO (Ptr StyleSchemeManager) + +{- | +Creates a new style manager. If you do not need more than one style +manager then use 'GI.GtkSource.Objects.StyleSchemeManager.styleSchemeManagerGetDefault' instead. +-} +styleSchemeManagerNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m StyleSchemeManager + {- ^ __Returns:__ a new 'GI.GtkSource.Objects.StyleSchemeManager.StyleSchemeManager'. -} +styleSchemeManagerNew = liftIO $ do + result <- gtk_source_style_scheme_manager_new + checkUnexpectedReturnNULL "styleSchemeManagerNew" result + result' <- (wrapObject StyleSchemeManager) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method StyleSchemeManager::append_search_path +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "StyleSchemeManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceStyleSchemeManager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a directory or a filename.", 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_manager_append_search_path" gtk_source_style_scheme_manager_append_search_path :: + Ptr StyleSchemeManager -> -- manager : TInterface (Name {namespace = "GtkSource", name = "StyleSchemeManager"}) + CString -> -- path : TBasicType TUTF8 + IO () + +{- | +Appends /@path@/ to the list of directories where the /@manager@/ looks for +style scheme files. +See 'GI.GtkSource.Objects.StyleSchemeManager.styleSchemeManagerSetSearchPath' for details. +-} +styleSchemeManagerAppendSearchPath :: + (B.CallStack.HasCallStack, MonadIO m, IsStyleSchemeManager a) => + a + {- ^ /@manager@/: a 'GI.GtkSource.Objects.StyleSchemeManager.StyleSchemeManager'. -} + -> T.Text + {- ^ /@path@/: a directory or a filename. -} + -> m () +styleSchemeManagerAppendSearchPath manager path = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + path' <- textToCString path + gtk_source_style_scheme_manager_append_search_path manager' path' + touchManagedPtr manager + freeMem path' + return () + +#if ENABLE_OVERLOADING +data StyleSchemeManagerAppendSearchPathMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsStyleSchemeManager a) => O.MethodInfo StyleSchemeManagerAppendSearchPathMethodInfo a signature where + overloadedMethod _ = styleSchemeManagerAppendSearchPath + +#endif + +-- method StyleSchemeManager::force_rescan +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "StyleSchemeManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceStyleSchemeManager.", 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_manager_force_rescan" gtk_source_style_scheme_manager_force_rescan :: + Ptr StyleSchemeManager -> -- manager : TInterface (Name {namespace = "GtkSource", name = "StyleSchemeManager"}) + IO () + +{- | +Mark any currently cached information about the available style scehems +as invalid. All the available style schemes will be reloaded next time +the /@manager@/ is accessed. +-} +styleSchemeManagerForceRescan :: + (B.CallStack.HasCallStack, MonadIO m, IsStyleSchemeManager a) => + a + {- ^ /@manager@/: a 'GI.GtkSource.Objects.StyleSchemeManager.StyleSchemeManager'. -} + -> m () +styleSchemeManagerForceRescan manager = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + gtk_source_style_scheme_manager_force_rescan manager' + touchManagedPtr manager + return () + +#if ENABLE_OVERLOADING +data StyleSchemeManagerForceRescanMethodInfo +instance (signature ~ (m ()), MonadIO m, IsStyleSchemeManager a) => O.MethodInfo StyleSchemeManagerForceRescanMethodInfo a signature where + overloadedMethod _ = styleSchemeManagerForceRescan + +#endif + +-- method StyleSchemeManager::get_scheme +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "StyleSchemeManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceStyleSchemeManager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scheme_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "style scheme id to find.", 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_manager_get_scheme" gtk_source_style_scheme_manager_get_scheme :: + Ptr StyleSchemeManager -> -- manager : TInterface (Name {namespace = "GtkSource", name = "StyleSchemeManager"}) + CString -> -- scheme_id : TBasicType TUTF8 + IO (Ptr GtkSource.StyleScheme.StyleScheme) + +{- | +Looks up style scheme by id. +-} +styleSchemeManagerGetScheme :: + (B.CallStack.HasCallStack, MonadIO m, IsStyleSchemeManager a) => + a + {- ^ /@manager@/: a 'GI.GtkSource.Objects.StyleSchemeManager.StyleSchemeManager'. -} + -> T.Text + {- ^ /@schemeId@/: style scheme id to find. -} + -> m GtkSource.StyleScheme.StyleScheme + {- ^ __Returns:__ a 'GI.GtkSource.Objects.StyleScheme.StyleScheme' object. Returned value is owned by +/@manager@/ and must not be unref\'ed. -} +styleSchemeManagerGetScheme manager schemeId = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + schemeId' <- textToCString schemeId + result <- gtk_source_style_scheme_manager_get_scheme manager' schemeId' + checkUnexpectedReturnNULL "styleSchemeManagerGetScheme" result + result' <- (newObject GtkSource.StyleScheme.StyleScheme) result + touchManagedPtr manager + freeMem schemeId' + return result' + +#if ENABLE_OVERLOADING +data StyleSchemeManagerGetSchemeMethodInfo +instance (signature ~ (T.Text -> m GtkSource.StyleScheme.StyleScheme), MonadIO m, IsStyleSchemeManager a) => O.MethodInfo StyleSchemeManagerGetSchemeMethodInfo a signature where + overloadedMethod _ = styleSchemeManagerGetScheme + +#endif + +-- method StyleSchemeManager::get_scheme_ids +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "StyleSchemeManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceStyleSchemeManager.", 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_style_scheme_manager_get_scheme_ids" gtk_source_style_scheme_manager_get_scheme_ids :: + Ptr StyleSchemeManager -> -- manager : TInterface (Name {namespace = "GtkSource", name = "StyleSchemeManager"}) + IO (Ptr CString) + +{- | +Returns the ids of the available style schemes. +-} +styleSchemeManagerGetSchemeIds :: + (B.CallStack.HasCallStack, MonadIO m, IsStyleSchemeManager a) => + a + {- ^ /@manager@/: a 'GI.GtkSource.Objects.StyleSchemeManager.StyleSchemeManager'. -} + -> m (Maybe [T.Text]) + {- ^ __Returns:__ +a 'Nothing'-terminated array of strings containing the ids of the available +style schemes or 'Nothing' if no style scheme is available. +The array is sorted alphabetically according to the scheme name. +The array is owned by the /@manager@/ and must not be modified. -} +styleSchemeManagerGetSchemeIds manager = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + result <- gtk_source_style_scheme_manager_get_scheme_ids manager' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- unpackZeroTerminatedUTF8CArray result' + return result'' + touchManagedPtr manager + return maybeResult + +#if ENABLE_OVERLOADING +data StyleSchemeManagerGetSchemeIdsMethodInfo +instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsStyleSchemeManager a) => O.MethodInfo StyleSchemeManagerGetSchemeIdsMethodInfo a signature where + overloadedMethod _ = styleSchemeManagerGetSchemeIds + +#endif + +-- method StyleSchemeManager::get_search_path +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "StyleSchemeManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceStyleSchemeManager.", 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_style_scheme_manager_get_search_path" gtk_source_style_scheme_manager_get_search_path :: + Ptr StyleSchemeManager -> -- manager : TInterface (Name {namespace = "GtkSource", name = "StyleSchemeManager"}) + IO (Ptr CString) + +{- | +Returns the current search path for the /@manager@/. +See 'GI.GtkSource.Objects.StyleSchemeManager.styleSchemeManagerSetSearchPath' for details. +-} +styleSchemeManagerGetSearchPath :: + (B.CallStack.HasCallStack, MonadIO m, IsStyleSchemeManager a) => + a + {- ^ /@manager@/: a 'GI.GtkSource.Objects.StyleSchemeManager.StyleSchemeManager'. -} + -> m [T.Text] + {- ^ __Returns:__ a 'Nothing'-terminated array +of string containing the search path. +The array is owned by the /@manager@/ and must not be modified. -} +styleSchemeManagerGetSearchPath manager = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + result <- gtk_source_style_scheme_manager_get_search_path manager' + checkUnexpectedReturnNULL "styleSchemeManagerGetSearchPath" result + result' <- unpackZeroTerminatedUTF8CArray result + touchManagedPtr manager + return result' + +#if ENABLE_OVERLOADING +data StyleSchemeManagerGetSearchPathMethodInfo +instance (signature ~ (m [T.Text]), MonadIO m, IsStyleSchemeManager a) => O.MethodInfo StyleSchemeManagerGetSearchPathMethodInfo a signature where + overloadedMethod _ = styleSchemeManagerGetSearchPath + +#endif + +-- method StyleSchemeManager::prepend_search_path +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "StyleSchemeManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceStyleSchemeManager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a directory or a filename.", 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_manager_prepend_search_path" gtk_source_style_scheme_manager_prepend_search_path :: + Ptr StyleSchemeManager -> -- manager : TInterface (Name {namespace = "GtkSource", name = "StyleSchemeManager"}) + CString -> -- path : TBasicType TUTF8 + IO () + +{- | +Prepends /@path@/ to the list of directories where the /@manager@/ looks +for style scheme files. +See 'GI.GtkSource.Objects.StyleSchemeManager.styleSchemeManagerSetSearchPath' for details. +-} +styleSchemeManagerPrependSearchPath :: + (B.CallStack.HasCallStack, MonadIO m, IsStyleSchemeManager a) => + a + {- ^ /@manager@/: a 'GI.GtkSource.Objects.StyleSchemeManager.StyleSchemeManager'. -} + -> T.Text + {- ^ /@path@/: a directory or a filename. -} + -> m () +styleSchemeManagerPrependSearchPath manager path = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + path' <- textToCString path + gtk_source_style_scheme_manager_prepend_search_path manager' path' + touchManagedPtr manager + freeMem path' + return () + +#if ENABLE_OVERLOADING +data StyleSchemeManagerPrependSearchPathMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsStyleSchemeManager a) => O.MethodInfo StyleSchemeManagerPrependSearchPathMethodInfo a signature where + overloadedMethod _ = styleSchemeManagerPrependSearchPath + +#endif + +-- method StyleSchemeManager::set_search_path +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "manager", argType = TInterface (Name {namespace = "GtkSource", name = "StyleSchemeManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceStyleSchemeManager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "\na %NULL-terminated array of strings 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_style_scheme_manager_set_search_path" gtk_source_style_scheme_manager_set_search_path :: + Ptr StyleSchemeManager -> -- manager : TInterface (Name {namespace = "GtkSource", name = "StyleSchemeManager"}) + Ptr CString -> -- path : TCArray True (-1) (-1) (TBasicType TUTF8) + IO () + +{- | +Sets the list of directories where the /@manager@/ looks for +style scheme files. +If /@path@/ is 'Nothing', the search path is reset to default. +-} +styleSchemeManagerSetSearchPath :: + (B.CallStack.HasCallStack, MonadIO m, IsStyleSchemeManager a) => + a + {- ^ /@manager@/: a 'GI.GtkSource.Objects.StyleSchemeManager.StyleSchemeManager'. -} + -> Maybe ([T.Text]) + {- ^ /@path@/: +a 'Nothing'-terminated array of strings or 'Nothing'. -} + -> m () +styleSchemeManagerSetSearchPath manager path = liftIO $ do + manager' <- unsafeManagedPtrCastPtr manager + maybePath <- case path of + Nothing -> return nullPtr + Just jPath -> do + jPath' <- packZeroTerminatedUTF8CArray jPath + return jPath' + gtk_source_style_scheme_manager_set_search_path manager' maybePath + touchManagedPtr manager + mapZeroTerminatedCArray freeMem maybePath + freeMem maybePath + return () + +#if ENABLE_OVERLOADING +data StyleSchemeManagerSetSearchPathMethodInfo +instance (signature ~ (Maybe ([T.Text]) -> m ()), MonadIO m, IsStyleSchemeManager a) => O.MethodInfo StyleSchemeManagerSetSearchPathMethodInfo a signature where + overloadedMethod _ = styleSchemeManagerSetSearchPath + +#endif + +-- method StyleSchemeManager::get_default +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "StyleSchemeManager"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_style_scheme_manager_get_default" gtk_source_style_scheme_manager_get_default :: + IO (Ptr StyleSchemeManager) + +{- | +Returns the default 'GI.GtkSource.Objects.StyleSchemeManager.StyleSchemeManager' instance. +-} +styleSchemeManagerGetDefault :: + (B.CallStack.HasCallStack, MonadIO m) => + m StyleSchemeManager + {- ^ __Returns:__ a 'GI.GtkSource.Objects.StyleSchemeManager.StyleSchemeManager'. Return value +is owned by GtkSourceView library and must not be unref\'ed. -} +styleSchemeManagerGetDefault = liftIO $ do + result <- gtk_source_style_scheme_manager_get_default + checkUnexpectedReturnNULL "styleSchemeManagerGetDefault" result + result' <- (newObject StyleSchemeManager) result + return result' + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/GtkSource/Objects/StyleSchemeManager.hs-boot b/GI/GtkSource/Objects/StyleSchemeManager.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/StyleSchemeManager.hs-boot @@ -0,0 +1,56 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.StyleSchemeManager 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 StyleSchemeManager = StyleSchemeManager (ManagedPtr StyleSchemeManager) +instance GObject StyleSchemeManager where +class (GObject o, O.IsDescendantOf StyleSchemeManager o) => IsStyleSchemeManager o +instance (GObject o, O.IsDescendantOf StyleSchemeManager o) => IsStyleSchemeManager o +instance O.HasParentTypes StyleSchemeManager +#if ENABLE_OVERLOADING +data StyleSchemeManagerSchemeIdsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data StyleSchemeManagerSearchPathPropertyInfo +#endif +#if ENABLE_OVERLOADING +data StyleSchemeManagerAppendSearchPathMethodInfo +#endif +#if ENABLE_OVERLOADING +data StyleSchemeManagerForceRescanMethodInfo +#endif +#if ENABLE_OVERLOADING +data StyleSchemeManagerGetSchemeMethodInfo +#endif +#if ENABLE_OVERLOADING +data StyleSchemeManagerGetSchemeIdsMethodInfo +#endif +#if ENABLE_OVERLOADING +data StyleSchemeManagerGetSearchPathMethodInfo +#endif +#if ENABLE_OVERLOADING +data StyleSchemeManagerPrependSearchPathMethodInfo +#endif +#if ENABLE_OVERLOADING +data StyleSchemeManagerSetSearchPathMethodInfo +#endif diff --git a/GI/GtkSource/Objects/Tag.hs b/GI/GtkSource/Objects/Tag.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/Tag.hs @@ -0,0 +1,319 @@ + + +{- | +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.Tag + ( + +-- * Exported types + Tag(..) , + IsTag , + toTag , + noTag , + + + -- * Methods +-- ** new #method:new# + + tagNew , + + + + + -- * Properties +-- ** drawSpaces #attr:drawSpaces# +{- | Whether to draw white spaces. This property takes precedence over the value +defined by the GtkSourceSpaceDrawer\'s 'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer':@/matrix/@ property +(only where the tag is applied). + +Setting this property also changes 'GI.GtkSource.Objects.Tag.Tag':@/draw-spaces-set/@ to +'True'. + +/Since: 3.20/ +-} +#if ENABLE_OVERLOADING + TagDrawSpacesPropertyInfo , +#endif + constructTagDrawSpaces , + getTagDrawSpaces , + setTagDrawSpaces , +#if ENABLE_OVERLOADING + tagDrawSpaces , +#endif + + +-- ** drawSpacesSet #attr:drawSpacesSet# +{- | Whether the 'GI.GtkSource.Objects.Tag.Tag':@/draw-spaces/@ property is set and must be +taken into account. + +/Since: 3.20/ +-} +#if ENABLE_OVERLOADING + TagDrawSpacesSetPropertyInfo , +#endif + constructTagDrawSpacesSet , + getTagDrawSpacesSet , + setTagDrawSpacesSet , +#if ENABLE_OVERLOADING + tagDrawSpacesSet , +#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 qualified GI.Gtk.Objects.TextTag as Gtk.TextTag + +-- | Memory-managed wrapper type. +newtype Tag = Tag (ManagedPtr Tag) +foreign import ccall "gtk_source_tag_get_type" + c_gtk_source_tag_get_type :: IO GType + +instance GObject Tag where + gobjectType = c_gtk_source_tag_get_type + + +-- | Type class for types which can be safely cast to `Tag`, for instance with `toTag`. +class (GObject o, O.IsDescendantOf Tag o) => IsTag o +instance (GObject o, O.IsDescendantOf Tag o) => IsTag o + +instance O.HasParentTypes Tag +type instance O.ParentTypes Tag = '[Gtk.TextTag.TextTag, GObject.Object.Object] + +-- | Cast to `Tag`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toTag :: (MonadIO m, IsTag o) => o -> m Tag +toTag = liftIO . unsafeCastTo Tag + +-- | A convenience alias for `Nothing` :: `Maybe` `Tag`. +noTag :: Maybe Tag +noTag = Nothing + +#if ENABLE_OVERLOADING +type family ResolveTagMethod (t :: Symbol) (o :: *) :: * where + ResolveTagMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveTagMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveTagMethod "changed" o = Gtk.TextTag.TextTagChangedMethodInfo + ResolveTagMethod "event" o = Gtk.TextTag.TextTagEventMethodInfo + ResolveTagMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveTagMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveTagMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveTagMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveTagMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveTagMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveTagMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveTagMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveTagMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveTagMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveTagMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveTagMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveTagMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveTagMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveTagMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveTagMethod "getPriority" o = Gtk.TextTag.TextTagGetPriorityMethodInfo + ResolveTagMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveTagMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveTagMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveTagMethod "setPriority" o = Gtk.TextTag.TextTagSetPriorityMethodInfo + ResolveTagMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveTagMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveTagMethod t Tag, O.MethodInfo info Tag p) => OL.IsLabel t (Tag -> 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 + +-- VVV Prop "draw-spaces" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@draw-spaces@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' tag #drawSpaces +@ +-} +getTagDrawSpaces :: (MonadIO m, IsTag o) => o -> m Bool +getTagDrawSpaces obj = liftIO $ B.Properties.getObjectPropertyBool obj "draw-spaces" + +{- | +Set the value of the “@draw-spaces@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' tag [ #drawSpaces 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setTagDrawSpaces :: (MonadIO m, IsTag o) => o -> Bool -> m () +setTagDrawSpaces obj val = liftIO $ B.Properties.setObjectPropertyBool obj "draw-spaces" val + +{- | +Construct a `GValueConstruct` with valid value for the “@draw-spaces@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructTagDrawSpaces :: (IsTag o) => Bool -> IO (GValueConstruct o) +constructTagDrawSpaces val = B.Properties.constructObjectPropertyBool "draw-spaces" val + +#if ENABLE_OVERLOADING +data TagDrawSpacesPropertyInfo +instance AttrInfo TagDrawSpacesPropertyInfo where + type AttrAllowedOps TagDrawSpacesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint TagDrawSpacesPropertyInfo = (~) Bool + type AttrBaseTypeConstraint TagDrawSpacesPropertyInfo = IsTag + type AttrGetType TagDrawSpacesPropertyInfo = Bool + type AttrLabel TagDrawSpacesPropertyInfo = "draw-spaces" + type AttrOrigin TagDrawSpacesPropertyInfo = Tag + attrGet _ = getTagDrawSpaces + attrSet _ = setTagDrawSpaces + attrConstruct _ = constructTagDrawSpaces + attrClear _ = undefined +#endif + +-- VVV Prop "draw-spaces-set" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@draw-spaces-set@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' tag #drawSpacesSet +@ +-} +getTagDrawSpacesSet :: (MonadIO m, IsTag o) => o -> m Bool +getTagDrawSpacesSet obj = liftIO $ B.Properties.getObjectPropertyBool obj "draw-spaces-set" + +{- | +Set the value of the “@draw-spaces-set@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' tag [ #drawSpacesSet 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setTagDrawSpacesSet :: (MonadIO m, IsTag o) => o -> Bool -> m () +setTagDrawSpacesSet obj val = liftIO $ B.Properties.setObjectPropertyBool obj "draw-spaces-set" val + +{- | +Construct a `GValueConstruct` with valid value for the “@draw-spaces-set@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructTagDrawSpacesSet :: (IsTag o) => Bool -> IO (GValueConstruct o) +constructTagDrawSpacesSet val = B.Properties.constructObjectPropertyBool "draw-spaces-set" val + +#if ENABLE_OVERLOADING +data TagDrawSpacesSetPropertyInfo +instance AttrInfo TagDrawSpacesSetPropertyInfo where + type AttrAllowedOps TagDrawSpacesSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint TagDrawSpacesSetPropertyInfo = (~) Bool + type AttrBaseTypeConstraint TagDrawSpacesSetPropertyInfo = IsTag + type AttrGetType TagDrawSpacesSetPropertyInfo = Bool + type AttrLabel TagDrawSpacesSetPropertyInfo = "draw-spaces-set" + type AttrOrigin TagDrawSpacesSetPropertyInfo = Tag + attrGet _ = getTagDrawSpacesSet + attrSet _ = setTagDrawSpacesSet + attrConstruct _ = constructTagDrawSpacesSet + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Tag +type instance O.AttributeList Tag = TagAttributeList +type TagAttributeList = ('[ '("accumulativeMargin", Gtk.TextTag.TextTagAccumulativeMarginPropertyInfo), '("background", Gtk.TextTag.TextTagBackgroundPropertyInfo), '("backgroundFullHeight", Gtk.TextTag.TextTagBackgroundFullHeightPropertyInfo), '("backgroundFullHeightSet", Gtk.TextTag.TextTagBackgroundFullHeightSetPropertyInfo), '("backgroundGdk", Gtk.TextTag.TextTagBackgroundGdkPropertyInfo), '("backgroundRgba", Gtk.TextTag.TextTagBackgroundRgbaPropertyInfo), '("backgroundSet", Gtk.TextTag.TextTagBackgroundSetPropertyInfo), '("direction", Gtk.TextTag.TextTagDirectionPropertyInfo), '("drawSpaces", TagDrawSpacesPropertyInfo), '("drawSpacesSet", TagDrawSpacesSetPropertyInfo), '("editable", Gtk.TextTag.TextTagEditablePropertyInfo), '("editableSet", Gtk.TextTag.TextTagEditableSetPropertyInfo), '("fallback", Gtk.TextTag.TextTagFallbackPropertyInfo), '("fallbackSet", Gtk.TextTag.TextTagFallbackSetPropertyInfo), '("family", Gtk.TextTag.TextTagFamilyPropertyInfo), '("familySet", Gtk.TextTag.TextTagFamilySetPropertyInfo), '("font", Gtk.TextTag.TextTagFontPropertyInfo), '("fontDesc", Gtk.TextTag.TextTagFontDescPropertyInfo), '("fontFeatures", Gtk.TextTag.TextTagFontFeaturesPropertyInfo), '("fontFeaturesSet", Gtk.TextTag.TextTagFontFeaturesSetPropertyInfo), '("foreground", Gtk.TextTag.TextTagForegroundPropertyInfo), '("foregroundGdk", Gtk.TextTag.TextTagForegroundGdkPropertyInfo), '("foregroundRgba", Gtk.TextTag.TextTagForegroundRgbaPropertyInfo), '("foregroundSet", Gtk.TextTag.TextTagForegroundSetPropertyInfo), '("indent", Gtk.TextTag.TextTagIndentPropertyInfo), '("indentSet", Gtk.TextTag.TextTagIndentSetPropertyInfo), '("invisible", Gtk.TextTag.TextTagInvisiblePropertyInfo), '("invisibleSet", Gtk.TextTag.TextTagInvisibleSetPropertyInfo), '("justification", Gtk.TextTag.TextTagJustificationPropertyInfo), '("justificationSet", Gtk.TextTag.TextTagJustificationSetPropertyInfo), '("language", Gtk.TextTag.TextTagLanguagePropertyInfo), '("languageSet", Gtk.TextTag.TextTagLanguageSetPropertyInfo), '("leftMargin", Gtk.TextTag.TextTagLeftMarginPropertyInfo), '("leftMarginSet", Gtk.TextTag.TextTagLeftMarginSetPropertyInfo), '("letterSpacing", Gtk.TextTag.TextTagLetterSpacingPropertyInfo), '("letterSpacingSet", Gtk.TextTag.TextTagLetterSpacingSetPropertyInfo), '("name", Gtk.TextTag.TextTagNamePropertyInfo), '("paragraphBackground", Gtk.TextTag.TextTagParagraphBackgroundPropertyInfo), '("paragraphBackgroundGdk", Gtk.TextTag.TextTagParagraphBackgroundGdkPropertyInfo), '("paragraphBackgroundRgba", Gtk.TextTag.TextTagParagraphBackgroundRgbaPropertyInfo), '("paragraphBackgroundSet", Gtk.TextTag.TextTagParagraphBackgroundSetPropertyInfo), '("pixelsAboveLines", Gtk.TextTag.TextTagPixelsAboveLinesPropertyInfo), '("pixelsAboveLinesSet", Gtk.TextTag.TextTagPixelsAboveLinesSetPropertyInfo), '("pixelsBelowLines", Gtk.TextTag.TextTagPixelsBelowLinesPropertyInfo), '("pixelsBelowLinesSet", Gtk.TextTag.TextTagPixelsBelowLinesSetPropertyInfo), '("pixelsInsideWrap", Gtk.TextTag.TextTagPixelsInsideWrapPropertyInfo), '("pixelsInsideWrapSet", Gtk.TextTag.TextTagPixelsInsideWrapSetPropertyInfo), '("rightMargin", Gtk.TextTag.TextTagRightMarginPropertyInfo), '("rightMarginSet", Gtk.TextTag.TextTagRightMarginSetPropertyInfo), '("rise", Gtk.TextTag.TextTagRisePropertyInfo), '("riseSet", Gtk.TextTag.TextTagRiseSetPropertyInfo), '("scale", Gtk.TextTag.TextTagScalePropertyInfo), '("scaleSet", Gtk.TextTag.TextTagScaleSetPropertyInfo), '("size", Gtk.TextTag.TextTagSizePropertyInfo), '("sizePoints", Gtk.TextTag.TextTagSizePointsPropertyInfo), '("sizeSet", Gtk.TextTag.TextTagSizeSetPropertyInfo), '("stretch", Gtk.TextTag.TextTagStretchPropertyInfo), '("stretchSet", Gtk.TextTag.TextTagStretchSetPropertyInfo), '("strikethrough", Gtk.TextTag.TextTagStrikethroughPropertyInfo), '("strikethroughRgba", Gtk.TextTag.TextTagStrikethroughRgbaPropertyInfo), '("strikethroughRgbaSet", Gtk.TextTag.TextTagStrikethroughRgbaSetPropertyInfo), '("strikethroughSet", Gtk.TextTag.TextTagStrikethroughSetPropertyInfo), '("style", Gtk.TextTag.TextTagStylePropertyInfo), '("styleSet", Gtk.TextTag.TextTagStyleSetPropertyInfo), '("tabs", Gtk.TextTag.TextTagTabsPropertyInfo), '("tabsSet", Gtk.TextTag.TextTagTabsSetPropertyInfo), '("underline", Gtk.TextTag.TextTagUnderlinePropertyInfo), '("underlineRgba", Gtk.TextTag.TextTagUnderlineRgbaPropertyInfo), '("underlineRgbaSet", Gtk.TextTag.TextTagUnderlineRgbaSetPropertyInfo), '("underlineSet", Gtk.TextTag.TextTagUnderlineSetPropertyInfo), '("variant", Gtk.TextTag.TextTagVariantPropertyInfo), '("variantSet", Gtk.TextTag.TextTagVariantSetPropertyInfo), '("weight", Gtk.TextTag.TextTagWeightPropertyInfo), '("weightSet", Gtk.TextTag.TextTagWeightSetPropertyInfo), '("wrapMode", Gtk.TextTag.TextTagWrapModePropertyInfo), '("wrapModeSet", Gtk.TextTag.TextTagWrapModeSetPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +tagDrawSpaces :: AttrLabelProxy "drawSpaces" +tagDrawSpaces = AttrLabelProxy + +tagDrawSpacesSet :: AttrLabelProxy "drawSpacesSet" +tagDrawSpacesSet = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Tag = TagSignalList +type TagSignalList = ('[ '("event", Gtk.TextTag.TextTagEventSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Tag::new +-- method type : Constructor +-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "tag name, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Tag"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_tag_new" gtk_source_tag_new :: + CString -> -- name : TBasicType TUTF8 + IO (Ptr Tag) + +{- | +Creates a 'GI.GtkSource.Objects.Tag.Tag'. Configure the tag using object arguments, +i.e. using @/g_object_set()/@. + +For usual cases, @/gtk_source_buffer_create_source_tag()/@ is more convenient to +use. + +/Since: 3.20/ +-} +tagNew :: + (B.CallStack.HasCallStack, MonadIO m) => + Maybe (T.Text) + {- ^ /@name@/: tag name, or 'Nothing'. -} + -> m Tag + {- ^ __Returns:__ a new 'GI.GtkSource.Objects.Tag.Tag'. -} +tagNew name = liftIO $ do + maybeName <- case name of + Nothing -> return nullPtr + Just jName -> do + jName' <- textToCString jName + return jName' + result <- gtk_source_tag_new maybeName + checkUnexpectedReturnNULL "tagNew" result + result' <- (wrapObject Tag) result + freeMem maybeName + return result' + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/GtkSource/Objects/Tag.hs-boot b/GI/GtkSource/Objects/Tag.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/Tag.hs-boot @@ -0,0 +1,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.Tag 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 Tag = Tag (ManagedPtr Tag) +instance GObject Tag where +class (GObject o, O.IsDescendantOf Tag o) => IsTag o +instance (GObject o, O.IsDescendantOf Tag o) => IsTag o +instance O.HasParentTypes Tag +#if ENABLE_OVERLOADING +data TagDrawSpacesPropertyInfo +#endif +#if ENABLE_OVERLOADING +data TagDrawSpacesSetPropertyInfo +#endif diff --git a/GI/GtkSource/Objects/View.hs b/GI/GtkSource/Objects/View.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/View.hs @@ -0,0 +1,4393 @@ + + +{- | +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.View + ( + +-- * Exported types + View(..) , + IsView , + toView , + noView , + + + -- * Methods +-- ** getAutoIndent #method:getAutoIndent# + +#if ENABLE_OVERLOADING + ViewGetAutoIndentMethodInfo , +#endif + viewGetAutoIndent , + + +-- ** getBackgroundPattern #method:getBackgroundPattern# + +#if ENABLE_OVERLOADING + ViewGetBackgroundPatternMethodInfo , +#endif + viewGetBackgroundPattern , + + +-- ** getCompletion #method:getCompletion# + +#if ENABLE_OVERLOADING + ViewGetCompletionMethodInfo , +#endif + viewGetCompletion , + + +-- ** getDrawSpaces #method:getDrawSpaces# + +#if ENABLE_OVERLOADING + ViewGetDrawSpacesMethodInfo , +#endif + viewGetDrawSpaces , + + +-- ** getGutter #method:getGutter# + +#if ENABLE_OVERLOADING + ViewGetGutterMethodInfo , +#endif + viewGetGutter , + + +-- ** getHighlightCurrentLine #method:getHighlightCurrentLine# + +#if ENABLE_OVERLOADING + ViewGetHighlightCurrentLineMethodInfo , +#endif + viewGetHighlightCurrentLine , + + +-- ** getIndentOnTab #method:getIndentOnTab# + +#if ENABLE_OVERLOADING + ViewGetIndentOnTabMethodInfo , +#endif + viewGetIndentOnTab , + + +-- ** getIndentWidth #method:getIndentWidth# + +#if ENABLE_OVERLOADING + ViewGetIndentWidthMethodInfo , +#endif + viewGetIndentWidth , + + +-- ** getInsertSpacesInsteadOfTabs #method:getInsertSpacesInsteadOfTabs# + +#if ENABLE_OVERLOADING + ViewGetInsertSpacesInsteadOfTabsMethodInfo, +#endif + viewGetInsertSpacesInsteadOfTabs , + + +-- ** getMarkAttributes #method:getMarkAttributes# + +#if ENABLE_OVERLOADING + ViewGetMarkAttributesMethodInfo , +#endif + viewGetMarkAttributes , + + +-- ** getRightMarginPosition #method:getRightMarginPosition# + +#if ENABLE_OVERLOADING + ViewGetRightMarginPositionMethodInfo , +#endif + viewGetRightMarginPosition , + + +-- ** getShowLineMarks #method:getShowLineMarks# + +#if ENABLE_OVERLOADING + ViewGetShowLineMarksMethodInfo , +#endif + viewGetShowLineMarks , + + +-- ** getShowLineNumbers #method:getShowLineNumbers# + +#if ENABLE_OVERLOADING + ViewGetShowLineNumbersMethodInfo , +#endif + viewGetShowLineNumbers , + + +-- ** getShowRightMargin #method:getShowRightMargin# + +#if ENABLE_OVERLOADING + ViewGetShowRightMarginMethodInfo , +#endif + viewGetShowRightMargin , + + +-- ** getSmartBackspace #method:getSmartBackspace# + +#if ENABLE_OVERLOADING + ViewGetSmartBackspaceMethodInfo , +#endif + viewGetSmartBackspace , + + +-- ** getSmartHomeEnd #method:getSmartHomeEnd# + +#if ENABLE_OVERLOADING + ViewGetSmartHomeEndMethodInfo , +#endif + viewGetSmartHomeEnd , + + +-- ** getSpaceDrawer #method:getSpaceDrawer# + +#if ENABLE_OVERLOADING + ViewGetSpaceDrawerMethodInfo , +#endif + viewGetSpaceDrawer , + + +-- ** getTabWidth #method:getTabWidth# + +#if ENABLE_OVERLOADING + ViewGetTabWidthMethodInfo , +#endif + viewGetTabWidth , + + +-- ** getVisualColumn #method:getVisualColumn# + +#if ENABLE_OVERLOADING + ViewGetVisualColumnMethodInfo , +#endif + viewGetVisualColumn , + + +-- ** indentLines #method:indentLines# + +#if ENABLE_OVERLOADING + ViewIndentLinesMethodInfo , +#endif + viewIndentLines , + + +-- ** new #method:new# + + viewNew , + + +-- ** newWithBuffer #method:newWithBuffer# + + viewNewWithBuffer , + + +-- ** setAutoIndent #method:setAutoIndent# + +#if ENABLE_OVERLOADING + ViewSetAutoIndentMethodInfo , +#endif + viewSetAutoIndent , + + +-- ** setBackgroundPattern #method:setBackgroundPattern# + +#if ENABLE_OVERLOADING + ViewSetBackgroundPatternMethodInfo , +#endif + viewSetBackgroundPattern , + + +-- ** setDrawSpaces #method:setDrawSpaces# + +#if ENABLE_OVERLOADING + ViewSetDrawSpacesMethodInfo , +#endif + viewSetDrawSpaces , + + +-- ** setHighlightCurrentLine #method:setHighlightCurrentLine# + +#if ENABLE_OVERLOADING + ViewSetHighlightCurrentLineMethodInfo , +#endif + viewSetHighlightCurrentLine , + + +-- ** setIndentOnTab #method:setIndentOnTab# + +#if ENABLE_OVERLOADING + ViewSetIndentOnTabMethodInfo , +#endif + viewSetIndentOnTab , + + +-- ** setIndentWidth #method:setIndentWidth# + +#if ENABLE_OVERLOADING + ViewSetIndentWidthMethodInfo , +#endif + viewSetIndentWidth , + + +-- ** setInsertSpacesInsteadOfTabs #method:setInsertSpacesInsteadOfTabs# + +#if ENABLE_OVERLOADING + ViewSetInsertSpacesInsteadOfTabsMethodInfo, +#endif + viewSetInsertSpacesInsteadOfTabs , + + +-- ** setMarkAttributes #method:setMarkAttributes# + +#if ENABLE_OVERLOADING + ViewSetMarkAttributesMethodInfo , +#endif + viewSetMarkAttributes , + + +-- ** setRightMarginPosition #method:setRightMarginPosition# + +#if ENABLE_OVERLOADING + ViewSetRightMarginPositionMethodInfo , +#endif + viewSetRightMarginPosition , + + +-- ** setShowLineMarks #method:setShowLineMarks# + +#if ENABLE_OVERLOADING + ViewSetShowLineMarksMethodInfo , +#endif + viewSetShowLineMarks , + + +-- ** setShowLineNumbers #method:setShowLineNumbers# + +#if ENABLE_OVERLOADING + ViewSetShowLineNumbersMethodInfo , +#endif + viewSetShowLineNumbers , + + +-- ** setShowRightMargin #method:setShowRightMargin# + +#if ENABLE_OVERLOADING + ViewSetShowRightMarginMethodInfo , +#endif + viewSetShowRightMargin , + + +-- ** setSmartBackspace #method:setSmartBackspace# + +#if ENABLE_OVERLOADING + ViewSetSmartBackspaceMethodInfo , +#endif + viewSetSmartBackspace , + + +-- ** setSmartHomeEnd #method:setSmartHomeEnd# + +#if ENABLE_OVERLOADING + ViewSetSmartHomeEndMethodInfo , +#endif + viewSetSmartHomeEnd , + + +-- ** setTabWidth #method:setTabWidth# + +#if ENABLE_OVERLOADING + ViewSetTabWidthMethodInfo , +#endif + viewSetTabWidth , + + +-- ** unindentLines #method:unindentLines# + +#if ENABLE_OVERLOADING + ViewUnindentLinesMethodInfo , +#endif + viewUnindentLines , + + + + + -- * Properties +-- ** autoIndent #attr:autoIndent# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + ViewAutoIndentPropertyInfo , +#endif + constructViewAutoIndent , + getViewAutoIndent , + setViewAutoIndent , +#if ENABLE_OVERLOADING + viewAutoIndent , +#endif + + +-- ** backgroundPattern #attr:backgroundPattern# +{- | Draw a specific background pattern on the view. + +/Since: 3.16/ +-} +#if ENABLE_OVERLOADING + ViewBackgroundPatternPropertyInfo , +#endif + constructViewBackgroundPattern , + getViewBackgroundPattern , + setViewBackgroundPattern , +#if ENABLE_OVERLOADING + viewBackgroundPattern , +#endif + + +-- ** completion #attr:completion# +{- | The completion object associated with the view +-} +#if ENABLE_OVERLOADING + ViewCompletionPropertyInfo , +#endif + getViewCompletion , +#if ENABLE_OVERLOADING + viewCompletion , +#endif + + +-- ** drawSpaces #attr:drawSpaces# +{- | Set if and how the spaces should be visualized. + +For a finer-grained method, there is also the GtkSourceTag\'s +'GI.GtkSource.Objects.Tag.Tag':@/draw-spaces/@ property. + +/Since: 2.4/ +-} +#if ENABLE_OVERLOADING + ViewDrawSpacesPropertyInfo , +#endif + constructViewDrawSpaces , + getViewDrawSpaces , + setViewDrawSpaces , +#if ENABLE_OVERLOADING + viewDrawSpaces , +#endif + + +-- ** highlightCurrentLine #attr:highlightCurrentLine# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + ViewHighlightCurrentLinePropertyInfo , +#endif + constructViewHighlightCurrentLine , + getViewHighlightCurrentLine , + setViewHighlightCurrentLine , +#if ENABLE_OVERLOADING + viewHighlightCurrentLine , +#endif + + +-- ** indentOnTab #attr:indentOnTab# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + ViewIndentOnTabPropertyInfo , +#endif + constructViewIndentOnTab , + getViewIndentOnTab , + setViewIndentOnTab , +#if ENABLE_OVERLOADING + viewIndentOnTab , +#endif + + +-- ** indentWidth #attr:indentWidth# +{- | Width of an indentation step expressed in number of spaces. +-} +#if ENABLE_OVERLOADING + ViewIndentWidthPropertyInfo , +#endif + constructViewIndentWidth , + getViewIndentWidth , + setViewIndentWidth , +#if ENABLE_OVERLOADING + viewIndentWidth , +#endif + + +-- ** insertSpacesInsteadOfTabs #attr:insertSpacesInsteadOfTabs# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + ViewInsertSpacesInsteadOfTabsPropertyInfo, +#endif + constructViewInsertSpacesInsteadOfTabs , + getViewInsertSpacesInsteadOfTabs , + setViewInsertSpacesInsteadOfTabs , +#if ENABLE_OVERLOADING + viewInsertSpacesInsteadOfTabs , +#endif + + +-- ** rightMarginPosition #attr:rightMarginPosition# +{- | Position of the right margin. +-} +#if ENABLE_OVERLOADING + ViewRightMarginPositionPropertyInfo , +#endif + constructViewRightMarginPosition , + getViewRightMarginPosition , + setViewRightMarginPosition , +#if ENABLE_OVERLOADING + viewRightMarginPosition , +#endif + + +-- ** showLineMarks #attr:showLineMarks# +{- | Whether to display line mark pixbufs +-} +#if ENABLE_OVERLOADING + ViewShowLineMarksPropertyInfo , +#endif + constructViewShowLineMarks , + getViewShowLineMarks , + setViewShowLineMarks , +#if ENABLE_OVERLOADING + viewShowLineMarks , +#endif + + +-- ** showLineNumbers #attr:showLineNumbers# +{- | Whether to display line numbers +-} +#if ENABLE_OVERLOADING + ViewShowLineNumbersPropertyInfo , +#endif + constructViewShowLineNumbers , + getViewShowLineNumbers , + setViewShowLineNumbers , +#if ENABLE_OVERLOADING + viewShowLineNumbers , +#endif + + +-- ** showRightMargin #attr:showRightMargin# +{- | Whether to display the right margin. +-} +#if ENABLE_OVERLOADING + ViewShowRightMarginPropertyInfo , +#endif + constructViewShowRightMargin , + getViewShowRightMargin , + setViewShowRightMargin , +#if ENABLE_OVERLOADING + viewShowRightMargin , +#endif + + +-- ** smartBackspace #attr:smartBackspace# +{- | Whether smart Backspace should be used. + +/Since: 3.18/ +-} +#if ENABLE_OVERLOADING + ViewSmartBackspacePropertyInfo , +#endif + constructViewSmartBackspace , + getViewSmartBackspace , + setViewSmartBackspace , +#if ENABLE_OVERLOADING + viewSmartBackspace , +#endif + + +-- ** smartHomeEnd #attr:smartHomeEnd# +{- | Set the behavior of the HOME and END keys. + +/Since: 2.0/ +-} +#if ENABLE_OVERLOADING + ViewSmartHomeEndPropertyInfo , +#endif + constructViewSmartHomeEnd , + getViewSmartHomeEnd , + setViewSmartHomeEnd , +#if ENABLE_OVERLOADING + viewSmartHomeEnd , +#endif + + +-- ** spaceDrawer #attr:spaceDrawer# +{- | The 'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer' object associated with the view. + +/Since: 3.24/ +-} +#if ENABLE_OVERLOADING + ViewSpaceDrawerPropertyInfo , +#endif + getViewSpaceDrawer , +#if ENABLE_OVERLOADING + viewSpaceDrawer , +#endif + + +-- ** tabWidth #attr:tabWidth# +{- | Width of a tab character expressed in number of spaces. +-} +#if ENABLE_OVERLOADING + ViewTabWidthPropertyInfo , +#endif + constructViewTabWidth , + getViewTabWidth , + setViewTabWidth , +#if ENABLE_OVERLOADING + viewTabWidth , +#endif + + + + + -- * Signals +-- ** changeCase #signal:changeCase# + + C_ViewChangeCaseCallback , + ViewChangeCaseCallback , +#if ENABLE_OVERLOADING + ViewChangeCaseSignalInfo , +#endif + afterViewChangeCase , + genClosure_ViewChangeCase , + mk_ViewChangeCaseCallback , + noViewChangeCaseCallback , + onViewChangeCase , + wrap_ViewChangeCaseCallback , + + +-- ** changeNumber #signal:changeNumber# + + C_ViewChangeNumberCallback , + ViewChangeNumberCallback , +#if ENABLE_OVERLOADING + ViewChangeNumberSignalInfo , +#endif + afterViewChangeNumber , + genClosure_ViewChangeNumber , + mk_ViewChangeNumberCallback , + noViewChangeNumberCallback , + onViewChangeNumber , + wrap_ViewChangeNumberCallback , + + +-- ** joinLines #signal:joinLines# + + C_ViewJoinLinesCallback , + ViewJoinLinesCallback , +#if ENABLE_OVERLOADING + ViewJoinLinesSignalInfo , +#endif + afterViewJoinLines , + genClosure_ViewJoinLines , + mk_ViewJoinLinesCallback , + noViewJoinLinesCallback , + onViewJoinLines , + wrap_ViewJoinLinesCallback , + + +-- ** lineMarkActivated #signal:lineMarkActivated# + + C_ViewLineMarkActivatedCallback , + ViewLineMarkActivatedCallback , +#if ENABLE_OVERLOADING + ViewLineMarkActivatedSignalInfo , +#endif + afterViewLineMarkActivated , + genClosure_ViewLineMarkActivated , + mk_ViewLineMarkActivatedCallback , + noViewLineMarkActivatedCallback , + onViewLineMarkActivated , + wrap_ViewLineMarkActivatedCallback , + + +-- ** moveLines #signal:moveLines# + + C_ViewMoveLinesCallback , + ViewMoveLinesCallback , +#if ENABLE_OVERLOADING + ViewMoveLinesSignalInfo , +#endif + afterViewMoveLines , + genClosure_ViewMoveLines , + mk_ViewMoveLinesCallback , + noViewMoveLinesCallback , + onViewMoveLines , + wrap_ViewMoveLinesCallback , + + +-- ** moveToMatchingBracket #signal:moveToMatchingBracket# + + C_ViewMoveToMatchingBracketCallback , + ViewMoveToMatchingBracketCallback , +#if ENABLE_OVERLOADING + ViewMoveToMatchingBracketSignalInfo , +#endif + afterViewMoveToMatchingBracket , + genClosure_ViewMoveToMatchingBracket , + mk_ViewMoveToMatchingBracketCallback , + noViewMoveToMatchingBracketCallback , + onViewMoveToMatchingBracket , + wrap_ViewMoveToMatchingBracketCallback , + + +-- ** moveWords #signal:moveWords# + + C_ViewMoveWordsCallback , + ViewMoveWordsCallback , +#if ENABLE_OVERLOADING + ViewMoveWordsSignalInfo , +#endif + afterViewMoveWords , + genClosure_ViewMoveWords , + mk_ViewMoveWordsCallback , + noViewMoveWordsCallback , + onViewMoveWords , + wrap_ViewMoveWordsCallback , + + +-- ** redo #signal:redo# + + C_ViewRedoCallback , + ViewRedoCallback , +#if ENABLE_OVERLOADING + ViewRedoSignalInfo , +#endif + afterViewRedo , + genClosure_ViewRedo , + mk_ViewRedoCallback , + noViewRedoCallback , + onViewRedo , + wrap_ViewRedoCallback , + + +-- ** showCompletion #signal:showCompletion# + + C_ViewShowCompletionCallback , + ViewShowCompletionCallback , +#if ENABLE_OVERLOADING + ViewShowCompletionSignalInfo , +#endif + afterViewShowCompletion , + genClosure_ViewShowCompletion , + mk_ViewShowCompletionCallback , + noViewShowCompletionCallback , + onViewShowCompletion , + wrap_ViewShowCompletionCallback , + + +-- ** smartHomeEnd #signal:smartHomeEnd# + + C_ViewSmartHomeEndCallback , + ViewSmartHomeEndCallback , +#if ENABLE_OVERLOADING + ViewSmartHomeEndSignalInfo , +#endif + afterViewSmartHomeEnd , + genClosure_ViewSmartHomeEnd , + mk_ViewSmartHomeEndCallback , + noViewSmartHomeEndCallback , + onViewSmartHomeEnd , + wrap_ViewSmartHomeEndCallback , + + +-- ** undo #signal:undo# + + C_ViewUndoCallback , + ViewUndoCallback , +#if ENABLE_OVERLOADING + ViewUndoSignalInfo , +#endif + afterViewUndo , + genClosure_ViewUndo , + mk_ViewUndoCallback , + noViewUndoCallback , + onViewUndo , + wrap_ViewUndoCallback , + + + + + ) 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.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gdk.Unions.Event as Gdk.Event +import qualified GI.Gtk.Enums as Gtk.Enums +import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable +import qualified GI.Gtk.Interfaces.Scrollable as Gtk.Scrollable +import qualified GI.Gtk.Objects.Container as Gtk.Container +import qualified GI.Gtk.Objects.TextView as Gtk.TextView +import qualified GI.Gtk.Objects.Widget as Gtk.Widget +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.Objects.Buffer as GtkSource.Buffer +import {-# SOURCE #-} qualified GI.GtkSource.Objects.Completion as GtkSource.Completion +import {-# SOURCE #-} qualified GI.GtkSource.Objects.Gutter as GtkSource.Gutter +import {-# SOURCE #-} qualified GI.GtkSource.Objects.MarkAttributes as GtkSource.MarkAttributes +import {-# SOURCE #-} qualified GI.GtkSource.Objects.SpaceDrawer as GtkSource.SpaceDrawer + +-- | Memory-managed wrapper type. +newtype View = View (ManagedPtr View) +foreign import ccall "gtk_source_view_get_type" + c_gtk_source_view_get_type :: IO GType + +instance GObject View where + gobjectType = c_gtk_source_view_get_type + + +-- | Type class for types which can be safely cast to `View`, for instance with `toView`. +class (GObject o, O.IsDescendantOf View o) => IsView o +instance (GObject o, O.IsDescendantOf View o) => IsView o + +instance O.HasParentTypes View +type instance O.ParentTypes View = '[Gtk.TextView.TextView, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable, Gtk.Scrollable.Scrollable] + +-- | Cast to `View`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toView :: (MonadIO m, IsView o) => o -> m View +toView = liftIO . unsafeCastTo View + +-- | A convenience alias for `Nothing` :: `Maybe` `View`. +noView :: Maybe View +noView = Nothing + +#if ENABLE_OVERLOADING +type family ResolveViewMethod (t :: Symbol) (o :: *) :: * where + ResolveViewMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo + ResolveViewMethod "add" o = Gtk.Container.ContainerAddMethodInfo + ResolveViewMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo + ResolveViewMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo + ResolveViewMethod "addChildAtAnchor" o = Gtk.TextView.TextViewAddChildAtAnchorMethodInfo + ResolveViewMethod "addChildInWindow" o = Gtk.TextView.TextViewAddChildInWindowMethodInfo + ResolveViewMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo + ResolveViewMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo + ResolveViewMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo + ResolveViewMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo + ResolveViewMethod "backwardDisplayLine" o = Gtk.TextView.TextViewBackwardDisplayLineMethodInfo + ResolveViewMethod "backwardDisplayLineStart" o = Gtk.TextView.TextViewBackwardDisplayLineStartMethodInfo + ResolveViewMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveViewMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveViewMethod "bufferToWindowCoords" o = Gtk.TextView.TextViewBufferToWindowCoordsMethodInfo + ResolveViewMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo + ResolveViewMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo + ResolveViewMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo + ResolveViewMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo + ResolveViewMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo + ResolveViewMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo + ResolveViewMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo + ResolveViewMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo + ResolveViewMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo + ResolveViewMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo + ResolveViewMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo + ResolveViewMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo + ResolveViewMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo + ResolveViewMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo + ResolveViewMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo + ResolveViewMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo + ResolveViewMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo + ResolveViewMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo + ResolveViewMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo + ResolveViewMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo + ResolveViewMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo + ResolveViewMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo + ResolveViewMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo + ResolveViewMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo + ResolveViewMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo + ResolveViewMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo + ResolveViewMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo + ResolveViewMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo + ResolveViewMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo + ResolveViewMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo + ResolveViewMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo + ResolveViewMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo + ResolveViewMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo + ResolveViewMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo + ResolveViewMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo + ResolveViewMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo + ResolveViewMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo + ResolveViewMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo + ResolveViewMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo + ResolveViewMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo + ResolveViewMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo + ResolveViewMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo + ResolveViewMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo + ResolveViewMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo + ResolveViewMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo + ResolveViewMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo + ResolveViewMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo + ResolveViewMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo + ResolveViewMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo + ResolveViewMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo + ResolveViewMethod "event" o = Gtk.Widget.WidgetEventMethodInfo + ResolveViewMethod "forall" o = Gtk.Container.ContainerForallMethodInfo + ResolveViewMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveViewMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo + ResolveViewMethod "forwardDisplayLine" o = Gtk.TextView.TextViewForwardDisplayLineMethodInfo + ResolveViewMethod "forwardDisplayLineEnd" o = Gtk.TextView.TextViewForwardDisplayLineEndMethodInfo + ResolveViewMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo + ResolveViewMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveViewMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveViewMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo + ResolveViewMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo + ResolveViewMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo + ResolveViewMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo + ResolveViewMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo + ResolveViewMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo + ResolveViewMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo + ResolveViewMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo + ResolveViewMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo + ResolveViewMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo + ResolveViewMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo + ResolveViewMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo + ResolveViewMethod "imContextFilterKeypress" o = Gtk.TextView.TextViewImContextFilterKeypressMethodInfo + ResolveViewMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo + ResolveViewMethod "indentLines" o = ViewIndentLinesMethodInfo + ResolveViewMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo + ResolveViewMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo + ResolveViewMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo + ResolveViewMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo + ResolveViewMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo + ResolveViewMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo + ResolveViewMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo + ResolveViewMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveViewMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo + ResolveViewMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo + ResolveViewMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo + ResolveViewMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo + ResolveViewMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo + ResolveViewMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo + ResolveViewMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo + ResolveViewMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo + ResolveViewMethod "map" o = Gtk.Widget.WidgetMapMethodInfo + ResolveViewMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo + ResolveViewMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo + ResolveViewMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo + ResolveViewMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo + ResolveViewMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo + ResolveViewMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo + ResolveViewMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo + ResolveViewMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo + ResolveViewMethod "moveChild" o = Gtk.TextView.TextViewMoveChildMethodInfo + ResolveViewMethod "moveMarkOnscreen" o = Gtk.TextView.TextViewMoveMarkOnscreenMethodInfo + ResolveViewMethod "moveVisually" o = Gtk.TextView.TextViewMoveVisuallyMethodInfo + ResolveViewMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveViewMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveViewMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo + ResolveViewMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo + ResolveViewMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo + ResolveViewMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo + ResolveViewMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo + ResolveViewMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo + ResolveViewMethod "path" o = Gtk.Widget.WidgetPathMethodInfo + ResolveViewMethod "placeCursorOnscreen" o = Gtk.TextView.TextViewPlaceCursorOnscreenMethodInfo + ResolveViewMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo + ResolveViewMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo + ResolveViewMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo + ResolveViewMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo + ResolveViewMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo + ResolveViewMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo + ResolveViewMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo + ResolveViewMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo + ResolveViewMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo + ResolveViewMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveViewMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveViewMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo + ResolveViewMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo + ResolveViewMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo + ResolveViewMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo + ResolveViewMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo + ResolveViewMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo + ResolveViewMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo + ResolveViewMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo + ResolveViewMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo + ResolveViewMethod "resetCursorBlink" o = Gtk.TextView.TextViewResetCursorBlinkMethodInfo + ResolveViewMethod "resetImContext" o = Gtk.TextView.TextViewResetImContextMethodInfo + ResolveViewMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo + ResolveViewMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo + ResolveViewMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo + ResolveViewMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveViewMethod "scrollMarkOnscreen" o = Gtk.TextView.TextViewScrollMarkOnscreenMethodInfo + ResolveViewMethod "scrollToIter" o = Gtk.TextView.TextViewScrollToIterMethodInfo + ResolveViewMethod "scrollToMark" o = Gtk.TextView.TextViewScrollToMarkMethodInfo + ResolveViewMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo + ResolveViewMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo + ResolveViewMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo + ResolveViewMethod "show" o = Gtk.Widget.WidgetShowMethodInfo + ResolveViewMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo + ResolveViewMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo + ResolveViewMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo + ResolveViewMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo + ResolveViewMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo + ResolveViewMethod "startsDisplayLine" o = Gtk.TextView.TextViewStartsDisplayLineMethodInfo + ResolveViewMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveViewMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveViewMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo + ResolveViewMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo + ResolveViewMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo + ResolveViewMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveViewMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo + ResolveViewMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo + ResolveViewMethod "unindentLines" o = ViewUnindentLinesMethodInfo + ResolveViewMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo + ResolveViewMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo + ResolveViewMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo + ResolveViewMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveViewMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo + ResolveViewMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo + ResolveViewMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo + ResolveViewMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveViewMethod "windowToBufferCoords" o = Gtk.TextView.TextViewWindowToBufferCoordsMethodInfo + ResolveViewMethod "getAcceptsTab" o = Gtk.TextView.TextViewGetAcceptsTabMethodInfo + ResolveViewMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo + ResolveViewMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo + ResolveViewMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo + ResolveViewMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo + ResolveViewMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo + ResolveViewMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo + ResolveViewMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo + ResolveViewMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo + ResolveViewMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo + ResolveViewMethod "getAutoIndent" o = ViewGetAutoIndentMethodInfo + ResolveViewMethod "getBackgroundPattern" o = ViewGetBackgroundPatternMethodInfo + ResolveViewMethod "getBorder" o = Gtk.Scrollable.ScrollableGetBorderMethodInfo + ResolveViewMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo + ResolveViewMethod "getBorderWindowSize" o = Gtk.TextView.TextViewGetBorderWindowSizeMethodInfo + ResolveViewMethod "getBottomMargin" o = Gtk.TextView.TextViewGetBottomMarginMethodInfo + ResolveViewMethod "getBuffer" o = Gtk.TextView.TextViewGetBufferMethodInfo + ResolveViewMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo + ResolveViewMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo + ResolveViewMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo + ResolveViewMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo + ResolveViewMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo + ResolveViewMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo + ResolveViewMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo + ResolveViewMethod "getCompletion" o = ViewGetCompletionMethodInfo + ResolveViewMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo + ResolveViewMethod "getCursorLocations" o = Gtk.TextView.TextViewGetCursorLocationsMethodInfo + ResolveViewMethod "getCursorVisible" o = Gtk.TextView.TextViewGetCursorVisibleMethodInfo + ResolveViewMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveViewMethod "getDefaultAttributes" o = Gtk.TextView.TextViewGetDefaultAttributesMethodInfo + ResolveViewMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo + ResolveViewMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo + ResolveViewMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo + ResolveViewMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo + ResolveViewMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo + ResolveViewMethod "getDrawSpaces" o = ViewGetDrawSpacesMethodInfo + ResolveViewMethod "getEditable" o = Gtk.TextView.TextViewGetEditableMethodInfo + ResolveViewMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo + ResolveViewMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo + ResolveViewMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo + ResolveViewMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo + ResolveViewMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo + ResolveViewMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo + ResolveViewMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo + ResolveViewMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo + ResolveViewMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo + ResolveViewMethod "getGutter" o = ViewGetGutterMethodInfo + ResolveViewMethod "getHadjustment" o = Gtk.TextView.TextViewGetHadjustmentMethodInfo + ResolveViewMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo + ResolveViewMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo + ResolveViewMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo + ResolveViewMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo + ResolveViewMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo + ResolveViewMethod "getHighlightCurrentLine" o = ViewGetHighlightCurrentLineMethodInfo + ResolveViewMethod "getHscrollPolicy" o = Gtk.Scrollable.ScrollableGetHscrollPolicyMethodInfo + ResolveViewMethod "getIndent" o = Gtk.TextView.TextViewGetIndentMethodInfo + ResolveViewMethod "getIndentOnTab" o = ViewGetIndentOnTabMethodInfo + ResolveViewMethod "getIndentWidth" o = ViewGetIndentWidthMethodInfo + ResolveViewMethod "getInputHints" o = Gtk.TextView.TextViewGetInputHintsMethodInfo + ResolveViewMethod "getInputPurpose" o = Gtk.TextView.TextViewGetInputPurposeMethodInfo + ResolveViewMethod "getInsertSpacesInsteadOfTabs" o = ViewGetInsertSpacesInsteadOfTabsMethodInfo + ResolveViewMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo + ResolveViewMethod "getIterAtLocation" o = Gtk.TextView.TextViewGetIterAtLocationMethodInfo + ResolveViewMethod "getIterAtPosition" o = Gtk.TextView.TextViewGetIterAtPositionMethodInfo + ResolveViewMethod "getIterLocation" o = Gtk.TextView.TextViewGetIterLocationMethodInfo + ResolveViewMethod "getJustification" o = Gtk.TextView.TextViewGetJustificationMethodInfo + ResolveViewMethod "getLeftMargin" o = Gtk.TextView.TextViewGetLeftMarginMethodInfo + ResolveViewMethod "getLineAtY" o = Gtk.TextView.TextViewGetLineAtYMethodInfo + ResolveViewMethod "getLineYrange" o = Gtk.TextView.TextViewGetLineYrangeMethodInfo + ResolveViewMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo + ResolveViewMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo + ResolveViewMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo + ResolveViewMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo + ResolveViewMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo + ResolveViewMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo + ResolveViewMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo + ResolveViewMethod "getMarkAttributes" o = ViewGetMarkAttributesMethodInfo + ResolveViewMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo + ResolveViewMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo + ResolveViewMethod "getMonospace" o = Gtk.TextView.TextViewGetMonospaceMethodInfo + ResolveViewMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo + ResolveViewMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo + ResolveViewMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo + ResolveViewMethod "getOverwrite" o = Gtk.TextView.TextViewGetOverwriteMethodInfo + ResolveViewMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo + ResolveViewMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo + ResolveViewMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo + ResolveViewMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo + ResolveViewMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo + ResolveViewMethod "getPixelsAboveLines" o = Gtk.TextView.TextViewGetPixelsAboveLinesMethodInfo + ResolveViewMethod "getPixelsBelowLines" o = Gtk.TextView.TextViewGetPixelsBelowLinesMethodInfo + ResolveViewMethod "getPixelsInsideWrap" o = Gtk.TextView.TextViewGetPixelsInsideWrapMethodInfo + ResolveViewMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo + ResolveViewMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo + ResolveViewMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo + ResolveViewMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo + ResolveViewMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo + ResolveViewMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo + ResolveViewMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo + ResolveViewMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveViewMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveViewMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo + ResolveViewMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo + ResolveViewMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo + ResolveViewMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo + ResolveViewMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo + ResolveViewMethod "getRightMargin" o = Gtk.TextView.TextViewGetRightMarginMethodInfo + ResolveViewMethod "getRightMarginPosition" o = ViewGetRightMarginPositionMethodInfo + ResolveViewMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo + ResolveViewMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo + ResolveViewMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo + ResolveViewMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo + ResolveViewMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo + ResolveViewMethod "getShowLineMarks" o = ViewGetShowLineMarksMethodInfo + ResolveViewMethod "getShowLineNumbers" o = ViewGetShowLineNumbersMethodInfo + ResolveViewMethod "getShowRightMargin" o = ViewGetShowRightMarginMethodInfo + ResolveViewMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo + ResolveViewMethod "getSmartBackspace" o = ViewGetSmartBackspaceMethodInfo + ResolveViewMethod "getSmartHomeEnd" o = ViewGetSmartHomeEndMethodInfo + ResolveViewMethod "getSpaceDrawer" o = ViewGetSpaceDrawerMethodInfo + ResolveViewMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo + ResolveViewMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo + ResolveViewMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo + ResolveViewMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo + ResolveViewMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo + ResolveViewMethod "getTabWidth" o = ViewGetTabWidthMethodInfo + ResolveViewMethod "getTabs" o = Gtk.TextView.TextViewGetTabsMethodInfo + ResolveViewMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo + ResolveViewMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo + ResolveViewMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo + ResolveViewMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo + ResolveViewMethod "getTopMargin" o = Gtk.TextView.TextViewGetTopMarginMethodInfo + ResolveViewMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo + ResolveViewMethod "getVadjustment" o = Gtk.TextView.TextViewGetVadjustmentMethodInfo + ResolveViewMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo + ResolveViewMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo + ResolveViewMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo + ResolveViewMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo + ResolveViewMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo + ResolveViewMethod "getVisibleRect" o = Gtk.TextView.TextViewGetVisibleRectMethodInfo + ResolveViewMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo + ResolveViewMethod "getVisualColumn" o = ViewGetVisualColumnMethodInfo + ResolveViewMethod "getVscrollPolicy" o = Gtk.Scrollable.ScrollableGetVscrollPolicyMethodInfo + ResolveViewMethod "getWindow" o = Gtk.TextView.TextViewGetWindowMethodInfo + ResolveViewMethod "getWindowType" o = Gtk.TextView.TextViewGetWindowTypeMethodInfo + ResolveViewMethod "getWrapMode" o = Gtk.TextView.TextViewGetWrapModeMethodInfo + ResolveViewMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo + ResolveViewMethod "setAcceptsTab" o = Gtk.TextView.TextViewSetAcceptsTabMethodInfo + ResolveViewMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo + ResolveViewMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo + ResolveViewMethod "setAutoIndent" o = ViewSetAutoIndentMethodInfo + ResolveViewMethod "setBackgroundPattern" o = ViewSetBackgroundPatternMethodInfo + ResolveViewMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo + ResolveViewMethod "setBorderWindowSize" o = Gtk.TextView.TextViewSetBorderWindowSizeMethodInfo + ResolveViewMethod "setBottomMargin" o = Gtk.TextView.TextViewSetBottomMarginMethodInfo + ResolveViewMethod "setBuffer" o = Gtk.TextView.TextViewSetBufferMethodInfo + ResolveViewMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo + ResolveViewMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo + ResolveViewMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo + ResolveViewMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo + ResolveViewMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo + ResolveViewMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo + ResolveViewMethod "setCursorVisible" o = Gtk.TextView.TextViewSetCursorVisibleMethodInfo + ResolveViewMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveViewMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo + ResolveViewMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo + ResolveViewMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo + ResolveViewMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo + ResolveViewMethod "setDrawSpaces" o = ViewSetDrawSpacesMethodInfo + ResolveViewMethod "setEditable" o = Gtk.TextView.TextViewSetEditableMethodInfo + ResolveViewMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo + ResolveViewMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo + ResolveViewMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo + ResolveViewMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo + ResolveViewMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo + ResolveViewMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo + ResolveViewMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo + ResolveViewMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo + ResolveViewMethod "setHadjustment" o = Gtk.Scrollable.ScrollableSetHadjustmentMethodInfo + ResolveViewMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo + ResolveViewMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo + ResolveViewMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo + ResolveViewMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo + ResolveViewMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo + ResolveViewMethod "setHighlightCurrentLine" o = ViewSetHighlightCurrentLineMethodInfo + ResolveViewMethod "setHscrollPolicy" o = Gtk.Scrollable.ScrollableSetHscrollPolicyMethodInfo + ResolveViewMethod "setIndent" o = Gtk.TextView.TextViewSetIndentMethodInfo + ResolveViewMethod "setIndentOnTab" o = ViewSetIndentOnTabMethodInfo + ResolveViewMethod "setIndentWidth" o = ViewSetIndentWidthMethodInfo + ResolveViewMethod "setInputHints" o = Gtk.TextView.TextViewSetInputHintsMethodInfo + ResolveViewMethod "setInputPurpose" o = Gtk.TextView.TextViewSetInputPurposeMethodInfo + ResolveViewMethod "setInsertSpacesInsteadOfTabs" o = ViewSetInsertSpacesInsteadOfTabsMethodInfo + ResolveViewMethod "setJustification" o = Gtk.TextView.TextViewSetJustificationMethodInfo + ResolveViewMethod "setLeftMargin" o = Gtk.TextView.TextViewSetLeftMarginMethodInfo + ResolveViewMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo + ResolveViewMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo + ResolveViewMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo + ResolveViewMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo + ResolveViewMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo + ResolveViewMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo + ResolveViewMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo + ResolveViewMethod "setMarkAttributes" o = ViewSetMarkAttributesMethodInfo + ResolveViewMethod "setMonospace" o = Gtk.TextView.TextViewSetMonospaceMethodInfo + ResolveViewMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo + ResolveViewMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo + ResolveViewMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo + ResolveViewMethod "setOverwrite" o = Gtk.TextView.TextViewSetOverwriteMethodInfo + ResolveViewMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo + ResolveViewMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo + ResolveViewMethod "setPixelsAboveLines" o = Gtk.TextView.TextViewSetPixelsAboveLinesMethodInfo + ResolveViewMethod "setPixelsBelowLines" o = Gtk.TextView.TextViewSetPixelsBelowLinesMethodInfo + ResolveViewMethod "setPixelsInsideWrap" o = Gtk.TextView.TextViewSetPixelsInsideWrapMethodInfo + ResolveViewMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveViewMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo + ResolveViewMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo + ResolveViewMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo + ResolveViewMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo + ResolveViewMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo + ResolveViewMethod "setRightMargin" o = Gtk.TextView.TextViewSetRightMarginMethodInfo + ResolveViewMethod "setRightMarginPosition" o = ViewSetRightMarginPositionMethodInfo + ResolveViewMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo + ResolveViewMethod "setShowLineMarks" o = ViewSetShowLineMarksMethodInfo + ResolveViewMethod "setShowLineNumbers" o = ViewSetShowLineNumbersMethodInfo + ResolveViewMethod "setShowRightMargin" o = ViewSetShowRightMarginMethodInfo + ResolveViewMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo + ResolveViewMethod "setSmartBackspace" o = ViewSetSmartBackspaceMethodInfo + ResolveViewMethod "setSmartHomeEnd" o = ViewSetSmartHomeEndMethodInfo + ResolveViewMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo + ResolveViewMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo + ResolveViewMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo + ResolveViewMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo + ResolveViewMethod "setTabWidth" o = ViewSetTabWidthMethodInfo + ResolveViewMethod "setTabs" o = Gtk.TextView.TextViewSetTabsMethodInfo + ResolveViewMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo + ResolveViewMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo + ResolveViewMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo + ResolveViewMethod "setTopMargin" o = Gtk.TextView.TextViewSetTopMarginMethodInfo + ResolveViewMethod "setVadjustment" o = Gtk.Scrollable.ScrollableSetVadjustmentMethodInfo + ResolveViewMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo + ResolveViewMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo + ResolveViewMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo + ResolveViewMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo + ResolveViewMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo + ResolveViewMethod "setVscrollPolicy" o = Gtk.Scrollable.ScrollableSetVscrollPolicyMethodInfo + ResolveViewMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo + ResolveViewMethod "setWrapMode" o = Gtk.TextView.TextViewSetWrapModeMethodInfo + ResolveViewMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveViewMethod t View, O.MethodInfo info View p) => OL.IsLabel t (View -> 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 View::change-case +{- | +Keybinding signal to change case of the text at the current cursor position. + +/Since: 3.16/ +-} +type ViewChangeCaseCallback = + GtkSource.Enums.ChangeCaseType + {- ^ /@caseType@/: the case to use -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ViewChangeCaseCallback`@. +noViewChangeCaseCallback :: Maybe ViewChangeCaseCallback +noViewChangeCaseCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_ViewChangeCaseCallback = + Ptr () -> -- object + CUInt -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_ViewChangeCaseCallback`. +foreign import ccall "wrapper" + mk_ViewChangeCaseCallback :: C_ViewChangeCaseCallback -> IO (FunPtr C_ViewChangeCaseCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_ViewChangeCase :: MonadIO m => ViewChangeCaseCallback -> m (GClosure C_ViewChangeCaseCallback) +genClosure_ViewChangeCase cb = liftIO $ do + let cb' = wrap_ViewChangeCaseCallback cb + mk_ViewChangeCaseCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `ViewChangeCaseCallback` into a `C_ViewChangeCaseCallback`. +wrap_ViewChangeCaseCallback :: + ViewChangeCaseCallback -> + C_ViewChangeCaseCallback +wrap_ViewChangeCaseCallback _cb _ caseType _ = do + let caseType' = (toEnum . fromIntegral) caseType + _cb caseType' + + +{- | +Connect a signal handler for the “@change-case@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' view #changeCase callback +@ +-} +onViewChangeCase :: (IsView a, MonadIO m) => a -> ViewChangeCaseCallback -> m SignalHandlerId +onViewChangeCase obj cb = liftIO $ do + let cb' = wrap_ViewChangeCaseCallback cb + cb'' <- mk_ViewChangeCaseCallback cb' + connectSignalFunPtr obj "change-case" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@change-case@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' view #changeCase callback +@ +-} +afterViewChangeCase :: (IsView a, MonadIO m) => a -> ViewChangeCaseCallback -> m SignalHandlerId +afterViewChangeCase obj cb = liftIO $ do + let cb' = wrap_ViewChangeCaseCallback cb + cb'' <- mk_ViewChangeCaseCallback cb' + connectSignalFunPtr obj "change-case" cb'' SignalConnectAfter + + +-- signal View::change-number +{- | +Keybinding signal to edit a number at the current cursor position. + +/Since: 3.16/ +-} +type ViewChangeNumberCallback = + Int32 + {- ^ /@count@/: the number to add to the number at the current position -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ViewChangeNumberCallback`@. +noViewChangeNumberCallback :: Maybe ViewChangeNumberCallback +noViewChangeNumberCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_ViewChangeNumberCallback = + Ptr () -> -- object + Int32 -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_ViewChangeNumberCallback`. +foreign import ccall "wrapper" + mk_ViewChangeNumberCallback :: C_ViewChangeNumberCallback -> IO (FunPtr C_ViewChangeNumberCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_ViewChangeNumber :: MonadIO m => ViewChangeNumberCallback -> m (GClosure C_ViewChangeNumberCallback) +genClosure_ViewChangeNumber cb = liftIO $ do + let cb' = wrap_ViewChangeNumberCallback cb + mk_ViewChangeNumberCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `ViewChangeNumberCallback` into a `C_ViewChangeNumberCallback`. +wrap_ViewChangeNumberCallback :: + ViewChangeNumberCallback -> + C_ViewChangeNumberCallback +wrap_ViewChangeNumberCallback _cb _ count _ = do + _cb count + + +{- | +Connect a signal handler for the “@change-number@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' view #changeNumber callback +@ +-} +onViewChangeNumber :: (IsView a, MonadIO m) => a -> ViewChangeNumberCallback -> m SignalHandlerId +onViewChangeNumber obj cb = liftIO $ do + let cb' = wrap_ViewChangeNumberCallback cb + cb'' <- mk_ViewChangeNumberCallback cb' + connectSignalFunPtr obj "change-number" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@change-number@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' view #changeNumber callback +@ +-} +afterViewChangeNumber :: (IsView a, MonadIO m) => a -> ViewChangeNumberCallback -> m SignalHandlerId +afterViewChangeNumber obj cb = liftIO $ do + let cb' = wrap_ViewChangeNumberCallback cb + cb'' <- mk_ViewChangeNumberCallback cb' + connectSignalFunPtr obj "change-number" cb'' SignalConnectAfter + + +-- signal View::join-lines +{- | +Keybinding signal to join the lines currently selected. + +/Since: 3.16/ +-} +type ViewJoinLinesCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ViewJoinLinesCallback`@. +noViewJoinLinesCallback :: Maybe ViewJoinLinesCallback +noViewJoinLinesCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_ViewJoinLinesCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_ViewJoinLinesCallback`. +foreign import ccall "wrapper" + mk_ViewJoinLinesCallback :: C_ViewJoinLinesCallback -> IO (FunPtr C_ViewJoinLinesCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_ViewJoinLines :: MonadIO m => ViewJoinLinesCallback -> m (GClosure C_ViewJoinLinesCallback) +genClosure_ViewJoinLines cb = liftIO $ do + let cb' = wrap_ViewJoinLinesCallback cb + mk_ViewJoinLinesCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `ViewJoinLinesCallback` into a `C_ViewJoinLinesCallback`. +wrap_ViewJoinLinesCallback :: + ViewJoinLinesCallback -> + C_ViewJoinLinesCallback +wrap_ViewJoinLinesCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@join-lines@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' view #joinLines callback +@ +-} +onViewJoinLines :: (IsView a, MonadIO m) => a -> ViewJoinLinesCallback -> m SignalHandlerId +onViewJoinLines obj cb = liftIO $ do + let cb' = wrap_ViewJoinLinesCallback cb + cb'' <- mk_ViewJoinLinesCallback cb' + connectSignalFunPtr obj "join-lines" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@join-lines@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' view #joinLines callback +@ +-} +afterViewJoinLines :: (IsView a, MonadIO m) => a -> ViewJoinLinesCallback -> m SignalHandlerId +afterViewJoinLines obj cb = liftIO $ do + let cb' = wrap_ViewJoinLinesCallback cb + cb'' <- mk_ViewJoinLinesCallback cb' + connectSignalFunPtr obj "join-lines" cb'' SignalConnectAfter + + +-- signal View::line-mark-activated +{- | +Emitted when a line mark has been activated (for instance when there +was a button press in the line marks gutter). You can use /@iter@/ to +determine on which line the activation took place. +-} +type ViewLineMarkActivatedCallback = + Gtk.TextIter.TextIter + {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter' -} + -> Gdk.Event.Event + {- ^ /@event@/: the 'GI.Gdk.Unions.Event.Event' that activated the event -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ViewLineMarkActivatedCallback`@. +noViewLineMarkActivatedCallback :: Maybe ViewLineMarkActivatedCallback +noViewLineMarkActivatedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_ViewLineMarkActivatedCallback = + Ptr () -> -- object + Ptr Gtk.TextIter.TextIter -> + Ptr Gdk.Event.Event -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_ViewLineMarkActivatedCallback`. +foreign import ccall "wrapper" + mk_ViewLineMarkActivatedCallback :: C_ViewLineMarkActivatedCallback -> IO (FunPtr C_ViewLineMarkActivatedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_ViewLineMarkActivated :: MonadIO m => ViewLineMarkActivatedCallback -> m (GClosure C_ViewLineMarkActivatedCallback) +genClosure_ViewLineMarkActivated cb = liftIO $ do + let cb' = wrap_ViewLineMarkActivatedCallback cb + mk_ViewLineMarkActivatedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `ViewLineMarkActivatedCallback` into a `C_ViewLineMarkActivatedCallback`. +wrap_ViewLineMarkActivatedCallback :: + ViewLineMarkActivatedCallback -> + C_ViewLineMarkActivatedCallback +wrap_ViewLineMarkActivatedCallback _cb _ iter event _ = do + B.ManagedPtr.withTransient Gtk.TextIter.TextIter iter $ \iter' -> do + B.ManagedPtr.withTransient Gdk.Event.Event event $ \event' -> do + _cb iter' event' + + +{- | +Connect a signal handler for the “@line-mark-activated@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' view #lineMarkActivated callback +@ +-} +onViewLineMarkActivated :: (IsView a, MonadIO m) => a -> ViewLineMarkActivatedCallback -> m SignalHandlerId +onViewLineMarkActivated obj cb = liftIO $ do + let cb' = wrap_ViewLineMarkActivatedCallback cb + cb'' <- mk_ViewLineMarkActivatedCallback cb' + connectSignalFunPtr obj "line-mark-activated" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@line-mark-activated@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' view #lineMarkActivated callback +@ +-} +afterViewLineMarkActivated :: (IsView a, MonadIO m) => a -> ViewLineMarkActivatedCallback -> m SignalHandlerId +afterViewLineMarkActivated obj cb = liftIO $ do + let cb' = wrap_ViewLineMarkActivatedCallback cb + cb'' <- mk_ViewLineMarkActivatedCallback cb' + connectSignalFunPtr obj "line-mark-activated" cb'' SignalConnectAfter + + +-- signal View::move-lines +{- | +The ::move-lines signal is a keybinding which gets emitted +when the user initiates moving a line. The default binding key +is Alt+Up\/Down arrow. And moves the currently selected lines, +or the current line by /@count@/. For the moment, only +/@count@/ of -1 or 1 is valid. + +The /@copy@/ parameter is deprecated, it has never been used by +GtkSourceView (the value is always 'False') and was buggy. + +/Since: 2.10/ +-} +type ViewMoveLinesCallback = + Bool + {- ^ /@copy@/: 'True' if the line should be copied, 'False' if it should be + moved. This parameter is deprecated and will be removed in a later + version, it should be always 'False'. -} + -> Int32 + {- ^ /@count@/: the number of lines to move over. Only 1 and -1 are + supported. -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ViewMoveLinesCallback`@. +noViewMoveLinesCallback :: Maybe ViewMoveLinesCallback +noViewMoveLinesCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_ViewMoveLinesCallback = + Ptr () -> -- object + CInt -> + Int32 -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_ViewMoveLinesCallback`. +foreign import ccall "wrapper" + mk_ViewMoveLinesCallback :: C_ViewMoveLinesCallback -> IO (FunPtr C_ViewMoveLinesCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_ViewMoveLines :: MonadIO m => ViewMoveLinesCallback -> m (GClosure C_ViewMoveLinesCallback) +genClosure_ViewMoveLines cb = liftIO $ do + let cb' = wrap_ViewMoveLinesCallback cb + mk_ViewMoveLinesCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `ViewMoveLinesCallback` into a `C_ViewMoveLinesCallback`. +wrap_ViewMoveLinesCallback :: + ViewMoveLinesCallback -> + C_ViewMoveLinesCallback +wrap_ViewMoveLinesCallback _cb _ copy count _ = do + let copy' = (/= 0) copy + _cb copy' count + + +{- | +Connect a signal handler for the “@move-lines@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' view #moveLines callback +@ +-} +onViewMoveLines :: (IsView a, MonadIO m) => a -> ViewMoveLinesCallback -> m SignalHandlerId +onViewMoveLines obj cb = liftIO $ do + let cb' = wrap_ViewMoveLinesCallback cb + cb'' <- mk_ViewMoveLinesCallback cb' + connectSignalFunPtr obj "move-lines" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@move-lines@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' view #moveLines callback +@ +-} +afterViewMoveLines :: (IsView a, MonadIO m) => a -> ViewMoveLinesCallback -> m SignalHandlerId +afterViewMoveLines obj cb = liftIO $ do + let cb' = wrap_ViewMoveLinesCallback cb + cb'' <- mk_ViewMoveLinesCallback cb' + connectSignalFunPtr obj "move-lines" cb'' SignalConnectAfter + + +-- signal View::move-to-matching-bracket +{- | +Keybinding signal to move the cursor to the matching bracket. + +/Since: 3.16/ +-} +type ViewMoveToMatchingBracketCallback = + Bool + {- ^ /@extendSelection@/: 'True' if the move should extend the selection -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ViewMoveToMatchingBracketCallback`@. +noViewMoveToMatchingBracketCallback :: Maybe ViewMoveToMatchingBracketCallback +noViewMoveToMatchingBracketCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_ViewMoveToMatchingBracketCallback = + Ptr () -> -- object + CInt -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_ViewMoveToMatchingBracketCallback`. +foreign import ccall "wrapper" + mk_ViewMoveToMatchingBracketCallback :: C_ViewMoveToMatchingBracketCallback -> IO (FunPtr C_ViewMoveToMatchingBracketCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_ViewMoveToMatchingBracket :: MonadIO m => ViewMoveToMatchingBracketCallback -> m (GClosure C_ViewMoveToMatchingBracketCallback) +genClosure_ViewMoveToMatchingBracket cb = liftIO $ do + let cb' = wrap_ViewMoveToMatchingBracketCallback cb + mk_ViewMoveToMatchingBracketCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `ViewMoveToMatchingBracketCallback` into a `C_ViewMoveToMatchingBracketCallback`. +wrap_ViewMoveToMatchingBracketCallback :: + ViewMoveToMatchingBracketCallback -> + C_ViewMoveToMatchingBracketCallback +wrap_ViewMoveToMatchingBracketCallback _cb _ extendSelection _ = do + let extendSelection' = (/= 0) extendSelection + _cb extendSelection' + + +{- | +Connect a signal handler for the “@move-to-matching-bracket@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' view #moveToMatchingBracket callback +@ +-} +onViewMoveToMatchingBracket :: (IsView a, MonadIO m) => a -> ViewMoveToMatchingBracketCallback -> m SignalHandlerId +onViewMoveToMatchingBracket obj cb = liftIO $ do + let cb' = wrap_ViewMoveToMatchingBracketCallback cb + cb'' <- mk_ViewMoveToMatchingBracketCallback cb' + connectSignalFunPtr obj "move-to-matching-bracket" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@move-to-matching-bracket@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' view #moveToMatchingBracket callback +@ +-} +afterViewMoveToMatchingBracket :: (IsView a, MonadIO m) => a -> ViewMoveToMatchingBracketCallback -> m SignalHandlerId +afterViewMoveToMatchingBracket obj cb = liftIO $ do + let cb' = wrap_ViewMoveToMatchingBracketCallback cb + cb'' <- mk_ViewMoveToMatchingBracketCallback cb' + connectSignalFunPtr obj "move-to-matching-bracket" cb'' SignalConnectAfter + + +-- signal View::move-words +{- | +The ::move-words signal is a keybinding which gets emitted +when the user initiates moving a word. The default binding key +is Alt+Left\/Right Arrow and moves the current selection, or the current +word by one word. + +/Since: 3.0/ +-} +type ViewMoveWordsCallback = + Int32 + {- ^ /@count@/: the number of words to move over -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ViewMoveWordsCallback`@. +noViewMoveWordsCallback :: Maybe ViewMoveWordsCallback +noViewMoveWordsCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_ViewMoveWordsCallback = + Ptr () -> -- object + Int32 -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_ViewMoveWordsCallback`. +foreign import ccall "wrapper" + mk_ViewMoveWordsCallback :: C_ViewMoveWordsCallback -> IO (FunPtr C_ViewMoveWordsCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_ViewMoveWords :: MonadIO m => ViewMoveWordsCallback -> m (GClosure C_ViewMoveWordsCallback) +genClosure_ViewMoveWords cb = liftIO $ do + let cb' = wrap_ViewMoveWordsCallback cb + mk_ViewMoveWordsCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `ViewMoveWordsCallback` into a `C_ViewMoveWordsCallback`. +wrap_ViewMoveWordsCallback :: + ViewMoveWordsCallback -> + C_ViewMoveWordsCallback +wrap_ViewMoveWordsCallback _cb _ count _ = do + _cb count + + +{- | +Connect a signal handler for the “@move-words@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' view #moveWords callback +@ +-} +onViewMoveWords :: (IsView a, MonadIO m) => a -> ViewMoveWordsCallback -> m SignalHandlerId +onViewMoveWords obj cb = liftIO $ do + let cb' = wrap_ViewMoveWordsCallback cb + cb'' <- mk_ViewMoveWordsCallback cb' + connectSignalFunPtr obj "move-words" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@move-words@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' view #moveWords callback +@ +-} +afterViewMoveWords :: (IsView a, MonadIO m) => a -> ViewMoveWordsCallback -> m SignalHandlerId +afterViewMoveWords obj cb = liftIO $ do + let cb' = wrap_ViewMoveWordsCallback cb + cb'' <- mk_ViewMoveWordsCallback cb' + connectSignalFunPtr obj "move-words" cb'' SignalConnectAfter + + +-- signal View::redo +{- | +/No description available in the introspection data./ +-} +type ViewRedoCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ViewRedoCallback`@. +noViewRedoCallback :: Maybe ViewRedoCallback +noViewRedoCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_ViewRedoCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_ViewRedoCallback`. +foreign import ccall "wrapper" + mk_ViewRedoCallback :: C_ViewRedoCallback -> IO (FunPtr C_ViewRedoCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_ViewRedo :: MonadIO m => ViewRedoCallback -> m (GClosure C_ViewRedoCallback) +genClosure_ViewRedo cb = liftIO $ do + let cb' = wrap_ViewRedoCallback cb + mk_ViewRedoCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `ViewRedoCallback` into a `C_ViewRedoCallback`. +wrap_ViewRedoCallback :: + ViewRedoCallback -> + C_ViewRedoCallback +wrap_ViewRedoCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@redo@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' view #redo callback +@ +-} +onViewRedo :: (IsView a, MonadIO m) => a -> ViewRedoCallback -> m SignalHandlerId +onViewRedo obj cb = liftIO $ do + let cb' = wrap_ViewRedoCallback cb + cb'' <- mk_ViewRedoCallback cb' + connectSignalFunPtr obj "redo" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@redo@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' view #redo callback +@ +-} +afterViewRedo :: (IsView a, MonadIO m) => a -> ViewRedoCallback -> m SignalHandlerId +afterViewRedo obj cb = liftIO $ do + let cb' = wrap_ViewRedoCallback cb + cb'' <- mk_ViewRedoCallback cb' + connectSignalFunPtr obj "redo" cb'' SignalConnectAfter + + +-- signal View::show-completion +{- | +The ::show-completion signal is a key binding signal which gets +emitted when the user requests a completion, by pressing +\\Control\<\/keycap>\space\<\/keycap>\<\/keycombo>. + +This will create a 'GI.GtkSource.Objects.CompletionContext.CompletionContext' with the activation +type as 'GI.GtkSource.Flags.CompletionActivationUserRequested'. + +Applications should not connect to it, but may emit it with +@/g_signal_emit_by_name()/@ if they need to activate the completion by +another means, for example with another key binding or a menu entry. +-} +type ViewShowCompletionCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ViewShowCompletionCallback`@. +noViewShowCompletionCallback :: Maybe ViewShowCompletionCallback +noViewShowCompletionCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_ViewShowCompletionCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_ViewShowCompletionCallback`. +foreign import ccall "wrapper" + mk_ViewShowCompletionCallback :: C_ViewShowCompletionCallback -> IO (FunPtr C_ViewShowCompletionCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_ViewShowCompletion :: MonadIO m => ViewShowCompletionCallback -> m (GClosure C_ViewShowCompletionCallback) +genClosure_ViewShowCompletion cb = liftIO $ do + let cb' = wrap_ViewShowCompletionCallback cb + mk_ViewShowCompletionCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `ViewShowCompletionCallback` into a `C_ViewShowCompletionCallback`. +wrap_ViewShowCompletionCallback :: + ViewShowCompletionCallback -> + C_ViewShowCompletionCallback +wrap_ViewShowCompletionCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@show-completion@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' view #showCompletion callback +@ +-} +onViewShowCompletion :: (IsView a, MonadIO m) => a -> ViewShowCompletionCallback -> m SignalHandlerId +onViewShowCompletion obj cb = liftIO $ do + let cb' = wrap_ViewShowCompletionCallback cb + cb'' <- mk_ViewShowCompletionCallback cb' + connectSignalFunPtr obj "show-completion" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@show-completion@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' view #showCompletion callback +@ +-} +afterViewShowCompletion :: (IsView a, MonadIO m) => a -> ViewShowCompletionCallback -> m SignalHandlerId +afterViewShowCompletion obj cb = liftIO $ do + let cb' = wrap_ViewShowCompletionCallback cb + cb'' <- mk_ViewShowCompletionCallback cb' + connectSignalFunPtr obj "show-completion" cb'' SignalConnectAfter + + +-- signal View::smart-home-end +{- | +Emitted when a the cursor was moved according to the smart home +end setting. The signal is emitted after the cursor is moved, but +during the GtkTextView::move-cursor action. This can be used to find +out whether the cursor was moved by a normal home\/end or by a smart +home\/end. + +/Since: 3.0/ +-} +type ViewSmartHomeEndCallback = + Gtk.TextIter.TextIter + {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter' -} + -> Int32 + {- ^ /@count@/: the count -} + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ViewSmartHomeEndCallback`@. +noViewSmartHomeEndCallback :: Maybe ViewSmartHomeEndCallback +noViewSmartHomeEndCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_ViewSmartHomeEndCallback = + Ptr () -> -- object + Ptr Gtk.TextIter.TextIter -> + Int32 -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_ViewSmartHomeEndCallback`. +foreign import ccall "wrapper" + mk_ViewSmartHomeEndCallback :: C_ViewSmartHomeEndCallback -> IO (FunPtr C_ViewSmartHomeEndCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_ViewSmartHomeEnd :: MonadIO m => ViewSmartHomeEndCallback -> m (GClosure C_ViewSmartHomeEndCallback) +genClosure_ViewSmartHomeEnd cb = liftIO $ do + let cb' = wrap_ViewSmartHomeEndCallback cb + mk_ViewSmartHomeEndCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `ViewSmartHomeEndCallback` into a `C_ViewSmartHomeEndCallback`. +wrap_ViewSmartHomeEndCallback :: + ViewSmartHomeEndCallback -> + C_ViewSmartHomeEndCallback +wrap_ViewSmartHomeEndCallback _cb _ iter count _ = do + B.ManagedPtr.withTransient Gtk.TextIter.TextIter iter $ \iter' -> do + _cb iter' count + + +{- | +Connect a signal handler for the “@smart-home-end@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' view #smartHomeEnd callback +@ +-} +onViewSmartHomeEnd :: (IsView a, MonadIO m) => a -> ViewSmartHomeEndCallback -> m SignalHandlerId +onViewSmartHomeEnd obj cb = liftIO $ do + let cb' = wrap_ViewSmartHomeEndCallback cb + cb'' <- mk_ViewSmartHomeEndCallback cb' + connectSignalFunPtr obj "smart-home-end" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@smart-home-end@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' view #smartHomeEnd callback +@ +-} +afterViewSmartHomeEnd :: (IsView a, MonadIO m) => a -> ViewSmartHomeEndCallback -> m SignalHandlerId +afterViewSmartHomeEnd obj cb = liftIO $ do + let cb' = wrap_ViewSmartHomeEndCallback cb + cb'' <- mk_ViewSmartHomeEndCallback cb' + connectSignalFunPtr obj "smart-home-end" cb'' SignalConnectAfter + + +-- signal View::undo +{- | +/No description available in the introspection data./ +-} +type ViewUndoCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `ViewUndoCallback`@. +noViewUndoCallback :: Maybe ViewUndoCallback +noViewUndoCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_ViewUndoCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_ViewUndoCallback`. +foreign import ccall "wrapper" + mk_ViewUndoCallback :: C_ViewUndoCallback -> IO (FunPtr C_ViewUndoCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_ViewUndo :: MonadIO m => ViewUndoCallback -> m (GClosure C_ViewUndoCallback) +genClosure_ViewUndo cb = liftIO $ do + let cb' = wrap_ViewUndoCallback cb + mk_ViewUndoCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `ViewUndoCallback` into a `C_ViewUndoCallback`. +wrap_ViewUndoCallback :: + ViewUndoCallback -> + C_ViewUndoCallback +wrap_ViewUndoCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@undo@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' view #undo callback +@ +-} +onViewUndo :: (IsView a, MonadIO m) => a -> ViewUndoCallback -> m SignalHandlerId +onViewUndo obj cb = liftIO $ do + let cb' = wrap_ViewUndoCallback cb + cb'' <- mk_ViewUndoCallback cb' + connectSignalFunPtr obj "undo" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@undo@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' view #undo callback +@ +-} +afterViewUndo :: (IsView a, MonadIO m) => a -> ViewUndoCallback -> m SignalHandlerId +afterViewUndo obj cb = liftIO $ do + let cb' = wrap_ViewUndoCallback cb + cb'' <- mk_ViewUndoCallback cb' + connectSignalFunPtr obj "undo" cb'' SignalConnectAfter + + +-- VVV Prop "auto-indent" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@auto-indent@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' view #autoIndent +@ +-} +getViewAutoIndent :: (MonadIO m, IsView o) => o -> m Bool +getViewAutoIndent obj = liftIO $ B.Properties.getObjectPropertyBool obj "auto-indent" + +{- | +Set the value of the “@auto-indent@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' view [ #autoIndent 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setViewAutoIndent :: (MonadIO m, IsView o) => o -> Bool -> m () +setViewAutoIndent obj val = liftIO $ B.Properties.setObjectPropertyBool obj "auto-indent" val + +{- | +Construct a `GValueConstruct` with valid value for the “@auto-indent@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructViewAutoIndent :: (IsView o) => Bool -> IO (GValueConstruct o) +constructViewAutoIndent val = B.Properties.constructObjectPropertyBool "auto-indent" val + +#if ENABLE_OVERLOADING +data ViewAutoIndentPropertyInfo +instance AttrInfo ViewAutoIndentPropertyInfo where + type AttrAllowedOps ViewAutoIndentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint ViewAutoIndentPropertyInfo = (~) Bool + type AttrBaseTypeConstraint ViewAutoIndentPropertyInfo = IsView + type AttrGetType ViewAutoIndentPropertyInfo = Bool + type AttrLabel ViewAutoIndentPropertyInfo = "auto-indent" + type AttrOrigin ViewAutoIndentPropertyInfo = View + attrGet _ = getViewAutoIndent + attrSet _ = setViewAutoIndent + attrConstruct _ = constructViewAutoIndent + attrClear _ = undefined +#endif + +-- VVV Prop "background-pattern" + -- Type: TInterface (Name {namespace = "GtkSource", name = "BackgroundPatternType"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@background-pattern@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' view #backgroundPattern +@ +-} +getViewBackgroundPattern :: (MonadIO m, IsView o) => o -> m GtkSource.Enums.BackgroundPatternType +getViewBackgroundPattern obj = liftIO $ B.Properties.getObjectPropertyEnum obj "background-pattern" + +{- | +Set the value of the “@background-pattern@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' view [ #backgroundPattern 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setViewBackgroundPattern :: (MonadIO m, IsView o) => o -> GtkSource.Enums.BackgroundPatternType -> m () +setViewBackgroundPattern obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "background-pattern" val + +{- | +Construct a `GValueConstruct` with valid value for the “@background-pattern@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructViewBackgroundPattern :: (IsView o) => GtkSource.Enums.BackgroundPatternType -> IO (GValueConstruct o) +constructViewBackgroundPattern val = B.Properties.constructObjectPropertyEnum "background-pattern" val + +#if ENABLE_OVERLOADING +data ViewBackgroundPatternPropertyInfo +instance AttrInfo ViewBackgroundPatternPropertyInfo where + type AttrAllowedOps ViewBackgroundPatternPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint ViewBackgroundPatternPropertyInfo = (~) GtkSource.Enums.BackgroundPatternType + type AttrBaseTypeConstraint ViewBackgroundPatternPropertyInfo = IsView + type AttrGetType ViewBackgroundPatternPropertyInfo = GtkSource.Enums.BackgroundPatternType + type AttrLabel ViewBackgroundPatternPropertyInfo = "background-pattern" + type AttrOrigin ViewBackgroundPatternPropertyInfo = View + attrGet _ = getViewBackgroundPattern + attrSet _ = setViewBackgroundPattern + attrConstruct _ = constructViewBackgroundPattern + attrClear _ = undefined +#endif + +-- VVV Prop "completion" + -- Type: TInterface (Name {namespace = "GtkSource", name = "Completion"}) + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@completion@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' view #completion +@ +-} +getViewCompletion :: (MonadIO m, IsView o) => o -> m GtkSource.Completion.Completion +getViewCompletion obj = liftIO $ checkUnexpectedNothing "getViewCompletion" $ B.Properties.getObjectPropertyObject obj "completion" GtkSource.Completion.Completion + +#if ENABLE_OVERLOADING +data ViewCompletionPropertyInfo +instance AttrInfo ViewCompletionPropertyInfo where + type AttrAllowedOps ViewCompletionPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ViewCompletionPropertyInfo = (~) () + type AttrBaseTypeConstraint ViewCompletionPropertyInfo = IsView + type AttrGetType ViewCompletionPropertyInfo = GtkSource.Completion.Completion + type AttrLabel ViewCompletionPropertyInfo = "completion" + type AttrOrigin ViewCompletionPropertyInfo = View + attrGet _ = getViewCompletion + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "draw-spaces" + -- Type: TInterface (Name {namespace = "GtkSource", name = "DrawSpacesFlags"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@draw-spaces@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' view #drawSpaces +@ +-} +getViewDrawSpaces :: (MonadIO m, IsView o) => o -> m [GtkSource.Flags.DrawSpacesFlags] +getViewDrawSpaces obj = liftIO $ B.Properties.getObjectPropertyFlags obj "draw-spaces" + +{- | +Set the value of the “@draw-spaces@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' view [ #drawSpaces 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setViewDrawSpaces :: (MonadIO m, IsView o) => o -> [GtkSource.Flags.DrawSpacesFlags] -> m () +setViewDrawSpaces obj val = liftIO $ B.Properties.setObjectPropertyFlags obj "draw-spaces" val + +{- | +Construct a `GValueConstruct` with valid value for the “@draw-spaces@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructViewDrawSpaces :: (IsView o) => [GtkSource.Flags.DrawSpacesFlags] -> IO (GValueConstruct o) +constructViewDrawSpaces val = B.Properties.constructObjectPropertyFlags "draw-spaces" val + +#if ENABLE_OVERLOADING +data ViewDrawSpacesPropertyInfo +instance AttrInfo ViewDrawSpacesPropertyInfo where + type AttrAllowedOps ViewDrawSpacesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint ViewDrawSpacesPropertyInfo = (~) [GtkSource.Flags.DrawSpacesFlags] + type AttrBaseTypeConstraint ViewDrawSpacesPropertyInfo = IsView + type AttrGetType ViewDrawSpacesPropertyInfo = [GtkSource.Flags.DrawSpacesFlags] + type AttrLabel ViewDrawSpacesPropertyInfo = "draw-spaces" + type AttrOrigin ViewDrawSpacesPropertyInfo = View + attrGet _ = getViewDrawSpaces + attrSet _ = setViewDrawSpaces + attrConstruct _ = constructViewDrawSpaces + attrClear _ = undefined +#endif + +-- VVV Prop "highlight-current-line" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@highlight-current-line@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' view #highlightCurrentLine +@ +-} +getViewHighlightCurrentLine :: (MonadIO m, IsView o) => o -> m Bool +getViewHighlightCurrentLine obj = liftIO $ B.Properties.getObjectPropertyBool obj "highlight-current-line" + +{- | +Set the value of the “@highlight-current-line@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' view [ #highlightCurrentLine 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setViewHighlightCurrentLine :: (MonadIO m, IsView o) => o -> Bool -> m () +setViewHighlightCurrentLine obj val = liftIO $ B.Properties.setObjectPropertyBool obj "highlight-current-line" val + +{- | +Construct a `GValueConstruct` with valid value for the “@highlight-current-line@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructViewHighlightCurrentLine :: (IsView o) => Bool -> IO (GValueConstruct o) +constructViewHighlightCurrentLine val = B.Properties.constructObjectPropertyBool "highlight-current-line" val + +#if ENABLE_OVERLOADING +data ViewHighlightCurrentLinePropertyInfo +instance AttrInfo ViewHighlightCurrentLinePropertyInfo where + type AttrAllowedOps ViewHighlightCurrentLinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint ViewHighlightCurrentLinePropertyInfo = (~) Bool + type AttrBaseTypeConstraint ViewHighlightCurrentLinePropertyInfo = IsView + type AttrGetType ViewHighlightCurrentLinePropertyInfo = Bool + type AttrLabel ViewHighlightCurrentLinePropertyInfo = "highlight-current-line" + type AttrOrigin ViewHighlightCurrentLinePropertyInfo = View + attrGet _ = getViewHighlightCurrentLine + attrSet _ = setViewHighlightCurrentLine + attrConstruct _ = constructViewHighlightCurrentLine + attrClear _ = undefined +#endif + +-- VVV Prop "indent-on-tab" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@indent-on-tab@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' view #indentOnTab +@ +-} +getViewIndentOnTab :: (MonadIO m, IsView o) => o -> m Bool +getViewIndentOnTab obj = liftIO $ B.Properties.getObjectPropertyBool obj "indent-on-tab" + +{- | +Set the value of the “@indent-on-tab@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' view [ #indentOnTab 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setViewIndentOnTab :: (MonadIO m, IsView o) => o -> Bool -> m () +setViewIndentOnTab obj val = liftIO $ B.Properties.setObjectPropertyBool obj "indent-on-tab" val + +{- | +Construct a `GValueConstruct` with valid value for the “@indent-on-tab@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructViewIndentOnTab :: (IsView o) => Bool -> IO (GValueConstruct o) +constructViewIndentOnTab val = B.Properties.constructObjectPropertyBool "indent-on-tab" val + +#if ENABLE_OVERLOADING +data ViewIndentOnTabPropertyInfo +instance AttrInfo ViewIndentOnTabPropertyInfo where + type AttrAllowedOps ViewIndentOnTabPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint ViewIndentOnTabPropertyInfo = (~) Bool + type AttrBaseTypeConstraint ViewIndentOnTabPropertyInfo = IsView + type AttrGetType ViewIndentOnTabPropertyInfo = Bool + type AttrLabel ViewIndentOnTabPropertyInfo = "indent-on-tab" + type AttrOrigin ViewIndentOnTabPropertyInfo = View + attrGet _ = getViewIndentOnTab + attrSet _ = setViewIndentOnTab + attrConstruct _ = constructViewIndentOnTab + attrClear _ = undefined +#endif + +-- VVV Prop "indent-width" + -- Type: TBasicType TInt + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@indent-width@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' view #indentWidth +@ +-} +getViewIndentWidth :: (MonadIO m, IsView o) => o -> m Int32 +getViewIndentWidth obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "indent-width" + +{- | +Set the value of the “@indent-width@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' view [ #indentWidth 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setViewIndentWidth :: (MonadIO m, IsView o) => o -> Int32 -> m () +setViewIndentWidth obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "indent-width" val + +{- | +Construct a `GValueConstruct` with valid value for the “@indent-width@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructViewIndentWidth :: (IsView o) => Int32 -> IO (GValueConstruct o) +constructViewIndentWidth val = B.Properties.constructObjectPropertyInt32 "indent-width" val + +#if ENABLE_OVERLOADING +data ViewIndentWidthPropertyInfo +instance AttrInfo ViewIndentWidthPropertyInfo where + type AttrAllowedOps ViewIndentWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint ViewIndentWidthPropertyInfo = (~) Int32 + type AttrBaseTypeConstraint ViewIndentWidthPropertyInfo = IsView + type AttrGetType ViewIndentWidthPropertyInfo = Int32 + type AttrLabel ViewIndentWidthPropertyInfo = "indent-width" + type AttrOrigin ViewIndentWidthPropertyInfo = View + attrGet _ = getViewIndentWidth + attrSet _ = setViewIndentWidth + attrConstruct _ = constructViewIndentWidth + attrClear _ = undefined +#endif + +-- VVV Prop "insert-spaces-instead-of-tabs" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@insert-spaces-instead-of-tabs@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' view #insertSpacesInsteadOfTabs +@ +-} +getViewInsertSpacesInsteadOfTabs :: (MonadIO m, IsView o) => o -> m Bool +getViewInsertSpacesInsteadOfTabs obj = liftIO $ B.Properties.getObjectPropertyBool obj "insert-spaces-instead-of-tabs" + +{- | +Set the value of the “@insert-spaces-instead-of-tabs@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' view [ #insertSpacesInsteadOfTabs 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setViewInsertSpacesInsteadOfTabs :: (MonadIO m, IsView o) => o -> Bool -> m () +setViewInsertSpacesInsteadOfTabs obj val = liftIO $ B.Properties.setObjectPropertyBool obj "insert-spaces-instead-of-tabs" val + +{- | +Construct a `GValueConstruct` with valid value for the “@insert-spaces-instead-of-tabs@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructViewInsertSpacesInsteadOfTabs :: (IsView o) => Bool -> IO (GValueConstruct o) +constructViewInsertSpacesInsteadOfTabs val = B.Properties.constructObjectPropertyBool "insert-spaces-instead-of-tabs" val + +#if ENABLE_OVERLOADING +data ViewInsertSpacesInsteadOfTabsPropertyInfo +instance AttrInfo ViewInsertSpacesInsteadOfTabsPropertyInfo where + type AttrAllowedOps ViewInsertSpacesInsteadOfTabsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint ViewInsertSpacesInsteadOfTabsPropertyInfo = (~) Bool + type AttrBaseTypeConstraint ViewInsertSpacesInsteadOfTabsPropertyInfo = IsView + type AttrGetType ViewInsertSpacesInsteadOfTabsPropertyInfo = Bool + type AttrLabel ViewInsertSpacesInsteadOfTabsPropertyInfo = "insert-spaces-instead-of-tabs" + type AttrOrigin ViewInsertSpacesInsteadOfTabsPropertyInfo = View + attrGet _ = getViewInsertSpacesInsteadOfTabs + attrSet _ = setViewInsertSpacesInsteadOfTabs + attrConstruct _ = constructViewInsertSpacesInsteadOfTabs + attrClear _ = undefined +#endif + +-- VVV Prop "right-margin-position" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@right-margin-position@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' view #rightMarginPosition +@ +-} +getViewRightMarginPosition :: (MonadIO m, IsView o) => o -> m Word32 +getViewRightMarginPosition obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "right-margin-position" + +{- | +Set the value of the “@right-margin-position@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' view [ #rightMarginPosition 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setViewRightMarginPosition :: (MonadIO m, IsView o) => o -> Word32 -> m () +setViewRightMarginPosition obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "right-margin-position" val + +{- | +Construct a `GValueConstruct` with valid value for the “@right-margin-position@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructViewRightMarginPosition :: (IsView o) => Word32 -> IO (GValueConstruct o) +constructViewRightMarginPosition val = B.Properties.constructObjectPropertyUInt32 "right-margin-position" val + +#if ENABLE_OVERLOADING +data ViewRightMarginPositionPropertyInfo +instance AttrInfo ViewRightMarginPositionPropertyInfo where + type AttrAllowedOps ViewRightMarginPositionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint ViewRightMarginPositionPropertyInfo = (~) Word32 + type AttrBaseTypeConstraint ViewRightMarginPositionPropertyInfo = IsView + type AttrGetType ViewRightMarginPositionPropertyInfo = Word32 + type AttrLabel ViewRightMarginPositionPropertyInfo = "right-margin-position" + type AttrOrigin ViewRightMarginPositionPropertyInfo = View + attrGet _ = getViewRightMarginPosition + attrSet _ = setViewRightMarginPosition + attrConstruct _ = constructViewRightMarginPosition + attrClear _ = undefined +#endif + +-- VVV Prop "show-line-marks" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@show-line-marks@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' view #showLineMarks +@ +-} +getViewShowLineMarks :: (MonadIO m, IsView o) => o -> m Bool +getViewShowLineMarks obj = liftIO $ B.Properties.getObjectPropertyBool obj "show-line-marks" + +{- | +Set the value of the “@show-line-marks@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' view [ #showLineMarks 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setViewShowLineMarks :: (MonadIO m, IsView o) => o -> Bool -> m () +setViewShowLineMarks obj val = liftIO $ B.Properties.setObjectPropertyBool obj "show-line-marks" val + +{- | +Construct a `GValueConstruct` with valid value for the “@show-line-marks@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructViewShowLineMarks :: (IsView o) => Bool -> IO (GValueConstruct o) +constructViewShowLineMarks val = B.Properties.constructObjectPropertyBool "show-line-marks" val + +#if ENABLE_OVERLOADING +data ViewShowLineMarksPropertyInfo +instance AttrInfo ViewShowLineMarksPropertyInfo where + type AttrAllowedOps ViewShowLineMarksPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint ViewShowLineMarksPropertyInfo = (~) Bool + type AttrBaseTypeConstraint ViewShowLineMarksPropertyInfo = IsView + type AttrGetType ViewShowLineMarksPropertyInfo = Bool + type AttrLabel ViewShowLineMarksPropertyInfo = "show-line-marks" + type AttrOrigin ViewShowLineMarksPropertyInfo = View + attrGet _ = getViewShowLineMarks + attrSet _ = setViewShowLineMarks + attrConstruct _ = constructViewShowLineMarks + attrClear _ = undefined +#endif + +-- VVV Prop "show-line-numbers" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@show-line-numbers@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' view #showLineNumbers +@ +-} +getViewShowLineNumbers :: (MonadIO m, IsView o) => o -> m Bool +getViewShowLineNumbers obj = liftIO $ B.Properties.getObjectPropertyBool obj "show-line-numbers" + +{- | +Set the value of the “@show-line-numbers@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' view [ #showLineNumbers 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setViewShowLineNumbers :: (MonadIO m, IsView o) => o -> Bool -> m () +setViewShowLineNumbers obj val = liftIO $ B.Properties.setObjectPropertyBool obj "show-line-numbers" val + +{- | +Construct a `GValueConstruct` with valid value for the “@show-line-numbers@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructViewShowLineNumbers :: (IsView o) => Bool -> IO (GValueConstruct o) +constructViewShowLineNumbers val = B.Properties.constructObjectPropertyBool "show-line-numbers" val + +#if ENABLE_OVERLOADING +data ViewShowLineNumbersPropertyInfo +instance AttrInfo ViewShowLineNumbersPropertyInfo where + type AttrAllowedOps ViewShowLineNumbersPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint ViewShowLineNumbersPropertyInfo = (~) Bool + type AttrBaseTypeConstraint ViewShowLineNumbersPropertyInfo = IsView + type AttrGetType ViewShowLineNumbersPropertyInfo = Bool + type AttrLabel ViewShowLineNumbersPropertyInfo = "show-line-numbers" + type AttrOrigin ViewShowLineNumbersPropertyInfo = View + attrGet _ = getViewShowLineNumbers + attrSet _ = setViewShowLineNumbers + attrConstruct _ = constructViewShowLineNumbers + attrClear _ = undefined +#endif + +-- VVV Prop "show-right-margin" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@show-right-margin@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' view #showRightMargin +@ +-} +getViewShowRightMargin :: (MonadIO m, IsView o) => o -> m Bool +getViewShowRightMargin obj = liftIO $ B.Properties.getObjectPropertyBool obj "show-right-margin" + +{- | +Set the value of the “@show-right-margin@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' view [ #showRightMargin 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setViewShowRightMargin :: (MonadIO m, IsView o) => o -> Bool -> m () +setViewShowRightMargin obj val = liftIO $ B.Properties.setObjectPropertyBool obj "show-right-margin" val + +{- | +Construct a `GValueConstruct` with valid value for the “@show-right-margin@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructViewShowRightMargin :: (IsView o) => Bool -> IO (GValueConstruct o) +constructViewShowRightMargin val = B.Properties.constructObjectPropertyBool "show-right-margin" val + +#if ENABLE_OVERLOADING +data ViewShowRightMarginPropertyInfo +instance AttrInfo ViewShowRightMarginPropertyInfo where + type AttrAllowedOps ViewShowRightMarginPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint ViewShowRightMarginPropertyInfo = (~) Bool + type AttrBaseTypeConstraint ViewShowRightMarginPropertyInfo = IsView + type AttrGetType ViewShowRightMarginPropertyInfo = Bool + type AttrLabel ViewShowRightMarginPropertyInfo = "show-right-margin" + type AttrOrigin ViewShowRightMarginPropertyInfo = View + attrGet _ = getViewShowRightMargin + attrSet _ = setViewShowRightMargin + attrConstruct _ = constructViewShowRightMargin + attrClear _ = undefined +#endif + +-- VVV Prop "smart-backspace" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@smart-backspace@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' view #smartBackspace +@ +-} +getViewSmartBackspace :: (MonadIO m, IsView o) => o -> m Bool +getViewSmartBackspace obj = liftIO $ B.Properties.getObjectPropertyBool obj "smart-backspace" + +{- | +Set the value of the “@smart-backspace@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' view [ #smartBackspace 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setViewSmartBackspace :: (MonadIO m, IsView o) => o -> Bool -> m () +setViewSmartBackspace obj val = liftIO $ B.Properties.setObjectPropertyBool obj "smart-backspace" val + +{- | +Construct a `GValueConstruct` with valid value for the “@smart-backspace@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructViewSmartBackspace :: (IsView o) => Bool -> IO (GValueConstruct o) +constructViewSmartBackspace val = B.Properties.constructObjectPropertyBool "smart-backspace" val + +#if ENABLE_OVERLOADING +data ViewSmartBackspacePropertyInfo +instance AttrInfo ViewSmartBackspacePropertyInfo where + type AttrAllowedOps ViewSmartBackspacePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint ViewSmartBackspacePropertyInfo = (~) Bool + type AttrBaseTypeConstraint ViewSmartBackspacePropertyInfo = IsView + type AttrGetType ViewSmartBackspacePropertyInfo = Bool + type AttrLabel ViewSmartBackspacePropertyInfo = "smart-backspace" + type AttrOrigin ViewSmartBackspacePropertyInfo = View + attrGet _ = getViewSmartBackspace + attrSet _ = setViewSmartBackspace + attrConstruct _ = constructViewSmartBackspace + attrClear _ = undefined +#endif + +-- VVV Prop "smart-home-end" + -- Type: TInterface (Name {namespace = "GtkSource", name = "SmartHomeEndType"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@smart-home-end@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' view #smartHomeEnd +@ +-} +getViewSmartHomeEnd :: (MonadIO m, IsView o) => o -> m GtkSource.Enums.SmartHomeEndType +getViewSmartHomeEnd obj = liftIO $ B.Properties.getObjectPropertyEnum obj "smart-home-end" + +{- | +Set the value of the “@smart-home-end@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' view [ #smartHomeEnd 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setViewSmartHomeEnd :: (MonadIO m, IsView o) => o -> GtkSource.Enums.SmartHomeEndType -> m () +setViewSmartHomeEnd obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "smart-home-end" val + +{- | +Construct a `GValueConstruct` with valid value for the “@smart-home-end@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructViewSmartHomeEnd :: (IsView o) => GtkSource.Enums.SmartHomeEndType -> IO (GValueConstruct o) +constructViewSmartHomeEnd val = B.Properties.constructObjectPropertyEnum "smart-home-end" val + +#if ENABLE_OVERLOADING +data ViewSmartHomeEndPropertyInfo +instance AttrInfo ViewSmartHomeEndPropertyInfo where + type AttrAllowedOps ViewSmartHomeEndPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint ViewSmartHomeEndPropertyInfo = (~) GtkSource.Enums.SmartHomeEndType + type AttrBaseTypeConstraint ViewSmartHomeEndPropertyInfo = IsView + type AttrGetType ViewSmartHomeEndPropertyInfo = GtkSource.Enums.SmartHomeEndType + type AttrLabel ViewSmartHomeEndPropertyInfo = "smart-home-end" + type AttrOrigin ViewSmartHomeEndPropertyInfo = View + attrGet _ = getViewSmartHomeEnd + attrSet _ = setViewSmartHomeEnd + attrConstruct _ = constructViewSmartHomeEnd + attrClear _ = undefined +#endif + +-- VVV Prop "space-drawer" + -- Type: TInterface (Name {namespace = "GtkSource", name = "SpaceDrawer"}) + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@space-drawer@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' view #spaceDrawer +@ +-} +getViewSpaceDrawer :: (MonadIO m, IsView o) => o -> m GtkSource.SpaceDrawer.SpaceDrawer +getViewSpaceDrawer obj = liftIO $ checkUnexpectedNothing "getViewSpaceDrawer" $ B.Properties.getObjectPropertyObject obj "space-drawer" GtkSource.SpaceDrawer.SpaceDrawer + +#if ENABLE_OVERLOADING +data ViewSpaceDrawerPropertyInfo +instance AttrInfo ViewSpaceDrawerPropertyInfo where + type AttrAllowedOps ViewSpaceDrawerPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ViewSpaceDrawerPropertyInfo = (~) () + type AttrBaseTypeConstraint ViewSpaceDrawerPropertyInfo = IsView + type AttrGetType ViewSpaceDrawerPropertyInfo = GtkSource.SpaceDrawer.SpaceDrawer + type AttrLabel ViewSpaceDrawerPropertyInfo = "space-drawer" + type AttrOrigin ViewSpaceDrawerPropertyInfo = View + attrGet _ = getViewSpaceDrawer + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "tab-width" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Just False,Just False) + +{- | +Get the value of the “@tab-width@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' view #tabWidth +@ +-} +getViewTabWidth :: (MonadIO m, IsView o) => o -> m Word32 +getViewTabWidth obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "tab-width" + +{- | +Set the value of the “@tab-width@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' view [ #tabWidth 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setViewTabWidth :: (MonadIO m, IsView o) => o -> Word32 -> m () +setViewTabWidth obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "tab-width" val + +{- | +Construct a `GValueConstruct` with valid value for the “@tab-width@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructViewTabWidth :: (IsView o) => Word32 -> IO (GValueConstruct o) +constructViewTabWidth val = B.Properties.constructObjectPropertyUInt32 "tab-width" val + +#if ENABLE_OVERLOADING +data ViewTabWidthPropertyInfo +instance AttrInfo ViewTabWidthPropertyInfo where + type AttrAllowedOps ViewTabWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint ViewTabWidthPropertyInfo = (~) Word32 + type AttrBaseTypeConstraint ViewTabWidthPropertyInfo = IsView + type AttrGetType ViewTabWidthPropertyInfo = Word32 + type AttrLabel ViewTabWidthPropertyInfo = "tab-width" + type AttrOrigin ViewTabWidthPropertyInfo = View + attrGet _ = getViewTabWidth + attrSet _ = setViewTabWidth + attrConstruct _ = constructViewTabWidth + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList View +type instance O.AttributeList View = ViewAttributeList +type ViewAttributeList = ('[ '("acceptsTab", Gtk.TextView.TextViewAcceptsTabPropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("autoIndent", ViewAutoIndentPropertyInfo), '("backgroundPattern", ViewBackgroundPatternPropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("bottomMargin", Gtk.TextView.TextViewBottomMarginPropertyInfo), '("buffer", Gtk.TextView.TextViewBufferPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("completion", ViewCompletionPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("cursorVisible", Gtk.TextView.TextViewCursorVisiblePropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("drawSpaces", ViewDrawSpacesPropertyInfo), '("editable", Gtk.TextView.TextViewEditablePropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("hadjustment", Gtk.Scrollable.ScrollableHadjustmentPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("highlightCurrentLine", ViewHighlightCurrentLinePropertyInfo), '("hscrollPolicy", Gtk.Scrollable.ScrollableHscrollPolicyPropertyInfo), '("imModule", Gtk.TextView.TextViewImModulePropertyInfo), '("indent", Gtk.TextView.TextViewIndentPropertyInfo), '("indentOnTab", ViewIndentOnTabPropertyInfo), '("indentWidth", ViewIndentWidthPropertyInfo), '("inputHints", Gtk.TextView.TextViewInputHintsPropertyInfo), '("inputPurpose", Gtk.TextView.TextViewInputPurposePropertyInfo), '("insertSpacesInsteadOfTabs", ViewInsertSpacesInsteadOfTabsPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("justification", Gtk.TextView.TextViewJustificationPropertyInfo), '("leftMargin", Gtk.TextView.TextViewLeftMarginPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("monospace", Gtk.TextView.TextViewMonospacePropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overwrite", Gtk.TextView.TextViewOverwritePropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("pixelsAboveLines", Gtk.TextView.TextViewPixelsAboveLinesPropertyInfo), '("pixelsBelowLines", Gtk.TextView.TextViewPixelsBelowLinesPropertyInfo), '("pixelsInsideWrap", Gtk.TextView.TextViewPixelsInsideWrapPropertyInfo), '("populateAll", Gtk.TextView.TextViewPopulateAllPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("rightMargin", Gtk.TextView.TextViewRightMarginPropertyInfo), '("rightMarginPosition", ViewRightMarginPositionPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("showLineMarks", ViewShowLineMarksPropertyInfo), '("showLineNumbers", ViewShowLineNumbersPropertyInfo), '("showRightMargin", ViewShowRightMarginPropertyInfo), '("smartBackspace", ViewSmartBackspacePropertyInfo), '("smartHomeEnd", ViewSmartHomeEndPropertyInfo), '("spaceDrawer", ViewSpaceDrawerPropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("tabWidth", ViewTabWidthPropertyInfo), '("tabs", Gtk.TextView.TextViewTabsPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("topMargin", Gtk.TextView.TextViewTopMarginPropertyInfo), '("vadjustment", Gtk.Scrollable.ScrollableVadjustmentPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("vscrollPolicy", Gtk.Scrollable.ScrollableVscrollPolicyPropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo), '("wrapMode", Gtk.TextView.TextViewWrapModePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +viewAutoIndent :: AttrLabelProxy "autoIndent" +viewAutoIndent = AttrLabelProxy + +viewBackgroundPattern :: AttrLabelProxy "backgroundPattern" +viewBackgroundPattern = AttrLabelProxy + +viewCompletion :: AttrLabelProxy "completion" +viewCompletion = AttrLabelProxy + +viewDrawSpaces :: AttrLabelProxy "drawSpaces" +viewDrawSpaces = AttrLabelProxy + +viewHighlightCurrentLine :: AttrLabelProxy "highlightCurrentLine" +viewHighlightCurrentLine = AttrLabelProxy + +viewIndentOnTab :: AttrLabelProxy "indentOnTab" +viewIndentOnTab = AttrLabelProxy + +viewIndentWidth :: AttrLabelProxy "indentWidth" +viewIndentWidth = AttrLabelProxy + +viewInsertSpacesInsteadOfTabs :: AttrLabelProxy "insertSpacesInsteadOfTabs" +viewInsertSpacesInsteadOfTabs = AttrLabelProxy + +viewRightMarginPosition :: AttrLabelProxy "rightMarginPosition" +viewRightMarginPosition = AttrLabelProxy + +viewShowLineMarks :: AttrLabelProxy "showLineMarks" +viewShowLineMarks = AttrLabelProxy + +viewShowLineNumbers :: AttrLabelProxy "showLineNumbers" +viewShowLineNumbers = AttrLabelProxy + +viewShowRightMargin :: AttrLabelProxy "showRightMargin" +viewShowRightMargin = AttrLabelProxy + +viewSmartBackspace :: AttrLabelProxy "smartBackspace" +viewSmartBackspace = AttrLabelProxy + +viewSmartHomeEnd :: AttrLabelProxy "smartHomeEnd" +viewSmartHomeEnd = AttrLabelProxy + +viewSpaceDrawer :: AttrLabelProxy "spaceDrawer" +viewSpaceDrawer = AttrLabelProxy + +viewTabWidth :: AttrLabelProxy "tabWidth" +viewTabWidth = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +data ViewChangeCaseSignalInfo +instance SignalInfo ViewChangeCaseSignalInfo where + type HaskellCallbackType ViewChangeCaseSignalInfo = ViewChangeCaseCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_ViewChangeCaseCallback cb + cb'' <- mk_ViewChangeCaseCallback cb' + connectSignalFunPtr obj "change-case" cb'' connectMode + +data ViewChangeNumberSignalInfo +instance SignalInfo ViewChangeNumberSignalInfo where + type HaskellCallbackType ViewChangeNumberSignalInfo = ViewChangeNumberCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_ViewChangeNumberCallback cb + cb'' <- mk_ViewChangeNumberCallback cb' + connectSignalFunPtr obj "change-number" cb'' connectMode + +data ViewJoinLinesSignalInfo +instance SignalInfo ViewJoinLinesSignalInfo where + type HaskellCallbackType ViewJoinLinesSignalInfo = ViewJoinLinesCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_ViewJoinLinesCallback cb + cb'' <- mk_ViewJoinLinesCallback cb' + connectSignalFunPtr obj "join-lines" cb'' connectMode + +data ViewLineMarkActivatedSignalInfo +instance SignalInfo ViewLineMarkActivatedSignalInfo where + type HaskellCallbackType ViewLineMarkActivatedSignalInfo = ViewLineMarkActivatedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_ViewLineMarkActivatedCallback cb + cb'' <- mk_ViewLineMarkActivatedCallback cb' + connectSignalFunPtr obj "line-mark-activated" cb'' connectMode + +data ViewMoveLinesSignalInfo +instance SignalInfo ViewMoveLinesSignalInfo where + type HaskellCallbackType ViewMoveLinesSignalInfo = ViewMoveLinesCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_ViewMoveLinesCallback cb + cb'' <- mk_ViewMoveLinesCallback cb' + connectSignalFunPtr obj "move-lines" cb'' connectMode + +data ViewMoveToMatchingBracketSignalInfo +instance SignalInfo ViewMoveToMatchingBracketSignalInfo where + type HaskellCallbackType ViewMoveToMatchingBracketSignalInfo = ViewMoveToMatchingBracketCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_ViewMoveToMatchingBracketCallback cb + cb'' <- mk_ViewMoveToMatchingBracketCallback cb' + connectSignalFunPtr obj "move-to-matching-bracket" cb'' connectMode + +data ViewMoveWordsSignalInfo +instance SignalInfo ViewMoveWordsSignalInfo where + type HaskellCallbackType ViewMoveWordsSignalInfo = ViewMoveWordsCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_ViewMoveWordsCallback cb + cb'' <- mk_ViewMoveWordsCallback cb' + connectSignalFunPtr obj "move-words" cb'' connectMode + +data ViewRedoSignalInfo +instance SignalInfo ViewRedoSignalInfo where + type HaskellCallbackType ViewRedoSignalInfo = ViewRedoCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_ViewRedoCallback cb + cb'' <- mk_ViewRedoCallback cb' + connectSignalFunPtr obj "redo" cb'' connectMode + +data ViewShowCompletionSignalInfo +instance SignalInfo ViewShowCompletionSignalInfo where + type HaskellCallbackType ViewShowCompletionSignalInfo = ViewShowCompletionCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_ViewShowCompletionCallback cb + cb'' <- mk_ViewShowCompletionCallback cb' + connectSignalFunPtr obj "show-completion" cb'' connectMode + +data ViewSmartHomeEndSignalInfo +instance SignalInfo ViewSmartHomeEndSignalInfo where + type HaskellCallbackType ViewSmartHomeEndSignalInfo = ViewSmartHomeEndCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_ViewSmartHomeEndCallback cb + cb'' <- mk_ViewSmartHomeEndCallback cb' + connectSignalFunPtr obj "smart-home-end" cb'' connectMode + +data ViewUndoSignalInfo +instance SignalInfo ViewUndoSignalInfo where + type HaskellCallbackType ViewUndoSignalInfo = ViewUndoCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_ViewUndoCallback cb + cb'' <- mk_ViewUndoCallback cb' + connectSignalFunPtr obj "undo" cb'' connectMode + +type instance O.SignalList View = ViewSignalList +type ViewSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("backspace", Gtk.TextView.TextViewBackspaceSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("changeCase", ViewChangeCaseSignalInfo), '("changeNumber", ViewChangeNumberSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("copyClipboard", Gtk.TextView.TextViewCopyClipboardSignalInfo), '("cutClipboard", Gtk.TextView.TextViewCutClipboardSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("deleteFromCursor", Gtk.TextView.TextViewDeleteFromCursorSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("extendSelection", Gtk.TextView.TextViewExtendSelectionSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("insertAtCursor", Gtk.TextView.TextViewInsertAtCursorSignalInfo), '("insertEmoji", Gtk.TextView.TextViewInsertEmojiSignalInfo), '("joinLines", ViewJoinLinesSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("lineMarkActivated", ViewLineMarkActivatedSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveCursor", Gtk.TextView.TextViewMoveCursorSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("moveLines", ViewMoveLinesSignalInfo), '("moveToMatchingBracket", ViewMoveToMatchingBracketSignalInfo), '("moveViewport", Gtk.TextView.TextViewMoveViewportSignalInfo), '("moveWords", ViewMoveWordsSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("pasteClipboard", Gtk.TextView.TextViewPasteClipboardSignalInfo), '("populatePopup", Gtk.TextView.TextViewPopulatePopupSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("preeditChanged", Gtk.TextView.TextViewPreeditChangedSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("redo", ViewRedoSignalInfo), '("remove", Gtk.Container.ContainerRemoveSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectAll", Gtk.TextView.TextViewSelectAllSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("setAnchor", Gtk.TextView.TextViewSetAnchorSignalInfo), '("setFocusChild", Gtk.Container.ContainerSetFocusChildSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showCompletion", ViewShowCompletionSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("smartHomeEnd", ViewSmartHomeEndSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("toggleCursorVisible", Gtk.TextView.TextViewToggleCursorVisibleSignalInfo), '("toggleOverwrite", Gtk.TextView.TextViewToggleOverwriteSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("undo", ViewUndoSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method View::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "View"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_view_new" gtk_source_view_new :: + IO (Ptr View) + +{- | +Creates a new 'GI.GtkSource.Objects.View.View'. + +By default, an empty 'GI.GtkSource.Objects.Buffer.Buffer' will be lazily created and can be +retrieved with 'GI.Gtk.Objects.TextView.textViewGetBuffer'. + +If you want to specify your own buffer, either override the +'GI.Gtk.Structs.TextViewClass.TextViewClass' create_buffer factory method, or use +'GI.GtkSource.Objects.View.viewNewWithBuffer'. +-} +viewNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m View + {- ^ __Returns:__ a new 'GI.GtkSource.Objects.View.View'. -} +viewNew = liftIO $ do + result <- gtk_source_view_new + checkUnexpectedReturnNULL "viewNew" result + result' <- (newObject View) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method View::new_with_buffer +-- method type : Constructor +-- 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 = "View"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_view_new_with_buffer" gtk_source_view_new_with_buffer :: + Ptr GtkSource.Buffer.Buffer -> -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"}) + IO (Ptr View) + +{- | +Creates a new 'GI.GtkSource.Objects.View.View' widget displaying the buffer +/@buffer@/. One buffer can be shared among many widgets. +-} +viewNewWithBuffer :: + (B.CallStack.HasCallStack, MonadIO m, GtkSource.Buffer.IsBuffer a) => + a + {- ^ /@buffer@/: a 'GI.GtkSource.Objects.Buffer.Buffer'. -} + -> m View + {- ^ __Returns:__ a new 'GI.GtkSource.Objects.View.View'. -} +viewNewWithBuffer buffer = liftIO $ do + buffer' <- unsafeManagedPtrCastPtr buffer + result <- gtk_source_view_new_with_buffer buffer' + checkUnexpectedReturnNULL "viewNewWithBuffer" result + result' <- (newObject View) result + touchManagedPtr buffer + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method View::get_auto_indent +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", 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_view_get_auto_indent" gtk_source_view_get_auto_indent :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + IO CInt + +{- | +Returns whether auto-indentation of text is enabled. +-} +viewGetAutoIndent :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> m Bool + {- ^ __Returns:__ 'True' if auto indentation is enabled. -} +viewGetAutoIndent view = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + result <- gtk_source_view_get_auto_indent view' + let result' = (/= 0) result + touchManagedPtr view + return result' + +#if ENABLE_OVERLOADING +data ViewGetAutoIndentMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsView a) => O.MethodInfo ViewGetAutoIndentMethodInfo a signature where + overloadedMethod _ = viewGetAutoIndent + +#endif + +-- method View::get_background_pattern +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "BackgroundPatternType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_view_get_background_pattern" gtk_source_view_get_background_pattern :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + IO CUInt + +{- | +Returns the 'GI.GtkSource.Enums.BackgroundPatternType' specifying if and how +the background pattern should be displayed for this /@view@/. + +/Since: 3.16/ +-} +viewGetBackgroundPattern :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View' -} + -> m GtkSource.Enums.BackgroundPatternType + {- ^ __Returns:__ the 'GI.GtkSource.Enums.BackgroundPatternType'. -} +viewGetBackgroundPattern view = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + result <- gtk_source_view_get_background_pattern view' + let result' = (toEnum . fromIntegral) result + touchManagedPtr view + return result' + +#if ENABLE_OVERLOADING +data ViewGetBackgroundPatternMethodInfo +instance (signature ~ (m GtkSource.Enums.BackgroundPatternType), MonadIO m, IsView a) => O.MethodInfo ViewGetBackgroundPatternMethodInfo a signature where + overloadedMethod _ = viewGetBackgroundPattern + +#endif + +-- method View::get_completion +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Completion"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_view_get_completion" gtk_source_view_get_completion :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + IO (Ptr GtkSource.Completion.Completion) + +{- | +Gets the 'GI.GtkSource.Objects.Completion.Completion' associated with /@view@/. The returned object is +guaranteed to be the same for the lifetime of /@view@/. Each 'GI.GtkSource.Objects.View.View' +object has a different 'GI.GtkSource.Objects.Completion.Completion'. +-} +viewGetCompletion :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> m GtkSource.Completion.Completion + {- ^ __Returns:__ the 'GI.GtkSource.Objects.Completion.Completion' associated with /@view@/. -} +viewGetCompletion view = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + result <- gtk_source_view_get_completion view' + checkUnexpectedReturnNULL "viewGetCompletion" result + result' <- (newObject GtkSource.Completion.Completion) result + touchManagedPtr view + return result' + +#if ENABLE_OVERLOADING +data ViewGetCompletionMethodInfo +instance (signature ~ (m GtkSource.Completion.Completion), MonadIO m, IsView a) => O.MethodInfo ViewGetCompletionMethodInfo a signature where + overloadedMethod _ = viewGetCompletion + +#endif + +-- method View::get_draw_spaces +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "DrawSpacesFlags"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_view_get_draw_spaces" gtk_source_view_get_draw_spaces :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + IO CUInt + +{-# DEPRECATED viewGetDrawSpaces ["(Since version 3.24)","Use 'GI.GtkSource.Objects.SpaceDrawer.spaceDrawerGetTypesForLocations'","instead."] #-} +{- | +Returns the 'GI.GtkSource.Flags.DrawSpacesFlags' specifying if and how spaces +should be displayed for this /@view@/. +-} +viewGetDrawSpaces :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View' -} + -> m [GtkSource.Flags.DrawSpacesFlags] + {- ^ __Returns:__ the 'GI.GtkSource.Flags.DrawSpacesFlags', 0 if no spaces should be drawn. -} +viewGetDrawSpaces view = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + result <- gtk_source_view_get_draw_spaces view' + let result' = wordToGFlags result + touchManagedPtr view + return result' + +#if ENABLE_OVERLOADING +data ViewGetDrawSpacesMethodInfo +instance (signature ~ (m [GtkSource.Flags.DrawSpacesFlags]), MonadIO m, IsView a) => O.MethodInfo ViewGetDrawSpacesMethodInfo a signature where + overloadedMethod _ = viewGetDrawSpaces + +#endif + +-- method View::get_gutter +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "window_type", argType = TInterface (Name {namespace = "Gtk", name = "TextWindowType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the gutter window type.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Gutter"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_view_get_gutter" gtk_source_view_get_gutter :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + CUInt -> -- window_type : TInterface (Name {namespace = "Gtk", name = "TextWindowType"}) + IO (Ptr GtkSource.Gutter.Gutter) + +{- | +Returns the 'GI.GtkSource.Objects.Gutter.Gutter' object associated with /@windowType@/ for /@view@/. +Only GTK_TEXT_WINDOW_LEFT and GTK_TEXT_WINDOW_RIGHT are supported, +respectively corresponding to the left and right gutter. The line numbers +and mark category icons are rendered in the left gutter. + +/Since: 2.8/ +-} +viewGetGutter :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> Gtk.Enums.TextWindowType + {- ^ /@windowType@/: the gutter window type. -} + -> m GtkSource.Gutter.Gutter + {- ^ __Returns:__ the 'GI.GtkSource.Objects.Gutter.Gutter'. -} +viewGetGutter view windowType = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + let windowType' = (fromIntegral . fromEnum) windowType + result <- gtk_source_view_get_gutter view' windowType' + checkUnexpectedReturnNULL "viewGetGutter" result + result' <- (newObject GtkSource.Gutter.Gutter) result + touchManagedPtr view + return result' + +#if ENABLE_OVERLOADING +data ViewGetGutterMethodInfo +instance (signature ~ (Gtk.Enums.TextWindowType -> m GtkSource.Gutter.Gutter), MonadIO m, IsView a) => O.MethodInfo ViewGetGutterMethodInfo a signature where + overloadedMethod _ = viewGetGutter + +#endif + +-- method View::get_highlight_current_line +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", 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_view_get_highlight_current_line" gtk_source_view_get_highlight_current_line :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + IO CInt + +{- | +Returns whether the current line is highlighted. +-} +viewGetHighlightCurrentLine :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> m Bool + {- ^ __Returns:__ 'True' if the current line is highlighted. -} +viewGetHighlightCurrentLine view = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + result <- gtk_source_view_get_highlight_current_line view' + let result' = (/= 0) result + touchManagedPtr view + return result' + +#if ENABLE_OVERLOADING +data ViewGetHighlightCurrentLineMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsView a) => O.MethodInfo ViewGetHighlightCurrentLineMethodInfo a signature where + overloadedMethod _ = viewGetHighlightCurrentLine + +#endif + +-- method View::get_indent_on_tab +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", 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_view_get_indent_on_tab" gtk_source_view_get_indent_on_tab :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + IO CInt + +{- | +Returns whether when the tab key is pressed the current selection +should get indented instead of replaced with the \\t character. +-} +viewGetIndentOnTab :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> m Bool + {- ^ __Returns:__ 'True' if the selection is indented when tab is pressed. -} +viewGetIndentOnTab view = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + result <- gtk_source_view_get_indent_on_tab view' + let result' = (/= 0) result + touchManagedPtr view + return result' + +#if ENABLE_OVERLOADING +data ViewGetIndentOnTabMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsView a) => O.MethodInfo ViewGetIndentOnTabMethodInfo a signature where + overloadedMethod _ = viewGetIndentOnTab + +#endif + +-- method View::get_indent_width +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", 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_view_get_indent_width" gtk_source_view_get_indent_width :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + IO Int32 + +{- | +Returns the number of spaces to use for each step of indent. +See 'GI.GtkSource.Objects.View.viewSetIndentWidth' for details. +-} +viewGetIndentWidth :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> m Int32 + {- ^ __Returns:__ indent width. -} +viewGetIndentWidth view = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + result <- gtk_source_view_get_indent_width view' + touchManagedPtr view + return result + +#if ENABLE_OVERLOADING +data ViewGetIndentWidthMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsView a) => O.MethodInfo ViewGetIndentWidthMethodInfo a signature where + overloadedMethod _ = viewGetIndentWidth + +#endif + +-- method View::get_insert_spaces_instead_of_tabs +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", 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_view_get_insert_spaces_instead_of_tabs" gtk_source_view_get_insert_spaces_instead_of_tabs :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + IO CInt + +{- | +Returns whether when inserting a tabulator character it should +be replaced by a group of space characters. +-} +viewGetInsertSpacesInsteadOfTabs :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> m Bool + {- ^ __Returns:__ 'True' if spaces are inserted instead of tabs. -} +viewGetInsertSpacesInsteadOfTabs view = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + result <- gtk_source_view_get_insert_spaces_instead_of_tabs view' + let result' = (/= 0) result + touchManagedPtr view + return result' + +#if ENABLE_OVERLOADING +data ViewGetInsertSpacesInsteadOfTabsMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsView a) => O.MethodInfo ViewGetInsertSpacesInsteadOfTabsMethodInfo a signature where + overloadedMethod _ = viewGetInsertSpacesInsteadOfTabs + +#endif + +-- method View::get_mark_attributes +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", 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 "the category.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "place where priority of the category will be stored.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_view_get_mark_attributes" gtk_source_view_get_mark_attributes :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + CString -> -- category : TBasicType TUTF8 + Int32 -> -- priority : TBasicType TInt + IO (Ptr GtkSource.MarkAttributes.MarkAttributes) + +{- | +Gets attributes and priority for the /@category@/. +-} +viewGetMarkAttributes :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> T.Text + {- ^ /@category@/: the category. -} + -> Int32 + {- ^ /@priority@/: place where priority of the category will be stored. -} + -> m GtkSource.MarkAttributes.MarkAttributes + {- ^ __Returns:__ 'GI.GtkSource.Objects.MarkAttributes.MarkAttributes' for the /@category@/. +The object belongs to /@view@/, so it must not be unreffed. -} +viewGetMarkAttributes view category priority = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + category' <- textToCString category + result <- gtk_source_view_get_mark_attributes view' category' priority + checkUnexpectedReturnNULL "viewGetMarkAttributes" result + result' <- (newObject GtkSource.MarkAttributes.MarkAttributes) result + touchManagedPtr view + freeMem category' + return result' + +#if ENABLE_OVERLOADING +data ViewGetMarkAttributesMethodInfo +instance (signature ~ (T.Text -> Int32 -> m GtkSource.MarkAttributes.MarkAttributes), MonadIO m, IsView a) => O.MethodInfo ViewGetMarkAttributesMethodInfo a signature where + overloadedMethod _ = viewGetMarkAttributes + +#endif + +-- method View::get_right_margin_position +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", 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_view_get_right_margin_position" gtk_source_view_get_right_margin_position :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + IO Word32 + +{- | +Gets the position of the right margin in the given /@view@/. +-} +viewGetRightMarginPosition :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> m Word32 + {- ^ __Returns:__ the position of the right margin. -} +viewGetRightMarginPosition view = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + result <- gtk_source_view_get_right_margin_position view' + touchManagedPtr view + return result + +#if ENABLE_OVERLOADING +data ViewGetRightMarginPositionMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsView a) => O.MethodInfo ViewGetRightMarginPositionMethodInfo a signature where + overloadedMethod _ = viewGetRightMarginPosition + +#endif + +-- method View::get_show_line_marks +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", 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_view_get_show_line_marks" gtk_source_view_get_show_line_marks :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + IO CInt + +{- | +Returns whether line marks are displayed beside the text. + +/Since: 2.2/ +-} +viewGetShowLineMarks :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> m Bool + {- ^ __Returns:__ 'True' if the line marks are displayed. -} +viewGetShowLineMarks view = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + result <- gtk_source_view_get_show_line_marks view' + let result' = (/= 0) result + touchManagedPtr view + return result' + +#if ENABLE_OVERLOADING +data ViewGetShowLineMarksMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsView a) => O.MethodInfo ViewGetShowLineMarksMethodInfo a signature where + overloadedMethod _ = viewGetShowLineMarks + +#endif + +-- method View::get_show_line_numbers +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", 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_view_get_show_line_numbers" gtk_source_view_get_show_line_numbers :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + IO CInt + +{- | +Returns whether line numbers are displayed beside the text. +-} +viewGetShowLineNumbers :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> m Bool + {- ^ __Returns:__ 'True' if the line numbers are displayed. -} +viewGetShowLineNumbers view = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + result <- gtk_source_view_get_show_line_numbers view' + let result' = (/= 0) result + touchManagedPtr view + return result' + +#if ENABLE_OVERLOADING +data ViewGetShowLineNumbersMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsView a) => O.MethodInfo ViewGetShowLineNumbersMethodInfo a signature where + overloadedMethod _ = viewGetShowLineNumbers + +#endif + +-- method View::get_show_right_margin +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", 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_view_get_show_right_margin" gtk_source_view_get_show_right_margin :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + IO CInt + +{- | +Returns whether a right margin is displayed. +-} +viewGetShowRightMargin :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> m Bool + {- ^ __Returns:__ 'True' if the right margin is shown. -} +viewGetShowRightMargin view = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + result <- gtk_source_view_get_show_right_margin view' + let result' = (/= 0) result + touchManagedPtr view + return result' + +#if ENABLE_OVERLOADING +data ViewGetShowRightMarginMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsView a) => O.MethodInfo ViewGetShowRightMarginMethodInfo a signature where + overloadedMethod _ = viewGetShowRightMargin + +#endif + +-- method View::get_smart_backspace +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", 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_view_get_smart_backspace" gtk_source_view_get_smart_backspace :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + IO CInt + +{- | +Returns 'True' if pressing the Backspace key will try to delete spaces +up to the previous tab stop. + +/Since: 3.18/ +-} +viewGetSmartBackspace :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> m Bool + {- ^ __Returns:__ 'True' if smart Backspace handling is enabled. -} +viewGetSmartBackspace view = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + result <- gtk_source_view_get_smart_backspace view' + let result' = (/= 0) result + touchManagedPtr view + return result' + +#if ENABLE_OVERLOADING +data ViewGetSmartBackspaceMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsView a) => O.MethodInfo ViewGetSmartBackspaceMethodInfo a signature where + overloadedMethod _ = viewGetSmartBackspace + +#endif + +-- method View::get_smart_home_end +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "SmartHomeEndType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_view_get_smart_home_end" gtk_source_view_get_smart_home_end :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + IO CUInt + +{- | +Returns a 'GI.GtkSource.Enums.SmartHomeEndType' end value specifying +how the cursor will move when HOME and END keys are pressed. +-} +viewGetSmartHomeEnd :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> m GtkSource.Enums.SmartHomeEndType + {- ^ __Returns:__ a 'GI.GtkSource.Enums.SmartHomeEndType' value. -} +viewGetSmartHomeEnd view = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + result <- gtk_source_view_get_smart_home_end view' + let result' = (toEnum . fromIntegral) result + touchManagedPtr view + return result' + +#if ENABLE_OVERLOADING +data ViewGetSmartHomeEndMethodInfo +instance (signature ~ (m GtkSource.Enums.SmartHomeEndType), MonadIO m, IsView a) => O.MethodInfo ViewGetSmartHomeEndMethodInfo a signature where + overloadedMethod _ = viewGetSmartHomeEnd + +#endif + +-- method View::get_space_drawer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "SpaceDrawer"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_view_get_space_drawer" gtk_source_view_get_space_drawer :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + IO (Ptr GtkSource.SpaceDrawer.SpaceDrawer) + +{- | +Gets the 'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer' associated with /@view@/. The returned object is +guaranteed to be the same for the lifetime of /@view@/. Each 'GI.GtkSource.Objects.View.View' +object has a different 'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer'. + +/Since: 3.24/ +-} +viewGetSpaceDrawer :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> m GtkSource.SpaceDrawer.SpaceDrawer + {- ^ __Returns:__ the 'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer' associated with /@view@/. -} +viewGetSpaceDrawer view = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + result <- gtk_source_view_get_space_drawer view' + checkUnexpectedReturnNULL "viewGetSpaceDrawer" result + result' <- (newObject GtkSource.SpaceDrawer.SpaceDrawer) result + touchManagedPtr view + return result' + +#if ENABLE_OVERLOADING +data ViewGetSpaceDrawerMethodInfo +instance (signature ~ (m GtkSource.SpaceDrawer.SpaceDrawer), MonadIO m, IsView a) => O.MethodInfo ViewGetSpaceDrawerMethodInfo a signature where + overloadedMethod _ = viewGetSpaceDrawer + +#endif + +-- method View::get_tab_width +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", 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_view_get_tab_width" gtk_source_view_get_tab_width :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + IO Word32 + +{- | +Returns the width of tabulation in characters. +-} +viewGetTabWidth :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> m Word32 + {- ^ __Returns:__ width of tab. -} +viewGetTabWidth view = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + result <- gtk_source_view_get_tab_width view' + touchManagedPtr view + return result + +#if ENABLE_OVERLOADING +data ViewGetTabWidthMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsView a) => O.MethodInfo ViewGetTabWidthMethodInfo a signature where + overloadedMethod _ = viewGetTabWidth + +#endif + +-- method View::get_visual_column +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a position in @view.", 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_view_get_visual_column" gtk_source_view_get_visual_column :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + Ptr Gtk.TextIter.TextIter -> -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + IO Word32 + +{- | +Determines the visual column at /@iter@/ taking into consideration the +'GI.GtkSource.Objects.View.View':@/tab-width/@ of /@view@/. +-} +viewGetVisualColumn :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> Gtk.TextIter.TextIter + {- ^ /@iter@/: a position in /@view@/. -} + -> m Word32 + {- ^ __Returns:__ the visual column at /@iter@/. -} +viewGetVisualColumn view iter = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + iter' <- unsafeManagedPtrGetPtr iter + result <- gtk_source_view_get_visual_column view' iter' + touchManagedPtr view + touchManagedPtr iter + return result + +#if ENABLE_OVERLOADING +data ViewGetVisualColumnMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> m Word32), MonadIO m, IsView a) => O.MethodInfo ViewGetVisualColumnMethodInfo a signature where + overloadedMethod _ = viewGetVisualColumn + +#endif + +-- method View::indent_lines +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", 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 "#GtkTextIter of the first line to indent", 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 "#GtkTextIter of the last line to indent", 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_view_indent_lines" gtk_source_view_indent_lines :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + Ptr Gtk.TextIter.TextIter -> -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + IO () + +{- | +Inserts one indentation level at the beginning of the specified lines. The +empty lines are not indented. + +/Since: 3.16/ +-} +viewIndentLines :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> Gtk.TextIter.TextIter + {- ^ /@start@/: 'GI.Gtk.Structs.TextIter.TextIter' of the first line to indent -} + -> Gtk.TextIter.TextIter + {- ^ /@end@/: 'GI.Gtk.Structs.TextIter.TextIter' of the last line to indent -} + -> m () +viewIndentLines view start end = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + start' <- unsafeManagedPtrGetPtr start + end' <- unsafeManagedPtrGetPtr end + gtk_source_view_indent_lines view' start' end' + touchManagedPtr view + touchManagedPtr start + touchManagedPtr end + return () + +#if ENABLE_OVERLOADING +data ViewIndentLinesMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> m ()), MonadIO m, IsView a) => O.MethodInfo ViewIndentLinesMethodInfo a signature where + overloadedMethod _ = viewIndentLines + +#endif + +-- method View::set_auto_indent +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to enable auto indentation.", 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_view_set_auto_indent" gtk_source_view_set_auto_indent :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + CInt -> -- enable : TBasicType TBoolean + IO () + +{- | +If 'True' auto-indentation of text is enabled. + +When Enter is pressed to create a new line, the auto-indentation inserts the +same indentation as the previous line. This is \not\<\/emphasis> a +\"smart indentation\" where an indentation level is added or removed depending +on the context. +-} +viewSetAutoIndent :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> Bool + {- ^ /@enable@/: whether to enable auto indentation. -} + -> m () +viewSetAutoIndent view enable = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + let enable' = (fromIntegral . fromEnum) enable + gtk_source_view_set_auto_indent view' enable' + touchManagedPtr view + return () + +#if ENABLE_OVERLOADING +data ViewSetAutoIndentMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsView a) => O.MethodInfo ViewSetAutoIndentMethodInfo a signature where + overloadedMethod _ = viewSetAutoIndent + +#endif + +-- method View::set_background_pattern +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "background_pattern", argType = TInterface (Name {namespace = "GtkSource", name = "BackgroundPatternType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkSourceBackgroundPatternType.", 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_view_set_background_pattern" gtk_source_view_set_background_pattern :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + CUInt -> -- background_pattern : TInterface (Name {namespace = "GtkSource", name = "BackgroundPatternType"}) + IO () + +{- | +Set if and how the background pattern should be displayed. + +/Since: 3.16/ +-} +viewSetBackgroundPattern :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> GtkSource.Enums.BackgroundPatternType + {- ^ /@backgroundPattern@/: the 'GI.GtkSource.Enums.BackgroundPatternType'. -} + -> m () +viewSetBackgroundPattern view backgroundPattern = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + let backgroundPattern' = (fromIntegral . fromEnum) backgroundPattern + gtk_source_view_set_background_pattern view' backgroundPattern' + touchManagedPtr view + return () + +#if ENABLE_OVERLOADING +data ViewSetBackgroundPatternMethodInfo +instance (signature ~ (GtkSource.Enums.BackgroundPatternType -> m ()), MonadIO m, IsView a) => O.MethodInfo ViewSetBackgroundPatternMethodInfo a signature where + overloadedMethod _ = viewSetBackgroundPattern + +#endif + +-- method View::set_draw_spaces +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GtkSource", name = "DrawSpacesFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GtkSourceDrawSpacesFlags specifing how white spaces should\nbe displayed", 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_view_set_draw_spaces" gtk_source_view_set_draw_spaces :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + CUInt -> -- flags : TInterface (Name {namespace = "GtkSource", name = "DrawSpacesFlags"}) + IO () + +{-# DEPRECATED viewSetDrawSpaces ["(Since version 3.24)","Use 'GI.GtkSource.Objects.SpaceDrawer.spaceDrawerSetTypesForLocations'","instead."] #-} +{- | +Set if and how the spaces should be visualized. Specifying /@flags@/ as 0 will +disable display of spaces. + +For a finer-grained method, there is also the GtkSourceTag\'s +'GI.GtkSource.Objects.Tag.Tag':@/draw-spaces/@ property. +-} +viewSetDrawSpaces :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> [GtkSource.Flags.DrawSpacesFlags] + {- ^ /@flags@/: 'GI.GtkSource.Flags.DrawSpacesFlags' specifing how white spaces should +be displayed -} + -> m () +viewSetDrawSpaces view flags = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + let flags' = gflagsToWord flags + gtk_source_view_set_draw_spaces view' flags' + touchManagedPtr view + return () + +#if ENABLE_OVERLOADING +data ViewSetDrawSpacesMethodInfo +instance (signature ~ ([GtkSource.Flags.DrawSpacesFlags] -> m ()), MonadIO m, IsView a) => O.MethodInfo ViewSetDrawSpacesMethodInfo a signature where + overloadedMethod _ = viewSetDrawSpaces + +#endif + +-- method View::set_highlight_current_line +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", 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 "whether to highlight the current line.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_view_set_highlight_current_line" gtk_source_view_set_highlight_current_line :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + CInt -> -- highlight : TBasicType TBoolean + IO () + +{- | +If /@highlight@/ is 'True' the current line will be highlighted. +-} +viewSetHighlightCurrentLine :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> Bool + {- ^ /@highlight@/: whether to highlight the current line. -} + -> m () +viewSetHighlightCurrentLine view highlight = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + let highlight' = (fromIntegral . fromEnum) highlight + gtk_source_view_set_highlight_current_line view' highlight' + touchManagedPtr view + return () + +#if ENABLE_OVERLOADING +data ViewSetHighlightCurrentLineMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsView a) => O.MethodInfo ViewSetHighlightCurrentLineMethodInfo a signature where + overloadedMethod _ = viewSetHighlightCurrentLine + +#endif + +-- method View::set_indent_on_tab +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to indent a block when tab is pressed.", 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_view_set_indent_on_tab" gtk_source_view_set_indent_on_tab :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + CInt -> -- enable : TBasicType TBoolean + IO () + +{- | +If 'True', when the tab key is pressed when several lines are selected, the +selected lines are indented of one level instead of being replaced with a \\t +character. Shift+Tab unindents the selection. + +If the first or last line is not selected completely, it is also indented or +unindented. + +When the selection doesn\'t span several lines, the tab key always replaces +the selection with a normal \\t character. +-} +viewSetIndentOnTab :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> Bool + {- ^ /@enable@/: whether to indent a block when tab is pressed. -} + -> m () +viewSetIndentOnTab view enable = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + let enable' = (fromIntegral . fromEnum) enable + gtk_source_view_set_indent_on_tab view' enable' + touchManagedPtr view + return () + +#if ENABLE_OVERLOADING +data ViewSetIndentOnTabMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsView a) => O.MethodInfo ViewSetIndentOnTabMethodInfo a signature where + overloadedMethod _ = viewSetIndentOnTab + +#endif + +-- method View::set_indent_width +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "indent width in characters.", 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_view_set_indent_width" gtk_source_view_set_indent_width :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + Int32 -> -- width : TBasicType TInt + IO () + +{- | +Sets the number of spaces to use for each step of indent when the tab key is +pressed. If /@width@/ is -1, the value of the 'GI.GtkSource.Objects.View.View':@/tab-width/@ property +will be used. + +The 'GI.GtkSource.Objects.View.View':@/indent-width/@ interacts with the +'GI.GtkSource.Objects.View.View':@/insert-spaces-instead-of-tabs/@ property and +'GI.GtkSource.Objects.View.View':@/tab-width/@. An example will be clearer: if the +'GI.GtkSource.Objects.View.View':@/indent-width/@ is 4 and +'GI.GtkSource.Objects.View.View':@/tab-width/@ is 8 and +'GI.GtkSource.Objects.View.View':@/insert-spaces-instead-of-tabs/@ is 'False', then pressing the tab +key at the beginning of a line will insert 4 spaces. So far so good. Pressing +the tab key a second time will remove the 4 spaces and insert a \\t character +instead (since 'GI.GtkSource.Objects.View.View':@/tab-width/@ is 8). On the other hand, if +'GI.GtkSource.Objects.View.View':@/insert-spaces-instead-of-tabs/@ is 'True', the second tab key +pressed will insert 4 more spaces for a total of 8 spaces in the +'GI.Gtk.Objects.TextBuffer.TextBuffer'. + +The test-widget program (available in the GtkSourceView repository) may be +useful to better understand the indentation settings (enable the space +drawing!). +-} +viewSetIndentWidth :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> Int32 + {- ^ /@width@/: indent width in characters. -} + -> m () +viewSetIndentWidth view width = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + gtk_source_view_set_indent_width view' width + touchManagedPtr view + return () + +#if ENABLE_OVERLOADING +data ViewSetIndentWidthMethodInfo +instance (signature ~ (Int32 -> m ()), MonadIO m, IsView a) => O.MethodInfo ViewSetIndentWidthMethodInfo a signature where + overloadedMethod _ = viewSetIndentWidth + +#endif + +-- method View::set_insert_spaces_instead_of_tabs +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to insert spaces instead of tabs.", 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_view_set_insert_spaces_instead_of_tabs" gtk_source_view_set_insert_spaces_instead_of_tabs :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + CInt -> -- enable : TBasicType TBoolean + IO () + +{- | +If 'True' a tab key pressed is replaced by a group of space characters. Of +course it is still possible to insert a real \\t programmatically with the +'GI.Gtk.Objects.TextBuffer.TextBuffer' API. +-} +viewSetInsertSpacesInsteadOfTabs :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> Bool + {- ^ /@enable@/: whether to insert spaces instead of tabs. -} + -> m () +viewSetInsertSpacesInsteadOfTabs view enable = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + let enable' = (fromIntegral . fromEnum) enable + gtk_source_view_set_insert_spaces_instead_of_tabs view' enable' + touchManagedPtr view + return () + +#if ENABLE_OVERLOADING +data ViewSetInsertSpacesInsteadOfTabsMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsView a) => O.MethodInfo ViewSetInsertSpacesInsteadOfTabsMethodInfo a signature where + overloadedMethod _ = viewSetInsertSpacesInsteadOfTabs + +#endif + +-- method View::set_mark_attributes +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", 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 "the category.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "attributes", argType = TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "mark attributes.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "priority of the category.", 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_view_set_mark_attributes" gtk_source_view_set_mark_attributes :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + CString -> -- category : TBasicType TUTF8 + Ptr GtkSource.MarkAttributes.MarkAttributes -> -- attributes : TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"}) + Int32 -> -- priority : TBasicType TInt + IO () + +{- | +Sets attributes and priority for the /@category@/. +-} +viewSetMarkAttributes :: + (B.CallStack.HasCallStack, MonadIO m, IsView a, GtkSource.MarkAttributes.IsMarkAttributes b) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> T.Text + {- ^ /@category@/: the category. -} + -> b + {- ^ /@attributes@/: mark attributes. -} + -> Int32 + {- ^ /@priority@/: priority of the category. -} + -> m () +viewSetMarkAttributes view category attributes priority = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + category' <- textToCString category + attributes' <- unsafeManagedPtrCastPtr attributes + gtk_source_view_set_mark_attributes view' category' attributes' priority + touchManagedPtr view + touchManagedPtr attributes + freeMem category' + return () + +#if ENABLE_OVERLOADING +data ViewSetMarkAttributesMethodInfo +instance (signature ~ (T.Text -> b -> Int32 -> m ()), MonadIO m, IsView a, GtkSource.MarkAttributes.IsMarkAttributes b) => O.MethodInfo ViewSetMarkAttributesMethodInfo a signature where + overloadedMethod _ = viewSetMarkAttributes + +#endif + +-- method View::set_right_margin_position +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pos", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the width in characters where to position the right margin.", 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_view_set_right_margin_position" gtk_source_view_set_right_margin_position :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + Word32 -> -- pos : TBasicType TUInt + IO () + +{- | +Sets the position of the right margin in the given /@view@/. +-} +viewSetRightMarginPosition :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> Word32 + {- ^ /@pos@/: the width in characters where to position the right margin. -} + -> m () +viewSetRightMarginPosition view pos = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + gtk_source_view_set_right_margin_position view' pos + touchManagedPtr view + return () + +#if ENABLE_OVERLOADING +data ViewSetRightMarginPositionMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m, IsView a) => O.MethodInfo ViewSetRightMarginPositionMethodInfo a signature where + overloadedMethod _ = viewSetRightMarginPosition + +#endif + +-- method View::set_show_line_marks +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "show", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether line marks should be displayed.", 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_view_set_show_line_marks" gtk_source_view_set_show_line_marks :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + CInt -> -- show : TBasicType TBoolean + IO () + +{- | +If 'True' line marks will be displayed beside the text. + +/Since: 2.2/ +-} +viewSetShowLineMarks :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> Bool + {- ^ /@show@/: whether line marks should be displayed. -} + -> m () +viewSetShowLineMarks view show_ = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + let show_' = (fromIntegral . fromEnum) show_ + gtk_source_view_set_show_line_marks view' show_' + touchManagedPtr view + return () + +#if ENABLE_OVERLOADING +data ViewSetShowLineMarksMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsView a) => O.MethodInfo ViewSetShowLineMarksMethodInfo a signature where + overloadedMethod _ = viewSetShowLineMarks + +#endif + +-- method View::set_show_line_numbers +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "show", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether line numbers should be displayed.", 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_view_set_show_line_numbers" gtk_source_view_set_show_line_numbers :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + CInt -> -- show : TBasicType TBoolean + IO () + +{- | +If 'True' line numbers will be displayed beside the text. +-} +viewSetShowLineNumbers :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> Bool + {- ^ /@show@/: whether line numbers should be displayed. -} + -> m () +viewSetShowLineNumbers view show_ = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + let show_' = (fromIntegral . fromEnum) show_ + gtk_source_view_set_show_line_numbers view' show_' + touchManagedPtr view + return () + +#if ENABLE_OVERLOADING +data ViewSetShowLineNumbersMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsView a) => O.MethodInfo ViewSetShowLineNumbersMethodInfo a signature where + overloadedMethod _ = viewSetShowLineNumbers + +#endif + +-- method View::set_show_right_margin +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "show", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to show a right margin.", 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_view_set_show_right_margin" gtk_source_view_set_show_right_margin :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + CInt -> -- show : TBasicType TBoolean + IO () + +{- | +If 'True' a right margin is displayed. +-} +viewSetShowRightMargin :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> Bool + {- ^ /@show@/: whether to show a right margin. -} + -> m () +viewSetShowRightMargin view show_ = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + let show_' = (fromIntegral . fromEnum) show_ + gtk_source_view_set_show_right_margin view' show_' + touchManagedPtr view + return () + +#if ENABLE_OVERLOADING +data ViewSetShowRightMarginMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsView a) => O.MethodInfo ViewSetShowRightMarginMethodInfo a signature where + overloadedMethod _ = viewSetShowRightMargin + +#endif + +-- method View::set_smart_backspace +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "smart_backspace", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to enable smart Backspace handling.", 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_view_set_smart_backspace" gtk_source_view_set_smart_backspace :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + CInt -> -- smart_backspace : TBasicType TBoolean + IO () + +{- | +When set to 'True', pressing the Backspace key will try to delete spaces +up to the previous tab stop. + +/Since: 3.18/ +-} +viewSetSmartBackspace :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> Bool + {- ^ /@smartBackspace@/: whether to enable smart Backspace handling. -} + -> m () +viewSetSmartBackspace view smartBackspace = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + let smartBackspace' = (fromIntegral . fromEnum) smartBackspace + gtk_source_view_set_smart_backspace view' smartBackspace' + touchManagedPtr view + return () + +#if ENABLE_OVERLOADING +data ViewSetSmartBackspaceMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsView a) => O.MethodInfo ViewSetSmartBackspaceMethodInfo a signature where + overloadedMethod _ = viewSetSmartBackspace + +#endif + +-- method View::set_smart_home_end +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "smart_home_end", argType = TInterface (Name {namespace = "GtkSource", name = "SmartHomeEndType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the desired behavior among #GtkSourceSmartHomeEndType.", 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_view_set_smart_home_end" gtk_source_view_set_smart_home_end :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + CUInt -> -- smart_home_end : TInterface (Name {namespace = "GtkSource", name = "SmartHomeEndType"}) + IO () + +{- | +Set the desired movement of the cursor when HOME and END keys +are pressed. +-} +viewSetSmartHomeEnd :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> GtkSource.Enums.SmartHomeEndType + {- ^ /@smartHomeEnd@/: the desired behavior among 'GI.GtkSource.Enums.SmartHomeEndType'. -} + -> m () +viewSetSmartHomeEnd view smartHomeEnd = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + let smartHomeEnd' = (fromIntegral . fromEnum) smartHomeEnd + gtk_source_view_set_smart_home_end view' smartHomeEnd' + touchManagedPtr view + return () + +#if ENABLE_OVERLOADING +data ViewSetSmartHomeEndMethodInfo +instance (signature ~ (GtkSource.Enums.SmartHomeEndType -> m ()), MonadIO m, IsView a) => O.MethodInfo ViewSetSmartHomeEndMethodInfo a signature where + overloadedMethod _ = viewSetSmartHomeEnd + +#endif + +-- method View::set_tab_width +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "width of tab in characters.", 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_view_set_tab_width" gtk_source_view_set_tab_width :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + Word32 -> -- width : TBasicType TUInt + IO () + +{- | +Sets the width of tabulation in characters. The 'GI.Gtk.Objects.TextBuffer.TextBuffer' still contains +\\t characters, but they can take a different visual width in a 'GI.GtkSource.Objects.View.View' +widget. +-} +viewSetTabWidth :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> Word32 + {- ^ /@width@/: width of tab in characters. -} + -> m () +viewSetTabWidth view width = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + gtk_source_view_set_tab_width view' width + touchManagedPtr view + return () + +#if ENABLE_OVERLOADING +data ViewSetTabWidthMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m, IsView a) => O.MethodInfo ViewSetTabWidthMethodInfo a signature where + overloadedMethod _ = viewSetTabWidth + +#endif + +-- method View::unindent_lines +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "view", argType = TInterface (Name {namespace = "GtkSource", name = "View"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceView.", 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 "#GtkTextIter of the first line to indent", 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 "#GtkTextIter of the last line to indent", 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_view_unindent_lines" gtk_source_view_unindent_lines :: + Ptr View -> -- view : TInterface (Name {namespace = "GtkSource", name = "View"}) + Ptr Gtk.TextIter.TextIter -> -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + IO () + +{- | +Removes one indentation level at the beginning of the +specified lines. + +/Since: 3.16/ +-} +viewUnindentLines :: + (B.CallStack.HasCallStack, MonadIO m, IsView a) => + a + {- ^ /@view@/: a 'GI.GtkSource.Objects.View.View'. -} + -> Gtk.TextIter.TextIter + {- ^ /@start@/: 'GI.Gtk.Structs.TextIter.TextIter' of the first line to indent -} + -> Gtk.TextIter.TextIter + {- ^ /@end@/: 'GI.Gtk.Structs.TextIter.TextIter' of the last line to indent -} + -> m () +viewUnindentLines view start end = liftIO $ do + view' <- unsafeManagedPtrCastPtr view + start' <- unsafeManagedPtrGetPtr start + end' <- unsafeManagedPtrGetPtr end + gtk_source_view_unindent_lines view' start' end' + touchManagedPtr view + touchManagedPtr start + touchManagedPtr end + return () + +#if ENABLE_OVERLOADING +data ViewUnindentLinesMethodInfo +instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> m ()), MonadIO m, IsView a) => O.MethodInfo ViewUnindentLinesMethodInfo a signature where + overloadedMethod _ = viewUnindentLines + +#endif + + diff --git a/GI/GtkSource/Objects/View.hs-boot b/GI/GtkSource/Objects/View.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Objects/View.hs-boot @@ -0,0 +1,218 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Objects.View 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 View = View (ManagedPtr View) +instance GObject View where +class (GObject o, O.IsDescendantOf View o) => IsView o +instance (GObject o, O.IsDescendantOf View o) => IsView o +instance O.HasParentTypes View +#if ENABLE_OVERLOADING +data ViewAutoIndentPropertyInfo +#endif +#if ENABLE_OVERLOADING +data ViewBackgroundPatternPropertyInfo +#endif +#if ENABLE_OVERLOADING +data ViewCompletionPropertyInfo +#endif +#if ENABLE_OVERLOADING +data ViewDrawSpacesPropertyInfo +#endif +#if ENABLE_OVERLOADING +data ViewHighlightCurrentLinePropertyInfo +#endif +#if ENABLE_OVERLOADING +data ViewIndentOnTabPropertyInfo +#endif +#if ENABLE_OVERLOADING +data ViewIndentWidthPropertyInfo +#endif +#if ENABLE_OVERLOADING +data ViewInsertSpacesInsteadOfTabsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data ViewRightMarginPositionPropertyInfo +#endif +#if ENABLE_OVERLOADING +data ViewShowLineMarksPropertyInfo +#endif +#if ENABLE_OVERLOADING +data ViewShowLineNumbersPropertyInfo +#endif +#if ENABLE_OVERLOADING +data ViewShowRightMarginPropertyInfo +#endif +#if ENABLE_OVERLOADING +data ViewSmartBackspacePropertyInfo +#endif +#if ENABLE_OVERLOADING +data ViewSmartHomeEndPropertyInfo +#endif +#if ENABLE_OVERLOADING +data ViewSpaceDrawerPropertyInfo +#endif +#if ENABLE_OVERLOADING +data ViewTabWidthPropertyInfo +#endif +#if ENABLE_OVERLOADING +data ViewChangeCaseSignalInfo +#endif +#if ENABLE_OVERLOADING +data ViewChangeNumberSignalInfo +#endif +#if ENABLE_OVERLOADING +data ViewJoinLinesSignalInfo +#endif +#if ENABLE_OVERLOADING +data ViewLineMarkActivatedSignalInfo +#endif +#if ENABLE_OVERLOADING +data ViewMoveLinesSignalInfo +#endif +#if ENABLE_OVERLOADING +data ViewMoveToMatchingBracketSignalInfo +#endif +#if ENABLE_OVERLOADING +data ViewMoveWordsSignalInfo +#endif +#if ENABLE_OVERLOADING +data ViewRedoSignalInfo +#endif +#if ENABLE_OVERLOADING +data ViewShowCompletionSignalInfo +#endif +#if ENABLE_OVERLOADING +data ViewSmartHomeEndSignalInfo +#endif +#if ENABLE_OVERLOADING +data ViewUndoSignalInfo +#endif +#if ENABLE_OVERLOADING +data ViewGetAutoIndentMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewGetBackgroundPatternMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewGetCompletionMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewGetDrawSpacesMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewGetGutterMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewGetHighlightCurrentLineMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewGetIndentOnTabMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewGetIndentWidthMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewGetInsertSpacesInsteadOfTabsMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewGetMarkAttributesMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewGetRightMarginPositionMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewGetShowLineMarksMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewGetShowLineNumbersMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewGetShowRightMarginMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewGetSmartBackspaceMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewGetSmartHomeEndMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewGetSpaceDrawerMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewGetTabWidthMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewGetVisualColumnMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewIndentLinesMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewSetAutoIndentMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewSetBackgroundPatternMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewSetDrawSpacesMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewSetHighlightCurrentLineMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewSetIndentOnTabMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewSetIndentWidthMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewSetInsertSpacesInsteadOfTabsMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewSetMarkAttributesMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewSetRightMarginPositionMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewSetShowLineMarksMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewSetShowLineNumbersMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewSetShowRightMarginMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewSetSmartBackspaceMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewSetSmartHomeEndMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewSetTabWidthMethodInfo +#endif +#if ENABLE_OVERLOADING +data ViewUnindentLinesMethodInfo +#endif diff --git a/GI/GtkSource/Structs.hs b/GI/GtkSource/Structs.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Structs.hs @@ -0,0 +1,43 @@ + + +{- | +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.Structs + ( module GI.GtkSource.Structs.Encoding , + module GI.GtkSource.Structs.RegionIter , + + + ) where + +import GI.GtkSource.Structs.Encoding +import GI.GtkSource.Structs.RegionIter + +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 + + + diff --git a/GI/GtkSource/Structs/Encoding.hs b/GI/GtkSource/Structs/Encoding.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Structs/Encoding.hs @@ -0,0 +1,501 @@ + + +{- | +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.Structs.Encoding + ( + +-- * Exported types + Encoding(..) , + noEncoding , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + EncodingCopyMethodInfo , +#endif + encodingCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + EncodingFreeMethodInfo , +#endif + encodingFree , + + +-- ** getAll #method:getAll# + + encodingGetAll , + + +-- ** getCharset #method:getCharset# + +#if ENABLE_OVERLOADING + EncodingGetCharsetMethodInfo , +#endif + encodingGetCharset , + + +-- ** getCurrent #method:getCurrent# + + encodingGetCurrent , + + +-- ** getDefaultCandidates #method:getDefaultCandidates# + + encodingGetDefaultCandidates , + + +-- ** getFromCharset #method:getFromCharset# + + encodingGetFromCharset , + + +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + EncodingGetNameMethodInfo , +#endif + encodingGetName , + + +-- ** getUtf8 #method:getUtf8# + + encodingGetUtf8 , + + +-- ** toString #method:toString# + +#if ENABLE_OVERLOADING + EncodingToStringMethodInfo , +#endif + encodingToString , + + + + + ) 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 + + +-- | Memory-managed wrapper type. +newtype Encoding = Encoding (ManagedPtr Encoding) +foreign import ccall "gtk_source_encoding_get_type" c_gtk_source_encoding_get_type :: + IO GType + +instance BoxedObject Encoding where + boxedType _ = c_gtk_source_encoding_get_type + +-- | A convenience alias for `Nothing` :: `Maybe` `Encoding`. +noEncoding :: Maybe Encoding +noEncoding = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Encoding +type instance O.AttributeList Encoding = EncodingAttributeList +type EncodingAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method Encoding::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GtkSource", name = "Encoding"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceEncoding.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Encoding"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_encoding_copy" gtk_source_encoding_copy :: + Ptr Encoding -> -- enc : TInterface (Name {namespace = "GtkSource", name = "Encoding"}) + IO (Ptr Encoding) + +{- | +Used by language bindings. + +/Since: 3.14/ +-} +encodingCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + Encoding + {- ^ /@enc@/: a 'GI.GtkSource.Structs.Encoding.Encoding'. -} + -> m Encoding + {- ^ __Returns:__ a copy of /@enc@/. -} +encodingCopy enc = liftIO $ do + enc' <- unsafeManagedPtrGetPtr enc + result <- gtk_source_encoding_copy enc' + checkUnexpectedReturnNULL "encodingCopy" result + result' <- (wrapBoxed Encoding) result + touchManagedPtr enc + return result' + +#if ENABLE_OVERLOADING +data EncodingCopyMethodInfo +instance (signature ~ (m Encoding), MonadIO m) => O.MethodInfo EncodingCopyMethodInfo Encoding signature where + overloadedMethod _ = encodingCopy + +#endif + +-- method Encoding::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GtkSource", name = "Encoding"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceEncoding.", 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_encoding_free" gtk_source_encoding_free :: + Ptr Encoding -> -- enc : TInterface (Name {namespace = "GtkSource", name = "Encoding"}) + IO () + +{- | +Used by language bindings. + +/Since: 3.14/ +-} +encodingFree :: + (B.CallStack.HasCallStack, MonadIO m) => + Encoding + {- ^ /@enc@/: a 'GI.GtkSource.Structs.Encoding.Encoding'. -} + -> m () +encodingFree enc = liftIO $ do + enc' <- unsafeManagedPtrGetPtr enc + gtk_source_encoding_free enc' + touchManagedPtr enc + return () + +#if ENABLE_OVERLOADING +data EncodingFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo EncodingFreeMethodInfo Encoding signature where + overloadedMethod _ = encodingFree + +#endif + +-- method Encoding::get_charset +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GtkSource", name = "Encoding"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceEncoding.", 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_encoding_get_charset" gtk_source_encoding_get_charset :: + Ptr Encoding -> -- enc : TInterface (Name {namespace = "GtkSource", name = "Encoding"}) + IO CString + +{- | +Gets the character set of the 'GI.GtkSource.Structs.Encoding.Encoding', such as \"UTF-8\" or +\"ISO-8859-1\". + +/Since: 3.14/ +-} +encodingGetCharset :: + (B.CallStack.HasCallStack, MonadIO m) => + Encoding + {- ^ /@enc@/: a 'GI.GtkSource.Structs.Encoding.Encoding'. -} + -> m T.Text + {- ^ __Returns:__ the character set of the 'GI.GtkSource.Structs.Encoding.Encoding'. -} +encodingGetCharset enc = liftIO $ do + enc' <- unsafeManagedPtrGetPtr enc + result <- gtk_source_encoding_get_charset enc' + checkUnexpectedReturnNULL "encodingGetCharset" result + result' <- cstringToText result + touchManagedPtr enc + return result' + +#if ENABLE_OVERLOADING +data EncodingGetCharsetMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo EncodingGetCharsetMethodInfo Encoding signature where + overloadedMethod _ = encodingGetCharset + +#endif + +-- method Encoding::get_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GtkSource", name = "Encoding"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceEncoding.", 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_encoding_get_name" gtk_source_encoding_get_name :: + Ptr Encoding -> -- enc : TInterface (Name {namespace = "GtkSource", name = "Encoding"}) + IO CString + +{- | +Gets the name of the 'GI.GtkSource.Structs.Encoding.Encoding' such as \"Unicode\" or \"Western\". + +/Since: 3.14/ +-} +encodingGetName :: + (B.CallStack.HasCallStack, MonadIO m) => + Encoding + {- ^ /@enc@/: a 'GI.GtkSource.Structs.Encoding.Encoding'. -} + -> m T.Text + {- ^ __Returns:__ the name of the 'GI.GtkSource.Structs.Encoding.Encoding'. -} +encodingGetName enc = liftIO $ do + enc' <- unsafeManagedPtrGetPtr enc + result <- gtk_source_encoding_get_name enc' + checkUnexpectedReturnNULL "encodingGetName" result + result' <- cstringToText result + touchManagedPtr enc + return result' + +#if ENABLE_OVERLOADING +data EncodingGetNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo EncodingGetNameMethodInfo Encoding signature where + overloadedMethod _ = encodingGetName + +#endif + +-- method Encoding::to_string +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "enc", argType = TInterface (Name {namespace = "GtkSource", name = "Encoding"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceEncoding.", 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_encoding_to_string" gtk_source_encoding_to_string :: + Ptr Encoding -> -- enc : TInterface (Name {namespace = "GtkSource", name = "Encoding"}) + IO CString + +{- | +/No description available in the introspection data./ + +/Since: 3.14/ +-} +encodingToString :: + (B.CallStack.HasCallStack, MonadIO m) => + Encoding + {- ^ /@enc@/: a 'GI.GtkSource.Structs.Encoding.Encoding'. -} + -> m T.Text + {- ^ __Returns:__ a string representation. Free with 'GI.GLib.Functions.free' when no longer needed. -} +encodingToString enc = liftIO $ do + enc' <- unsafeManagedPtrGetPtr enc + result <- gtk_source_encoding_to_string enc' + checkUnexpectedReturnNULL "encodingToString" result + result' <- cstringToText result + freeMem result + touchManagedPtr enc + return result' + +#if ENABLE_OVERLOADING +data EncodingToStringMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo EncodingToStringMethodInfo Encoding signature where + overloadedMethod _ = encodingToString + +#endif + +-- method Encoding::get_all +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TGSList (TInterface (Name {namespace = "GtkSource", name = "Encoding"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_encoding_get_all" gtk_source_encoding_get_all :: + IO (Ptr (GSList (Ptr Encoding))) + +{- | +Gets all encodings. + +/Since: 3.14/ +-} +encodingGetAll :: + (B.CallStack.HasCallStack, MonadIO m) => + m [Encoding] + {- ^ __Returns:__ a list of +all 'GI.GtkSource.Structs.Encoding.Encoding'\'s. Free with @/g_slist_free()/@. -} +encodingGetAll = liftIO $ do + result <- gtk_source_encoding_get_all + result' <- unpackGSList result + result'' <- mapM (newBoxed Encoding) result' + g_slist_free result + return result'' + +#if ENABLE_OVERLOADING +#endif + +-- method Encoding::get_current +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Encoding"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_encoding_get_current" gtk_source_encoding_get_current :: + IO (Ptr Encoding) + +{- | +Gets the 'GI.GtkSource.Structs.Encoding.Encoding' for the current locale. See also 'GI.GLib.Functions.getCharset'. + +/Since: 3.14/ +-} +encodingGetCurrent :: + (B.CallStack.HasCallStack, MonadIO m) => + m Encoding + {- ^ __Returns:__ the current locale encoding. -} +encodingGetCurrent = liftIO $ do + result <- gtk_source_encoding_get_current + checkUnexpectedReturnNULL "encodingGetCurrent" result + result' <- (newBoxed Encoding) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Encoding::get_default_candidates +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TGSList (TInterface (Name {namespace = "GtkSource", name = "Encoding"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_encoding_get_default_candidates" gtk_source_encoding_get_default_candidates :: + IO (Ptr (GSList (Ptr Encoding))) + +{- | +Gets the list of default candidate encodings to try when loading a file. See +'GI.GtkSource.Objects.FileLoader.fileLoaderSetCandidateEncodings'. + +This function returns a different list depending on the current locale (i.e. +language, country and default encoding). The UTF-8 encoding and the current +locale encoding are guaranteed to be present in the returned list. + +/Since: 3.18/ +-} +encodingGetDefaultCandidates :: + (B.CallStack.HasCallStack, MonadIO m) => + m [Encoding] + {- ^ __Returns:__ the list of +default candidate encodings. Free with @/g_slist_free()/@. -} +encodingGetDefaultCandidates = liftIO $ do + result <- gtk_source_encoding_get_default_candidates + result' <- unpackGSList result + result'' <- mapM (newBoxed Encoding) result' + g_slist_free result + return result'' + +#if ENABLE_OVERLOADING +#endif + +-- method Encoding::get_from_charset +-- method type : MemberFunction +-- Args : [Arg {argCName = "charset", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a character set.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Encoding"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_encoding_get_from_charset" gtk_source_encoding_get_from_charset :: + CString -> -- charset : TBasicType TUTF8 + IO (Ptr Encoding) + +{- | +Gets a 'GI.GtkSource.Structs.Encoding.Encoding' from a character set such as \"UTF-8\" or +\"ISO-8859-1\". + +/Since: 3.14/ +-} +encodingGetFromCharset :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@charset@/: a character set. -} + -> m (Maybe Encoding) + {- ^ __Returns:__ the corresponding 'GI.GtkSource.Structs.Encoding.Encoding', or 'Nothing' +if not found. -} +encodingGetFromCharset charset = liftIO $ do + charset' <- textToCString charset + result <- gtk_source_encoding_get_from_charset charset' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed Encoding) result' + return result'' + freeMem charset' + return maybeResult + +#if ENABLE_OVERLOADING +#endif + +-- method Encoding::get_utf8 +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Encoding"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gtk_source_encoding_get_utf8" gtk_source_encoding_get_utf8 :: + IO (Ptr Encoding) + +{- | +/No description available in the introspection data./ + +/Since: 3.14/ +-} +encodingGetUtf8 :: + (B.CallStack.HasCallStack, MonadIO m) => + m Encoding + {- ^ __Returns:__ the UTF-8 encoding. -} +encodingGetUtf8 = liftIO $ do + result <- gtk_source_encoding_get_utf8 + checkUnexpectedReturnNULL "encodingGetUtf8" result + result' <- (newBoxed Encoding) result + return result' + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type family ResolveEncodingMethod (t :: Symbol) (o :: *) :: * where + ResolveEncodingMethod "copy" o = EncodingCopyMethodInfo + ResolveEncodingMethod "free" o = EncodingFreeMethodInfo + ResolveEncodingMethod "toString" o = EncodingToStringMethodInfo + ResolveEncodingMethod "getCharset" o = EncodingGetCharsetMethodInfo + ResolveEncodingMethod "getName" o = EncodingGetNameMethodInfo + ResolveEncodingMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveEncodingMethod t Encoding, O.MethodInfo info Encoding p) => OL.IsLabel t (Encoding -> 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 + + diff --git a/GI/GtkSource/Structs/Encoding.hs-boot b/GI/GtkSource/Structs/Encoding.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Structs/Encoding.hs-boot @@ -0,0 +1,41 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Structs.Encoding 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 Encoding = Encoding (ManagedPtr Encoding) +instance BoxedObject Encoding where +#if ENABLE_OVERLOADING +data EncodingCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data EncodingFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data EncodingGetCharsetMethodInfo +#endif +#if ENABLE_OVERLOADING +data EncodingGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data EncodingToStringMethodInfo +#endif diff --git a/GI/GtkSource/Structs/RegionIter.hs b/GI/GtkSource/Structs/RegionIter.hs new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Structs/RegionIter.hs @@ -0,0 +1,241 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +'GI.GtkSource.Structs.RegionIter.RegionIter' is an opaque datatype; ignore all its fields. +Initialize the iter with 'GI.GtkSource.Objects.Region.regionGetStartRegionIter'. + +/Since: 3.22/ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GtkSource.Structs.RegionIter + ( + +-- * Exported types + RegionIter(..) , + newZeroRegionIter , + noRegionIter , + + + -- * Methods +-- ** getSubregion #method:getSubregion# + +#if ENABLE_OVERLOADING + RegionIterGetSubregionMethodInfo , +#endif + regionIterGetSubregion , + + +-- ** isEnd #method:isEnd# + +#if ENABLE_OVERLOADING + RegionIterIsEndMethodInfo , +#endif + regionIterIsEnd , + + +-- ** next #method:next# + +#if ENABLE_OVERLOADING + RegionIterNextMethodInfo , +#endif + regionIterNext , + + + + + ) 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.Gtk.Structs.TextIter as Gtk.TextIter + +-- | Memory-managed wrapper type. +newtype RegionIter = RegionIter (ManagedPtr RegionIter) +instance WrappedPtr RegionIter where + wrappedPtrCalloc = callocBytes 24 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 24 >=> wrapPtr RegionIter) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `RegionIter` struct initialized to zero. +newZeroRegionIter :: MonadIO m => m RegionIter +newZeroRegionIter = liftIO $ wrappedPtrCalloc >>= wrapPtr RegionIter + +instance tag ~ 'AttrSet => Constructible RegionIter tag where + new _ attrs = do + o <- newZeroRegionIter + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `RegionIter`. +noRegionIter :: Maybe RegionIter +noRegionIter = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList RegionIter +type instance O.AttributeList RegionIter = RegionIterAttributeList +type RegionIterAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method RegionIter::get_subregion +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "GtkSource", name = "RegionIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceRegionIter.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "iterator to initialize with the subregion start, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "Gtk", name = "TextIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "iterator to initialize with the subregion end, or %NULL.", 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_region_iter_get_subregion" gtk_source_region_iter_get_subregion :: + Ptr RegionIter -> -- iter : TInterface (Name {namespace = "GtkSource", name = "RegionIter"}) + Ptr Gtk.TextIter.TextIter -> -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + Ptr Gtk.TextIter.TextIter -> -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"}) + IO CInt + +{- | +Gets the subregion at this iterator. + +/Since: 3.22/ +-} +regionIterGetSubregion :: + (B.CallStack.HasCallStack, MonadIO m) => + RegionIter + {- ^ /@iter@/: a 'GI.GtkSource.Structs.RegionIter.RegionIter'. -} + -> m ((Bool, Gtk.TextIter.TextIter, Gtk.TextIter.TextIter)) + {- ^ __Returns:__ 'True' if /@start@/ and /@end@/ have been set successfully (if non-'Nothing'), + or 'False' if /@iter@/ is the end iterator or if the region is empty. -} +regionIterGetSubregion iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + start <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter) + end <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter) + result <- gtk_source_region_iter_get_subregion iter' start end + let result' = (/= 0) result + start' <- (wrapBoxed Gtk.TextIter.TextIter) start + end' <- (wrapBoxed Gtk.TextIter.TextIter) end + touchManagedPtr iter + return (result', start', end') + +#if ENABLE_OVERLOADING +data RegionIterGetSubregionMethodInfo +instance (signature ~ (m ((Bool, Gtk.TextIter.TextIter, Gtk.TextIter.TextIter))), MonadIO m) => O.MethodInfo RegionIterGetSubregionMethodInfo RegionIter signature where + overloadedMethod _ = regionIterGetSubregion + +#endif + +-- method RegionIter::is_end +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "GtkSource", name = "RegionIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceRegionIter.", 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_region_iter_is_end" gtk_source_region_iter_is_end :: + Ptr RegionIter -> -- iter : TInterface (Name {namespace = "GtkSource", name = "RegionIter"}) + IO CInt + +{- | +/No description available in the introspection data./ + +/Since: 3.22/ +-} +regionIterIsEnd :: + (B.CallStack.HasCallStack, MonadIO m) => + RegionIter + {- ^ /@iter@/: a 'GI.GtkSource.Structs.RegionIter.RegionIter'. -} + -> m Bool + {- ^ __Returns:__ whether /@iter@/ is the end iterator. -} +regionIterIsEnd iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + result <- gtk_source_region_iter_is_end iter' + let result' = (/= 0) result + touchManagedPtr iter + return result' + +#if ENABLE_OVERLOADING +data RegionIterIsEndMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo RegionIterIsEndMethodInfo RegionIter signature where + overloadedMethod _ = regionIterIsEnd + +#endif + +-- method RegionIter::next +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "GtkSource", name = "RegionIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceRegionIter.", 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_region_iter_next" gtk_source_region_iter_next :: + Ptr RegionIter -> -- iter : TInterface (Name {namespace = "GtkSource", name = "RegionIter"}) + IO CInt + +{- | +Moves /@iter@/ to the next subregion. + +/Since: 3.22/ +-} +regionIterNext :: + (B.CallStack.HasCallStack, MonadIO m) => + RegionIter + {- ^ /@iter@/: a 'GI.GtkSource.Structs.RegionIter.RegionIter'. -} + -> m Bool + {- ^ __Returns:__ 'True' if /@iter@/ moved and is dereferenceable, or 'False' if /@iter@/ has + been set to the end iterator. -} +regionIterNext iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + result <- gtk_source_region_iter_next iter' + let result' = (/= 0) result + touchManagedPtr iter + return result' + +#if ENABLE_OVERLOADING +data RegionIterNextMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo RegionIterNextMethodInfo RegionIter signature where + overloadedMethod _ = regionIterNext + +#endif + +#if ENABLE_OVERLOADING +type family ResolveRegionIterMethod (t :: Symbol) (o :: *) :: * where + ResolveRegionIterMethod "isEnd" o = RegionIterIsEndMethodInfo + ResolveRegionIterMethod "next" o = RegionIterNextMethodInfo + ResolveRegionIterMethod "getSubregion" o = RegionIterGetSubregionMethodInfo + ResolveRegionIterMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRegionIterMethod t RegionIter, O.MethodInfo info RegionIter p) => OL.IsLabel t (RegionIter -> 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 + + diff --git a/GI/GtkSource/Structs/RegionIter.hs-boot b/GI/GtkSource/Structs/RegionIter.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GtkSource/Structs/RegionIter.hs-boot @@ -0,0 +1,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GtkSource.Structs.RegionIter 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 RegionIter = RegionIter (ManagedPtr RegionIter) +instance WrappedPtr RegionIter where +#if ENABLE_OVERLOADING +data RegionIterGetSubregionMethodInfo +#endif +#if ENABLE_OVERLOADING +data RegionIterIsEndMethodInfo +#endif +#if ENABLE_OVERLOADING +data RegionIterNextMethodInfo +#endif diff --git a/LICENSE b/LICENSE --- a/LICENSE +++ b/LICENSE @@ -1,3 +1,17 @@ +The gi-gtksource library and included works are provided under the terms of the +GNU Library General Public License (LGPL) version 2.1 with the following +exception: + +Static linking of applications or any other source to the gi-gtksource library +does not constitute a modified or derivative work and does not require +the author(s) to provide source code for said work, to link against the +shared gi-gtksource libraries, or to link their applications against a +user-supplied version of gi-gtksource. If you link applications to a modified +version of gi-gtksource, then the changes to gi-gtksource must be provided under the +terms of the LGPL. + +---------------------------------------------------------------------------- + GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # Documentation Autogenerated documentation for this package can be found at -[https://hackage.haskell.org/package/gi-gtksource-3.0.16/docs/GI-GtkSource.html](https://hackage.haskell.org/package/gi-gtksource-3.0.16/docs/GI-GtkSource.html) +[https://hackage.haskell.org/package/gi-gtksource-3.0.18/docs/GI-GtkSource.html](https://hackage.haskell.org/package/gi-gtksource-3.0.18/docs/GI-GtkSource.html) For general documentation on using [haskell-gi](https://github.com/haskell-gi/haskell-gi) based bindings, see [the project page](https://github.com/haskell-gi/haskell-gi) or [the Wiki](https://github.com/haskell-gi/haskell-gi/wiki). diff --git a/gi-gtksource.cabal b/gi-gtksource.cabal --- a/gi-gtksource.cabal +++ b/gi-gtksource.cabal @@ -1,33 +1,33 @@ name: gi-gtksource -version: 3.0.16 +version: 3.0.18 synopsis: GtkSource bindings description: Bindings for GtkSource, autogenerated by haskell-gi. homepage: https://github.com/haskell-gi/haskell-gi license: LGPL-2.1 license-file: LICENSE author: Will Thompson, Iñaki García Etxebarria and Jonas Platte -maintainer: Iñaki García Etxebarria (garetxe@gmail.com) +maintainer: Iñaki García Etxebarria (inaki@blueleaf.cc) category: Bindings build-type: Custom -cabal-version: >= 1.24 +cabal-version: 1.24 extra-source-files: README.md ChangeLog.md stack.yaml GtkSource.overrides custom-setup - setup-depends: base >= 4.7 && < 5, + setup-depends: base >= 4.9 && < 5, Cabal >= 1.24, - haskell-gi == 0.21.* + haskell-gi >= 0.21.0 && < 0.23 library default-language: Haskell2010 - default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts + default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts, UndecidableSuperClasses other-extensions: PatternSynonyms, ViewPatterns ghc-options: -fno-warn-unused-imports -fno-warn-warnings-deprecations pkgconfig-depends: gtksourceview-3.0 build-depends: base >= 4.7 && <5, - haskell-gi-base == 0.21.*, - haskell-gi == 0.21.*, + haskell-gi-base >= 0.21.0 && < 0.23, + haskell-gi >= 0.21.0 && < 0.23, haskell-gi-overloading < 1.1, gi-cairo == 1.0.*, gi-pango == 1.0.*, @@ -47,3 +47,47 @@ -- see https://ghc.haskell.org/trac/ghc/ticket/14382 if impl(ghc == 8.2.*) build-depends: haskell-gi-overloading == 0.0 + + exposed-modules: GI.GtkSource, + GI.GtkSource.Enums, + GI.GtkSource.Flags, + GI.GtkSource.Functions, + GI.GtkSource.Interfaces, + GI.GtkSource.Interfaces.CompletionProposal, + GI.GtkSource.Interfaces.CompletionProvider, + GI.GtkSource.Interfaces.StyleSchemeChooser, + GI.GtkSource.Interfaces.UndoManager, + GI.GtkSource.Objects, + GI.GtkSource.Objects.Buffer, + GI.GtkSource.Objects.Completion, + GI.GtkSource.Objects.CompletionContext, + GI.GtkSource.Objects.CompletionInfo, + GI.GtkSource.Objects.CompletionItem, + GI.GtkSource.Objects.CompletionWords, + GI.GtkSource.Objects.File, + GI.GtkSource.Objects.FileLoader, + GI.GtkSource.Objects.FileSaver, + GI.GtkSource.Objects.Gutter, + GI.GtkSource.Objects.GutterRenderer, + GI.GtkSource.Objects.GutterRendererPixbuf, + GI.GtkSource.Objects.GutterRendererText, + GI.GtkSource.Objects.Language, + GI.GtkSource.Objects.LanguageManager, + GI.GtkSource.Objects.Map, + GI.GtkSource.Objects.Mark, + GI.GtkSource.Objects.MarkAttributes, + GI.GtkSource.Objects.PrintCompositor, + GI.GtkSource.Objects.Region, + GI.GtkSource.Objects.SearchContext, + GI.GtkSource.Objects.SearchSettings, + GI.GtkSource.Objects.SpaceDrawer, + GI.GtkSource.Objects.Style, + GI.GtkSource.Objects.StyleScheme, + GI.GtkSource.Objects.StyleSchemeChooserButton, + GI.GtkSource.Objects.StyleSchemeChooserWidget, + GI.GtkSource.Objects.StyleSchemeManager, + GI.GtkSource.Objects.Tag, + GI.GtkSource.Objects.View, + GI.GtkSource.Structs, + GI.GtkSource.Structs.Encoding, + GI.GtkSource.Structs.RegionIter diff --git a/stack.yaml b/stack.yaml --- a/stack.yaml +++ b/stack.yaml @@ -1,3 +1,3 @@ packages: - '.' -resolver: lts-9.21 +resolver: lts-13.7