diff --git a/ChangeLog.md b/ChangeLog.md --- a/ChangeLog.md +++ b/ChangeLog.md @@ -1,3 +1,11 @@ +### 1.0.18 + ++ Update to haskell-gi(-base) 0.22 + +### 1.0.17 + ++ Update stack version to 12.10 + ### 1.0.16 + Add a missing dependency on `gi-glib`, needed for newer versions. diff --git a/GI/GIRepository.hs b/GI/GIRepository.hs new file mode 100644 --- /dev/null +++ b/GI/GIRepository.hs @@ -0,0 +1,58 @@ + + +{- | +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.GIRepository + ( module GI.GIRepository.Constants , + module GI.GIRepository.Enums , + module GI.GIRepository.Flags , + module GI.GIRepository.Functions , + module GI.GIRepository.Objects , + module GI.GIRepository.Structs , + module GI.GIRepository.Unions , + + + + module Data.GI.Base , + + + ) where + +import GI.GIRepository.Constants +import GI.GIRepository.Enums +import GI.GIRepository.Flags +import GI.GIRepository.Functions +import GI.GIRepository.Objects +import GI.GIRepository.Structs +import GI.GIRepository.Unions + +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/GIRepository/Constants.hs b/GI/GIRepository/Constants.hs new file mode 100644 --- /dev/null +++ b/GI/GIRepository/Constants.hs @@ -0,0 +1,69 @@ +{-# LANGUAGE PatternSynonyms, ScopedTypeVariables, ViewPatterns #-} + + +{- | +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.GIRepository.Constants + ( + pattern TYPE_TAG_N_TYPES , + pattern MINOR_VERSION , + pattern MICRO_VERSION , + pattern MAJOR_VERSION , + + ) 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 + + +{- | +TODO +-} +pattern TYPE_TAG_N_TYPES = 22 :: Int32 + +{- | +The minor version number of the girepository library. + +/Since: 1.60/ +-} +pattern MINOR_VERSION = 60 :: Int32 + +{- | +The micro version number of the girepository library. + +/Since: 1.60/ +-} +pattern MICRO_VERSION = 1 :: Int32 + +{- | +The major version number of the girepository library. + +/Since: 1.60/ +-} +pattern MAJOR_VERSION = 1 :: Int32 + + diff --git a/GI/GIRepository/Enums.hs b/GI/GIRepository/Enums.hs new file mode 100644 --- /dev/null +++ b/GI/GIRepository/Enums.hs @@ -0,0 +1,628 @@ + + +{- | +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.GIRepository.Enums + ( + + -- * Enumerations +-- ** ArrayType #enum:ArrayType# + + ArrayType(..) , + + +-- ** Direction #enum:Direction# + + Direction(..) , + + +-- ** InfoType #enum:InfoType# + + InfoType(..) , + + +-- ** NvokeError #enum:NvokeError# + + NvokeError(..) , + + +-- ** RepositoryError #enum:RepositoryError# + + RepositoryError(..) , + + +-- ** ScopeType #enum:ScopeType# + + ScopeType(..) , + + +-- ** Transfer #enum:Transfer# + + Transfer(..) , + + +-- ** TypeTag #enum:TypeTag# + + TypeTag(..) , + + + + + ) 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 nvokeError +{- | +An error occuring while invoking a function via +@/g_function_info_invoke()/@. +-} +data NvokeError = + NvokeErrorFailed + {- ^ + invokation failed, unknown error. + -} + | NvokeErrorSymbolNotFound + {- ^ + symbol couldn\'t be found in any of the + libraries associated with the typelib of the function. + -} + | NvokeErrorArgumentMismatch + {- ^ + the arguments provided didn\'t match + the expected arguments for the functions type signature. + -} + | AnotherNvokeError Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum NvokeError where + fromEnum NvokeErrorFailed = 0 + fromEnum NvokeErrorSymbolNotFound = 1 + fromEnum NvokeErrorArgumentMismatch = 2 + fromEnum (AnotherNvokeError k) = k + + toEnum 0 = NvokeErrorFailed + toEnum 1 = NvokeErrorSymbolNotFound + toEnum 2 = NvokeErrorArgumentMismatch + toEnum k = AnotherNvokeError k + +instance P.Ord NvokeError where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +-- Enum TypeTag +{- | +The type tag of a @/GITypeInfo/@. +-} +data TypeTag = + TypeTagVoid + {- ^ + void + -} + | TypeTagBoolean + {- ^ + boolean + -} + | TypeTagInt8 + {- ^ + 8-bit signed integer + -} + | TypeTagUint8 + {- ^ + 8-bit unsigned integer + -} + | TypeTagInt16 + {- ^ + 16-bit signed integer + -} + | TypeTagUint16 + {- ^ + 16-bit unsigned integer + -} + | TypeTagInt32 + {- ^ + 32-bit signed integer + -} + | TypeTagUint32 + {- ^ + 32-bit unsigned integer + -} + | TypeTagInt64 + {- ^ + 64-bit signed integer + -} + | TypeTagUint64 + {- ^ + 64-bit unsigned integer + -} + | TypeTagFloat + {- ^ + float + -} + | TypeTagDouble + {- ^ + double floating point + -} + | TypeTagGtype + {- ^ + a 'GType' + -} + | TypeTagUtf8 + {- ^ + a UTF-8 encoded string + -} + | TypeTagFilename + {- ^ + a filename, encoded in the same encoding + as the native filesystem is using. + -} + | TypeTagArray + {- ^ + an array + -} + | TypeTagInterface + {- ^ + an extended interface object + -} + | TypeTagGlist + {- ^ + a 'GI.GLib.Structs.List.List' + -} + | TypeTagGslist + {- ^ + a 'GI.GLib.Structs.SList.SList' + -} + | TypeTagGhash + {- ^ + a 'GI.GLib.Structs.HashTable.HashTable' + -} + | TypeTagError + {- ^ + a 'GError' + -} + | TypeTagUnichar + {- ^ + Unicode character + -} + | AnotherTypeTag Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum TypeTag where + fromEnum TypeTagVoid = 0 + fromEnum TypeTagBoolean = 1 + fromEnum TypeTagInt8 = 2 + fromEnum TypeTagUint8 = 3 + fromEnum TypeTagInt16 = 4 + fromEnum TypeTagUint16 = 5 + fromEnum TypeTagInt32 = 6 + fromEnum TypeTagUint32 = 7 + fromEnum TypeTagInt64 = 8 + fromEnum TypeTagUint64 = 9 + fromEnum TypeTagFloat = 10 + fromEnum TypeTagDouble = 11 + fromEnum TypeTagGtype = 12 + fromEnum TypeTagUtf8 = 13 + fromEnum TypeTagFilename = 14 + fromEnum TypeTagArray = 15 + fromEnum TypeTagInterface = 16 + fromEnum TypeTagGlist = 17 + fromEnum TypeTagGslist = 18 + fromEnum TypeTagGhash = 19 + fromEnum TypeTagError = 20 + fromEnum TypeTagUnichar = 21 + fromEnum (AnotherTypeTag k) = k + + toEnum 0 = TypeTagVoid + toEnum 1 = TypeTagBoolean + toEnum 2 = TypeTagInt8 + toEnum 3 = TypeTagUint8 + toEnum 4 = TypeTagInt16 + toEnum 5 = TypeTagUint16 + toEnum 6 = TypeTagInt32 + toEnum 7 = TypeTagUint32 + toEnum 8 = TypeTagInt64 + toEnum 9 = TypeTagUint64 + toEnum 10 = TypeTagFloat + toEnum 11 = TypeTagDouble + toEnum 12 = TypeTagGtype + toEnum 13 = TypeTagUtf8 + toEnum 14 = TypeTagFilename + toEnum 15 = TypeTagArray + toEnum 16 = TypeTagInterface + toEnum 17 = TypeTagGlist + toEnum 18 = TypeTagGslist + toEnum 19 = TypeTagGhash + toEnum 20 = TypeTagError + toEnum 21 = TypeTagUnichar + toEnum k = AnotherTypeTag k + +instance P.Ord TypeTag where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +-- Enum Transfer +{- | +The transfer is the exchange of data between two parts, from the callee to +the caller. The callee is either a function\/method\/signal or an +object\/interface where a property is defined. The caller is the side +accessing a property or calling a function. +'GI.GIRepository.Enums.Transfer' specifies who\'s responsible for freeing the resources after the +ownership transfer is complete. In case of a containing type such as a list, +an array or a hash table the container itself is specified differently from +the items within the container itself. Each container is freed differently, +check the documentation for the types themselves for information on how to +free them. +-} +data Transfer = + TransferNothing + {- ^ + transfer nothing from the callee (function or the type + instance the property belongs to) to the caller. The callee retains the + ownership of the transfer and the caller doesn\'t need to do anything to free + up the resources of this transfer. + -} + | TransferContainer + {- ^ + transfer the container (list, array, hash table) from + the callee to the caller. The callee retains the ownership of the individual + items in the container and the caller has to free up the container resources + (@/g_list_free()/@\/'GI.GLib.Functions.hashTableDestroy' etc) of this transfer. + -} + | TransferEverything + {- ^ + transfer everything, eg the container and its + contents from the callee to the caller. This is the case when the callee + creates a copy of all the data it returns. The caller is responsible for + cleaning up the container and item resources of this transfer. + -} + | AnotherTransfer Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum Transfer where + fromEnum TransferNothing = 0 + fromEnum TransferContainer = 1 + fromEnum TransferEverything = 2 + fromEnum (AnotherTransfer k) = k + + toEnum 0 = TransferNothing + toEnum 1 = TransferContainer + toEnum 2 = TransferEverything + toEnum k = AnotherTransfer k + +instance P.Ord Transfer where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +-- Enum ScopeType +{- | +Scope type of a @/GIArgInfo/@ representing callback, determines how the +callback is invoked and is used to decided when the invoke structs +can be freed. +-} +data ScopeType = + ScopeTypeInvalid + {- ^ + The argument is not of callback type. + -} + | ScopeTypeCall + {- ^ + The callback and associated user_data is only + used during the call to this function. + -} + | ScopeTypeAsync + {- ^ + The callback and associated user_data is + only used until the callback is invoked, and the callback. + is invoked always exactly once. + -} + | ScopeTypeNotified + {- ^ + The callback and and associated + user_data is used until the caller is notfied via the destroy_notify. + -} + | AnotherScopeType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum ScopeType where + fromEnum ScopeTypeInvalid = 0 + fromEnum ScopeTypeCall = 1 + fromEnum ScopeTypeAsync = 2 + fromEnum ScopeTypeNotified = 3 + fromEnum (AnotherScopeType k) = k + + toEnum 0 = ScopeTypeInvalid + toEnum 1 = ScopeTypeCall + toEnum 2 = ScopeTypeAsync + toEnum 3 = ScopeTypeNotified + toEnum k = AnotherScopeType k + +instance P.Ord ScopeType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +-- Enum RepositoryError +{- | +An error code used with @/G_IREPOSITORY_ERROR/@ in a 'GError' returned +from a 'GI.GIRepository.Objects.Repository.Repository' routine. +-} +data RepositoryError = + RepositoryErrorTypelibNotFound + {- ^ + the typelib could not be found. + -} + | RepositoryErrorNamespaceMismatch + {- ^ + the namespace does not match the + requested namespace. + -} + | RepositoryErrorNamespaceVersionConflict + {- ^ + the version of the + typelib does not match the requested version. + -} + | RepositoryErrorLibraryNotFound + {- ^ + the library used by the typelib + could not be found. + -} + | AnotherRepositoryError Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum RepositoryError where + fromEnum RepositoryErrorTypelibNotFound = 0 + fromEnum RepositoryErrorNamespaceMismatch = 1 + fromEnum RepositoryErrorNamespaceVersionConflict = 2 + fromEnum RepositoryErrorLibraryNotFound = 3 + fromEnum (AnotherRepositoryError k) = k + + toEnum 0 = RepositoryErrorTypelibNotFound + toEnum 1 = RepositoryErrorNamespaceMismatch + toEnum 2 = RepositoryErrorNamespaceVersionConflict + toEnum 3 = RepositoryErrorLibraryNotFound + toEnum k = AnotherRepositoryError k + +instance P.Ord RepositoryError where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +-- Enum InfoType +{- | +The type of a GIBaseInfo struct. +-} +data InfoType = + InfoTypeInvalid + {- ^ + invalid type + -} + | InfoTypeFunction + {- ^ + function, see @/GIFunctionInfo/@ + -} + | InfoTypeCallback + {- ^ + callback, see @/GIFunctionInfo/@ + -} + | InfoTypeStruct + {- ^ + struct, see @/GIStructInfo/@ + -} + | InfoTypeBoxed + {- ^ + boxed, see @/GIStructInfo/@ or @/GIUnionInfo/@ + -} + | InfoTypeEnum + {- ^ + enum, see @/GIEnumInfo/@ + -} + | InfoTypeFlags + {- ^ + flags, see @/GIEnumInfo/@ + -} + | InfoTypeObject + {- ^ + object, see @/GIObjectInfo/@ + -} + | InfoTypeInterface + {- ^ + interface, see @/GIInterfaceInfo/@ + -} + | InfoTypeConstant + {- ^ + contant, see @/GIConstantInfo/@ + -} + | InfoTypeInvalid0 + {- ^ + deleted, used to be GI_INFO_TYPE_ERROR_DOMAIN. + -} + | InfoTypeUnion + {- ^ + union, see @/GIUnionInfo/@ + -} + | InfoTypeValue + {- ^ + enum value, see @/GIValueInfo/@ + -} + | InfoTypeSignal + {- ^ + signal, see @/GISignalInfo/@ + -} + | InfoTypeVfunc + {- ^ + virtual function, see @/GIVFuncInfo/@ + -} + | InfoTypeProperty + {- ^ + GObject property, see @/GIPropertyInfo/@ + -} + | InfoTypeField + {- ^ + struct or union field, see @/GIFieldInfo/@ + -} + | InfoTypeArg + {- ^ + argument of a function or callback, see @/GIArgInfo/@ + -} + | InfoTypeType + {- ^ + type information, see @/GITypeInfo/@ + -} + | InfoTypeUnresolved + {- ^ + unresolved type, a type which is not present in + the typelib, or any of its dependencies. + -} + | AnotherInfoType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum InfoType where + fromEnum InfoTypeInvalid = 0 + fromEnum InfoTypeFunction = 1 + fromEnum InfoTypeCallback = 2 + fromEnum InfoTypeStruct = 3 + fromEnum InfoTypeBoxed = 4 + fromEnum InfoTypeEnum = 5 + fromEnum InfoTypeFlags = 6 + fromEnum InfoTypeObject = 7 + fromEnum InfoTypeInterface = 8 + fromEnum InfoTypeConstant = 9 + fromEnum InfoTypeInvalid0 = 10 + fromEnum InfoTypeUnion = 11 + fromEnum InfoTypeValue = 12 + fromEnum InfoTypeSignal = 13 + fromEnum InfoTypeVfunc = 14 + fromEnum InfoTypeProperty = 15 + fromEnum InfoTypeField = 16 + fromEnum InfoTypeArg = 17 + fromEnum InfoTypeType = 18 + fromEnum InfoTypeUnresolved = 19 + fromEnum (AnotherInfoType k) = k + + toEnum 0 = InfoTypeInvalid + toEnum 1 = InfoTypeFunction + toEnum 2 = InfoTypeCallback + toEnum 3 = InfoTypeStruct + toEnum 4 = InfoTypeBoxed + toEnum 5 = InfoTypeEnum + toEnum 6 = InfoTypeFlags + toEnum 7 = InfoTypeObject + toEnum 8 = InfoTypeInterface + toEnum 9 = InfoTypeConstant + toEnum 10 = InfoTypeInvalid0 + toEnum 11 = InfoTypeUnion + toEnum 12 = InfoTypeValue + toEnum 13 = InfoTypeSignal + toEnum 14 = InfoTypeVfunc + toEnum 15 = InfoTypeProperty + toEnum 16 = InfoTypeField + toEnum 17 = InfoTypeArg + toEnum 18 = InfoTypeType + toEnum 19 = InfoTypeUnresolved + toEnum k = AnotherInfoType k + +instance P.Ord InfoType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +-- Enum Direction +{- | +The direction of a @/GIArgInfo/@. +-} +data Direction = + DirectionIn + {- ^ + in argument. + -} + | DirectionOut + {- ^ + out argument. + -} + | DirectionInout + {- ^ + in and out argument. + -} + | AnotherDirection Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum Direction where + fromEnum DirectionIn = 0 + fromEnum DirectionOut = 1 + fromEnum DirectionInout = 2 + fromEnum (AnotherDirection k) = k + + toEnum 0 = DirectionIn + toEnum 1 = DirectionOut + toEnum 2 = DirectionInout + toEnum k = AnotherDirection k + +instance P.Ord Direction where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +-- Enum ArrayType +{- | +The type of array in a @/GITypeInfo/@. +-} +data ArrayType = + ArrayTypeC + {- ^ + a C array, char[] for instance + -} + | ArrayTypeArray + {- ^ + a /@gArray@/ array + -} + | ArrayTypePtrArray + {- ^ + a 'GI.GLib.Structs.PtrArray.PtrArray' array + -} + | ArrayTypeByteArray + {- ^ + a 'GI.GLib.Structs.ByteArray.ByteArray' array + -} + | AnotherArrayType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum ArrayType where + fromEnum ArrayTypeC = 0 + fromEnum ArrayTypeArray = 1 + fromEnum ArrayTypePtrArray = 2 + fromEnum ArrayTypeByteArray = 3 + fromEnum (AnotherArrayType k) = k + + toEnum 0 = ArrayTypeC + toEnum 1 = ArrayTypeArray + toEnum 2 = ArrayTypePtrArray + toEnum 3 = ArrayTypeByteArray + toEnum k = AnotherArrayType k + +instance P.Ord ArrayType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + + diff --git a/GI/GIRepository/Enums.hs-boot b/GI/GIRepository/Enums.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GIRepository/Enums.hs-boot @@ -0,0 +1,40 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GIRepository.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 NvokeError +instance P.Enum NvokeError where +data TypeTag +instance P.Enum TypeTag where +data Transfer +instance P.Enum Transfer where +data ScopeType +instance P.Enum ScopeType where +data RepositoryError +instance P.Enum RepositoryError where +data InfoType +instance P.Enum InfoType where +data Direction +instance P.Enum Direction where +data ArrayType +instance P.Enum ArrayType where diff --git a/GI/GIRepository/Flags.hs b/GI/GIRepository/Flags.hs new file mode 100644 --- /dev/null +++ b/GI/GIRepository/Flags.hs @@ -0,0 +1,215 @@ + + +{- | +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.GIRepository.Flags + ( + + -- * Flags +-- ** FieldInfoFlags #flag:FieldInfoFlags# + + FieldInfoFlags(..) , + + +-- ** FunctionInfoFlags #flag:FunctionInfoFlags# + + FunctionInfoFlags(..) , + + +-- ** RepositoryLoadFlags #flag:RepositoryLoadFlags# + + RepositoryLoadFlags(..) , + + +-- ** VFuncInfoFlags #flag:VFuncInfoFlags# + + VFuncInfoFlags(..) , + + + + + ) 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 VFuncInfoFlags +{- | +Flags of a @/GIVFuncInfo/@ struct. +-} +data VFuncInfoFlags = + VFuncInfoFlagsMustChainUp + {- ^ + chains up to the parent type + -} + | VFuncInfoFlagsMustOverride + {- ^ + overrides + -} + | VFuncInfoFlagsMustNotOverride + {- ^ + does not override + -} + | VFuncInfoFlagsThrows + {- ^ + Includes a 'GError' + -} + | AnotherVFuncInfoFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum VFuncInfoFlags where + fromEnum VFuncInfoFlagsMustChainUp = 1 + fromEnum VFuncInfoFlagsMustOverride = 2 + fromEnum VFuncInfoFlagsMustNotOverride = 4 + fromEnum VFuncInfoFlagsThrows = 8 + fromEnum (AnotherVFuncInfoFlags k) = k + + toEnum 1 = VFuncInfoFlagsMustChainUp + toEnum 2 = VFuncInfoFlagsMustOverride + toEnum 4 = VFuncInfoFlagsMustNotOverride + toEnum 8 = VFuncInfoFlagsThrows + toEnum k = AnotherVFuncInfoFlags k + +instance P.Ord VFuncInfoFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance IsGFlag VFuncInfoFlags + +-- Flags RepositoryLoadFlags +{- | +Flags that control how a typelib is loaded. +-} +data RepositoryLoadFlags = + RepositoryLoadFlagsIrepositoryLoadFlagLazy + {- ^ + Lazily load the typelib. + -} + | AnotherRepositoryLoadFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum RepositoryLoadFlags where + fromEnum RepositoryLoadFlagsIrepositoryLoadFlagLazy = 1 + fromEnum (AnotherRepositoryLoadFlags k) = k + + toEnum 1 = RepositoryLoadFlagsIrepositoryLoadFlagLazy + toEnum k = AnotherRepositoryLoadFlags k + +instance P.Ord RepositoryLoadFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance IsGFlag RepositoryLoadFlags + +-- Flags FunctionInfoFlags +{- | +Flags for a @/GIFunctionInfo/@ struct. +-} +data FunctionInfoFlags = + FunctionInfoFlagsIsMethod + {- ^ + is a method. + -} + | FunctionInfoFlagsIsConstructor + {- ^ + is a constructor. + -} + | FunctionInfoFlagsIsGetter + {- ^ + is a getter of a @/GIPropertyInfo/@. + -} + | FunctionInfoFlagsIsSetter + {- ^ + is a setter of a @/GIPropertyInfo/@. + -} + | FunctionInfoFlagsWrapsVfunc + {- ^ + represents a virtual function. + -} + | FunctionInfoFlagsThrows + {- ^ + the function may throw an error. + -} + | AnotherFunctionInfoFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum FunctionInfoFlags where + fromEnum FunctionInfoFlagsIsMethod = 1 + fromEnum FunctionInfoFlagsIsConstructor = 2 + fromEnum FunctionInfoFlagsIsGetter = 4 + fromEnum FunctionInfoFlagsIsSetter = 8 + fromEnum FunctionInfoFlagsWrapsVfunc = 16 + fromEnum FunctionInfoFlagsThrows = 32 + fromEnum (AnotherFunctionInfoFlags k) = k + + toEnum 1 = FunctionInfoFlagsIsMethod + toEnum 2 = FunctionInfoFlagsIsConstructor + toEnum 4 = FunctionInfoFlagsIsGetter + toEnum 8 = FunctionInfoFlagsIsSetter + toEnum 16 = FunctionInfoFlagsWrapsVfunc + toEnum 32 = FunctionInfoFlagsThrows + toEnum k = AnotherFunctionInfoFlags k + +instance P.Ord FunctionInfoFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance IsGFlag FunctionInfoFlags + +-- Flags FieldInfoFlags +{- | +Flags for a @/GIFieldInfo/@. +-} +data FieldInfoFlags = + FieldInfoFlagsReadable + {- ^ + field is readable. + -} + | FieldInfoFlagsWritable + {- ^ + field is writable. + -} + | AnotherFieldInfoFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum FieldInfoFlags where + fromEnum FieldInfoFlagsReadable = 1 + fromEnum FieldInfoFlagsWritable = 2 + fromEnum (AnotherFieldInfoFlags k) = k + + toEnum 1 = FieldInfoFlagsReadable + toEnum 2 = FieldInfoFlagsWritable + toEnum k = AnotherFieldInfoFlags k + +instance P.Ord FieldInfoFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance IsGFlag FieldInfoFlags + + diff --git a/GI/GIRepository/Flags.hs-boot b/GI/GIRepository/Flags.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GIRepository/Flags.hs-boot @@ -0,0 +1,36 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GIRepository.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 VFuncInfoFlags +instance P.Enum VFuncInfoFlags where +instance IsGFlag VFuncInfoFlags +data RepositoryLoadFlags +instance P.Enum RepositoryLoadFlags where +instance IsGFlag RepositoryLoadFlags +data FunctionInfoFlags +instance P.Enum FunctionInfoFlags where +instance IsGFlag FunctionInfoFlags +data FieldInfoFlags +instance P.Enum FieldInfoFlags where +instance IsGFlag FieldInfoFlags diff --git a/GI/GIRepository/Functions.hs b/GI/GIRepository/Functions.hs new file mode 100644 --- /dev/null +++ b/GI/GIRepository/Functions.hs @@ -0,0 +1,4961 @@ + + +{- | +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.GIRepository.Functions + ( + + -- * Methods +-- ** argInfoGetClosure #method:argInfoGetClosure# + + argInfoGetClosure , + + +-- ** argInfoGetDestroy #method:argInfoGetDestroy# + + argInfoGetDestroy , + + +-- ** argInfoGetDirection #method:argInfoGetDirection# + + argInfoGetDirection , + + +-- ** argInfoGetOwnershipTransfer #method:argInfoGetOwnershipTransfer# + + argInfoGetOwnershipTransfer , + + +-- ** argInfoGetScope #method:argInfoGetScope# + + argInfoGetScope , + + +-- ** argInfoGetType #method:argInfoGetType# + + argInfoGetType , + + +-- ** argInfoIsCallerAllocates #method:argInfoIsCallerAllocates# + + argInfoIsCallerAllocates , + + +-- ** argInfoIsOptional #method:argInfoIsOptional# + + argInfoIsOptional , + + +-- ** argInfoIsReturnValue #method:argInfoIsReturnValue# + + argInfoIsReturnValue , + + +-- ** argInfoIsSkip #method:argInfoIsSkip# + + argInfoIsSkip , + + +-- ** argInfoLoadType #method:argInfoLoadType# + + argInfoLoadType , + + +-- ** argInfoMayBeNull #method:argInfoMayBeNull# + + argInfoMayBeNull , + + +-- ** callableInfoCanThrowGerror #method:callableInfoCanThrowGerror# + + callableInfoCanThrowGerror , + + +-- ** callableInfoGetArg #method:callableInfoGetArg# + + callableInfoGetArg , + + +-- ** callableInfoGetCallerOwns #method:callableInfoGetCallerOwns# + + callableInfoGetCallerOwns , + + +-- ** callableInfoGetInstanceOwnershipTransfer #method:callableInfoGetInstanceOwnershipTransfer# + + callableInfoGetInstanceOwnershipTransfer, + + +-- ** callableInfoGetNArgs #method:callableInfoGetNArgs# + + callableInfoGetNArgs , + + +-- ** callableInfoGetReturnAttribute #method:callableInfoGetReturnAttribute# + + callableInfoGetReturnAttribute , + + +-- ** callableInfoGetReturnType #method:callableInfoGetReturnType# + + callableInfoGetReturnType , + + +-- ** callableInfoInvoke #method:callableInfoInvoke# + + callableInfoInvoke , + + +-- ** callableInfoIsMethod #method:callableInfoIsMethod# + + callableInfoIsMethod , + + +-- ** callableInfoIterateReturnAttributes #method:callableInfoIterateReturnAttributes# + + callableInfoIterateReturnAttributes , + + +-- ** callableInfoLoadArg #method:callableInfoLoadArg# + + callableInfoLoadArg , + + +-- ** callableInfoLoadReturnType #method:callableInfoLoadReturnType# + + callableInfoLoadReturnType , + + +-- ** callableInfoMayReturnNull #method:callableInfoMayReturnNull# + + callableInfoMayReturnNull , + + +-- ** callableInfoSkipReturn #method:callableInfoSkipReturn# + + callableInfoSkipReturn , + + +-- ** cclosureMarshalGeneric #method:cclosureMarshalGeneric# + + cclosureMarshalGeneric , + + +-- ** constantInfoGetType #method:constantInfoGetType# + + constantInfoGetType , + + +-- ** enumInfoGetErrorDomain #method:enumInfoGetErrorDomain# + + enumInfoGetErrorDomain , + + +-- ** enumInfoGetMethod #method:enumInfoGetMethod# + + enumInfoGetMethod , + + +-- ** enumInfoGetNMethods #method:enumInfoGetNMethods# + + enumInfoGetNMethods , + + +-- ** enumInfoGetNValues #method:enumInfoGetNValues# + + enumInfoGetNValues , + + +-- ** enumInfoGetStorageType #method:enumInfoGetStorageType# + + enumInfoGetStorageType , + + +-- ** enumInfoGetValue #method:enumInfoGetValue# + + enumInfoGetValue , + + +-- ** fieldInfoGetFlags #method:fieldInfoGetFlags# + + fieldInfoGetFlags , + + +-- ** fieldInfoGetOffset #method:fieldInfoGetOffset# + + fieldInfoGetOffset , + + +-- ** fieldInfoGetSize #method:fieldInfoGetSize# + + fieldInfoGetSize , + + +-- ** fieldInfoGetType #method:fieldInfoGetType# + + fieldInfoGetType , + + +-- ** functionInfoGetFlags #method:functionInfoGetFlags# + + functionInfoGetFlags , + + +-- ** functionInfoGetProperty #method:functionInfoGetProperty# + + functionInfoGetProperty , + + +-- ** functionInfoGetSymbol #method:functionInfoGetSymbol# + + functionInfoGetSymbol , + + +-- ** functionInfoGetVfunc #method:functionInfoGetVfunc# + + functionInfoGetVfunc , + + +-- ** infoNew #method:infoNew# + + infoNew , + + +-- ** infoTypeToString #method:infoTypeToString# + + infoTypeToString , + + +-- ** interfaceInfoFindMethod #method:interfaceInfoFindMethod# + + interfaceInfoFindMethod , + + +-- ** interfaceInfoFindSignal #method:interfaceInfoFindSignal# + + interfaceInfoFindSignal , + + +-- ** interfaceInfoFindVfunc #method:interfaceInfoFindVfunc# + + interfaceInfoFindVfunc , + + +-- ** interfaceInfoGetConstant #method:interfaceInfoGetConstant# + + interfaceInfoGetConstant , + + +-- ** interfaceInfoGetIfaceStruct #method:interfaceInfoGetIfaceStruct# + + interfaceInfoGetIfaceStruct , + + +-- ** interfaceInfoGetMethod #method:interfaceInfoGetMethod# + + interfaceInfoGetMethod , + + +-- ** interfaceInfoGetNConstants #method:interfaceInfoGetNConstants# + + interfaceInfoGetNConstants , + + +-- ** interfaceInfoGetNMethods #method:interfaceInfoGetNMethods# + + interfaceInfoGetNMethods , + + +-- ** interfaceInfoGetNPrerequisites #method:interfaceInfoGetNPrerequisites# + + interfaceInfoGetNPrerequisites , + + +-- ** interfaceInfoGetNProperties #method:interfaceInfoGetNProperties# + + interfaceInfoGetNProperties , + + +-- ** interfaceInfoGetNSignals #method:interfaceInfoGetNSignals# + + interfaceInfoGetNSignals , + + +-- ** interfaceInfoGetNVfuncs #method:interfaceInfoGetNVfuncs# + + interfaceInfoGetNVfuncs , + + +-- ** interfaceInfoGetPrerequisite #method:interfaceInfoGetPrerequisite# + + interfaceInfoGetPrerequisite , + + +-- ** interfaceInfoGetProperty #method:interfaceInfoGetProperty# + + interfaceInfoGetProperty , + + +-- ** interfaceInfoGetSignal #method:interfaceInfoGetSignal# + + interfaceInfoGetSignal , + + +-- ** interfaceInfoGetVfunc #method:interfaceInfoGetVfunc# + + interfaceInfoGetVfunc , + + +-- ** invokeErrorQuark #method:invokeErrorQuark# + + invokeErrorQuark , + + +-- ** objectInfoFindMethod #method:objectInfoFindMethod# + + objectInfoFindMethod , + + +-- ** objectInfoFindMethodUsingInterfaces #method:objectInfoFindMethodUsingInterfaces# + + objectInfoFindMethodUsingInterfaces , + + +-- ** objectInfoFindSignal #method:objectInfoFindSignal# + + objectInfoFindSignal , + + +-- ** objectInfoFindVfunc #method:objectInfoFindVfunc# + + objectInfoFindVfunc , + + +-- ** objectInfoFindVfuncUsingInterfaces #method:objectInfoFindVfuncUsingInterfaces# + + objectInfoFindVfuncUsingInterfaces , + + +-- ** objectInfoGetAbstract #method:objectInfoGetAbstract# + + objectInfoGetAbstract , + + +-- ** objectInfoGetClassStruct #method:objectInfoGetClassStruct# + + objectInfoGetClassStruct , + + +-- ** objectInfoGetConstant #method:objectInfoGetConstant# + + objectInfoGetConstant , + + +-- ** objectInfoGetField #method:objectInfoGetField# + + objectInfoGetField , + + +-- ** objectInfoGetFundamental #method:objectInfoGetFundamental# + + objectInfoGetFundamental , + + +-- ** objectInfoGetGetValueFunction #method:objectInfoGetGetValueFunction# + + objectInfoGetGetValueFunction , + + +-- ** objectInfoGetInterface #method:objectInfoGetInterface# + + objectInfoGetInterface , + + +-- ** objectInfoGetMethod #method:objectInfoGetMethod# + + objectInfoGetMethod , + + +-- ** objectInfoGetNConstants #method:objectInfoGetNConstants# + + objectInfoGetNConstants , + + +-- ** objectInfoGetNFields #method:objectInfoGetNFields# + + objectInfoGetNFields , + + +-- ** objectInfoGetNInterfaces #method:objectInfoGetNInterfaces# + + objectInfoGetNInterfaces , + + +-- ** objectInfoGetNMethods #method:objectInfoGetNMethods# + + objectInfoGetNMethods , + + +-- ** objectInfoGetNProperties #method:objectInfoGetNProperties# + + objectInfoGetNProperties , + + +-- ** objectInfoGetNSignals #method:objectInfoGetNSignals# + + objectInfoGetNSignals , + + +-- ** objectInfoGetNVfuncs #method:objectInfoGetNVfuncs# + + objectInfoGetNVfuncs , + + +-- ** objectInfoGetParent #method:objectInfoGetParent# + + objectInfoGetParent , + + +-- ** objectInfoGetProperty #method:objectInfoGetProperty# + + objectInfoGetProperty , + + +-- ** objectInfoGetRefFunction #method:objectInfoGetRefFunction# + + objectInfoGetRefFunction , + + +-- ** objectInfoGetSetValueFunction #method:objectInfoGetSetValueFunction# + + objectInfoGetSetValueFunction , + + +-- ** objectInfoGetSignal #method:objectInfoGetSignal# + + objectInfoGetSignal , + + +-- ** objectInfoGetTypeInit #method:objectInfoGetTypeInit# + + objectInfoGetTypeInit , + + +-- ** objectInfoGetTypeName #method:objectInfoGetTypeName# + + objectInfoGetTypeName , + + +-- ** objectInfoGetUnrefFunction #method:objectInfoGetUnrefFunction# + + objectInfoGetUnrefFunction , + + +-- ** objectInfoGetVfunc #method:objectInfoGetVfunc# + + objectInfoGetVfunc , + + +-- ** propertyInfoGetFlags #method:propertyInfoGetFlags# + + propertyInfoGetFlags , + + +-- ** propertyInfoGetOwnershipTransfer #method:propertyInfoGetOwnershipTransfer# + + propertyInfoGetOwnershipTransfer , + + +-- ** propertyInfoGetType #method:propertyInfoGetType# + + propertyInfoGetType , + + +-- ** registeredTypeInfoGetGType #method:registeredTypeInfoGetGType# + + registeredTypeInfoGetGType , + + +-- ** registeredTypeInfoGetTypeInit #method:registeredTypeInfoGetTypeInit# + + registeredTypeInfoGetTypeInit , + + +-- ** registeredTypeInfoGetTypeName #method:registeredTypeInfoGetTypeName# + + registeredTypeInfoGetTypeName , + + +-- ** signalInfoGetClassClosure #method:signalInfoGetClassClosure# + + signalInfoGetClassClosure , + + +-- ** signalInfoGetFlags #method:signalInfoGetFlags# + + signalInfoGetFlags , + + +-- ** signalInfoTrueStopsEmit #method:signalInfoTrueStopsEmit# + + signalInfoTrueStopsEmit , + + +-- ** structInfoFindField #method:structInfoFindField# + + structInfoFindField , + + +-- ** structInfoFindMethod #method:structInfoFindMethod# + + structInfoFindMethod , + + +-- ** structInfoGetAlignment #method:structInfoGetAlignment# + + structInfoGetAlignment , + + +-- ** structInfoGetField #method:structInfoGetField# + + structInfoGetField , + + +-- ** structInfoGetMethod #method:structInfoGetMethod# + + structInfoGetMethod , + + +-- ** structInfoGetNFields #method:structInfoGetNFields# + + structInfoGetNFields , + + +-- ** structInfoGetNMethods #method:structInfoGetNMethods# + + structInfoGetNMethods , + + +-- ** structInfoGetSize #method:structInfoGetSize# + + structInfoGetSize , + + +-- ** structInfoIsForeign #method:structInfoIsForeign# + + structInfoIsForeign , + + +-- ** structInfoIsGtypeStruct #method:structInfoIsGtypeStruct# + + structInfoIsGtypeStruct , + + +-- ** typeInfoGetArrayFixedSize #method:typeInfoGetArrayFixedSize# + + typeInfoGetArrayFixedSize , + + +-- ** typeInfoGetArrayLength #method:typeInfoGetArrayLength# + + typeInfoGetArrayLength , + + +-- ** typeInfoGetArrayType #method:typeInfoGetArrayType# + + typeInfoGetArrayType , + + +-- ** typeInfoGetInterface #method:typeInfoGetInterface# + + typeInfoGetInterface , + + +-- ** typeInfoGetParamType #method:typeInfoGetParamType# + + typeInfoGetParamType , + + +-- ** typeInfoGetTag #method:typeInfoGetTag# + + typeInfoGetTag , + + +-- ** typeInfoIsPointer #method:typeInfoIsPointer# + + typeInfoIsPointer , + + +-- ** typeInfoIsZeroTerminated #method:typeInfoIsZeroTerminated# + + typeInfoIsZeroTerminated , + + +-- ** typeTagToString #method:typeTagToString# + + typeTagToString , + + +-- ** unionInfoFindMethod #method:unionInfoFindMethod# + + unionInfoFindMethod , + + +-- ** unionInfoGetAlignment #method:unionInfoGetAlignment# + + unionInfoGetAlignment , + + +-- ** unionInfoGetDiscriminator #method:unionInfoGetDiscriminator# + + unionInfoGetDiscriminator , + + +-- ** unionInfoGetDiscriminatorOffset #method:unionInfoGetDiscriminatorOffset# + + unionInfoGetDiscriminatorOffset , + + +-- ** unionInfoGetDiscriminatorType #method:unionInfoGetDiscriminatorType# + + unionInfoGetDiscriminatorType , + + +-- ** unionInfoGetField #method:unionInfoGetField# + + unionInfoGetField , + + +-- ** unionInfoGetMethod #method:unionInfoGetMethod# + + unionInfoGetMethod , + + +-- ** unionInfoGetNFields #method:unionInfoGetNFields# + + unionInfoGetNFields , + + +-- ** unionInfoGetNMethods #method:unionInfoGetNMethods# + + unionInfoGetNMethods , + + +-- ** unionInfoGetSize #method:unionInfoGetSize# + + unionInfoGetSize , + + +-- ** unionInfoIsDiscriminated #method:unionInfoIsDiscriminated# + + unionInfoIsDiscriminated , + + +-- ** valueInfoGetValue #method:valueInfoGetValue# + + valueInfoGetValue , + + +-- ** vfuncInfoGetAddress #method:vfuncInfoGetAddress# + + vfuncInfoGetAddress , + + +-- ** vfuncInfoGetFlags #method:vfuncInfoGetFlags# + + vfuncInfoGetFlags , + + +-- ** vfuncInfoGetInvoker #method:vfuncInfoGetInvoker# + + vfuncInfoGetInvoker , + + +-- ** vfuncInfoGetOffset #method:vfuncInfoGetOffset# + + vfuncInfoGetOffset , + + +-- ** vfuncInfoGetSignal #method:vfuncInfoGetSignal# + + vfuncInfoGetSignal , + + + + + ) 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 {-# SOURCE #-} qualified GI.GIRepository.Enums as GIRepository.Enums +import {-# SOURCE #-} qualified GI.GIRepository.Flags as GIRepository.Flags +import {-# SOURCE #-} qualified GI.GIRepository.Structs.AttributeIter as GIRepository.AttributeIter +import {-# SOURCE #-} qualified GI.GIRepository.Structs.BaseInfo as GIRepository.BaseInfo +import {-# SOURCE #-} qualified GI.GIRepository.Structs.Typelib as GIRepository.Typelib +import {-# SOURCE #-} qualified GI.GIRepository.Unions.Argument as GIRepository.Argument +import qualified GI.GObject.Flags as GObject.Flags + +-- function g_vfunc_info_get_signal +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIVFuncInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_vfunc_info_get_signal" g_vfunc_info_get_signal :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain the signal for the virtual function if one is set. +The signal comes from the object or interface to which +this virtual function belongs. +-} +vfuncInfoGetSignal :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIVFuncInfo/@ -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the signal or 'Nothing' if none set -} +vfuncInfoGetSignal info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_vfunc_info_get_signal info' + checkUnexpectedReturnNULL "vfuncInfoGetSignal" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_vfunc_info_get_offset +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIVFuncInfo", 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 "g_vfunc_info_get_offset" g_vfunc_info_get_offset :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the offset of the function pointer in the class struct. The value +0xFFFF indicates that the struct offset is unknown. +-} +vfuncInfoGetOffset :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIVFuncInfo/@ -} + -> m Int32 + {- ^ __Returns:__ the struct offset or 0xFFFF if it\'s unknown -} +vfuncInfoGetOffset info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_vfunc_info_get_offset info' + touchManagedPtr info + return result + + +-- function g_vfunc_info_get_invoker +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIVFuncInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_vfunc_info_get_invoker" g_vfunc_info_get_invoker :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +If this virtual function has an associated invoker method, this +method will return it. An invoker method is a C entry point. + +Not all virtuals will have invokers. +-} +vfuncInfoGetInvoker :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIVFuncInfo/@ -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIVFuncInfo/@ or 'Nothing'. Free it with +@/g_base_info_unref()/@ when done. -} +vfuncInfoGetInvoker info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_vfunc_info_get_invoker info' + checkUnexpectedReturnNULL "vfuncInfoGetInvoker" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_vfunc_info_get_flags +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIVFuncInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "VFuncInfoFlags"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_vfunc_info_get_flags" g_vfunc_info_get_flags :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CUInt + +{- | +Obtain the flags for this virtual function info. See 'GI.GIRepository.Flags.VFuncInfoFlags' for +more information about possible flag values. +-} +vfuncInfoGetFlags :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIVFuncInfo/@ -} + -> m [GIRepository.Flags.VFuncInfoFlags] + {- ^ __Returns:__ the flags -} +vfuncInfoGetFlags info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_vfunc_info_get_flags info' + let result' = wordToGFlags result + touchManagedPtr info + return result' + + +-- function g_vfunc_info_get_address +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIVFuncInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "implementor_gtype", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GType implementing this virtual function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TPtr) +-- throws : True +-- Skip return : False + +foreign import ccall "g_vfunc_info_get_address" g_vfunc_info_get_address :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + CGType -> -- implementor_gtype : TBasicType TGType + Ptr (Ptr GError) -> -- error + IO (Ptr ()) + +{- | +This method will look up where inside the type struct of /@implementorGtype@/ +is the implementation for /@info@/. +-} +vfuncInfoGetAddress :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIVFuncInfo/@ -} + -> GType + {- ^ /@implementorGtype@/: 'GType' implementing this virtual function -} + -> m (Ptr ()) + {- ^ __Returns:__ address to a function or 'Nothing' if an error happened /(Can throw 'Data.GI.Base.GError.GError')/ -} +vfuncInfoGetAddress info implementorGtype = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + let implementorGtype' = gtypeToCGType implementorGtype + onException (do + result <- propagateGError $ g_vfunc_info_get_address info' implementorGtype' + touchManagedPtr info + return result + ) (do + return () + ) + + +-- function g_value_info_get_value +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIValueInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt64) +-- throws : False +-- Skip return : False + +foreign import ccall "g_value_info_get_value" g_value_info_get_value :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int64 + +{- | +Obtain the enumeration value of the @/GIValueInfo/@. +-} +valueInfoGetValue :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIValueInfo/@ -} + -> m Int64 + {- ^ __Returns:__ the enumeration value. This will always be representable + as a 32-bit signed or unsigned value. The use of gint64 as the + return type is to allow both. -} +valueInfoGetValue info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_value_info_get_value info' + touchManagedPtr info + return result + + +-- function g_union_info_is_discriminated +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIUnionInfo", 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 "g_union_info_is_discriminated" g_union_info_is_discriminated :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CInt + +{- | +Return true if this union contains discriminator field. +-} +unionInfoIsDiscriminated :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIUnionInfo/@ -} + -> m Bool + {- ^ __Returns:__ 'True' if this is a discriminated union, 'False' otherwise -} +unionInfoIsDiscriminated info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_union_info_is_discriminated info' + let result' = (/= 0) result + touchManagedPtr info + return result' + + +-- function g_union_info_get_size +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIUnionInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt64) +-- throws : False +-- Skip return : False + +foreign import ccall "g_union_info_get_size" g_union_info_get_size :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Word64 + +{- | +Obtain the total size of the union. +-} +unionInfoGetSize :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIUnionInfo/@ -} + -> m Word64 + {- ^ __Returns:__ size of the union in bytes -} +unionInfoGetSize info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_union_info_get_size info' + touchManagedPtr info + return result + + +-- function g_union_info_get_n_methods +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIUnionInfo", 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 "g_union_info_get_n_methods" g_union_info_get_n_methods :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the number of methods this union has. +-} +unionInfoGetNMethods :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIUnionInfo/@ -} + -> m Int32 + {- ^ __Returns:__ number of methods -} +unionInfoGetNMethods info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_union_info_get_n_methods info' + touchManagedPtr info + return result + + +-- function g_union_info_get_n_fields +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIUnionInfo", 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 "g_union_info_get_n_fields" g_union_info_get_n_fields :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the number of fields this union has. +-} +unionInfoGetNFields :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIUnionInfo/@ -} + -> m Int32 + {- ^ __Returns:__ number of fields -} +unionInfoGetNFields info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_union_info_get_n_fields info' + touchManagedPtr info + return result + + +-- function g_union_info_get_method +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIUnionInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a method index", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_union_info_get_method" g_union_info_get_method :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Int32 -> -- n : TBasicType TInt + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain the type information for method with specified index. +-} +unionInfoGetMethod :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIUnionInfo/@ -} + -> Int32 + {- ^ /@n@/: a method index -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIFunctionInfo/@, free it with @/g_base_info_unref()/@ +when done. -} +unionInfoGetMethod info n = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_union_info_get_method info' n + checkUnexpectedReturnNULL "unionInfoGetMethod" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_union_info_get_field +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIUnionInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a field index", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_union_info_get_field" g_union_info_get_field :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Int32 -> -- n : TBasicType TInt + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain the type information for field with specified index. +-} +unionInfoGetField :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIUnionInfo/@ -} + -> Int32 + {- ^ /@n@/: a field index -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIFieldInfo/@, free it with @/g_base_info_unref()/@ +when done. -} +unionInfoGetField info n = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_union_info_get_field info' n + checkUnexpectedReturnNULL "unionInfoGetField" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_union_info_get_discriminator_type +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIUnionInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_union_info_get_discriminator_type" g_union_info_get_discriminator_type :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain the type information of the union discriminator. +-} +unionInfoGetDiscriminatorType :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIUnionInfo/@ -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GITypeInfo/@, free it with @/g_base_info_unref()/@ +when done. -} +unionInfoGetDiscriminatorType info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_union_info_get_discriminator_type info' + checkUnexpectedReturnNULL "unionInfoGetDiscriminatorType" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_union_info_get_discriminator_offset +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIUnionInfo", 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 "g_union_info_get_discriminator_offset" g_union_info_get_discriminator_offset :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Returns offset of the discriminator field in the structure. +-} +unionInfoGetDiscriminatorOffset :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIUnionInfo/@ -} + -> m Int32 + {- ^ __Returns:__ offset in bytes of the discriminator -} +unionInfoGetDiscriminatorOffset info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_union_info_get_discriminator_offset info' + touchManagedPtr info + return result + + +-- function g_union_info_get_discriminator +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIUnionInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a union field index", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_union_info_get_discriminator" g_union_info_get_discriminator :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Int32 -> -- n : TBasicType TInt + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain discriminator value assigned for n-th union field, i.e. n-th +union field is the active one if discriminator contains this +constant. +-} +unionInfoGetDiscriminator :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIUnionInfo/@ -} + -> Int32 + {- ^ /@n@/: a union field index -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIConstantInfo/@, free it with @/g_base_info_unref()/@ +when done. -} +unionInfoGetDiscriminator info n = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_union_info_get_discriminator info' n + checkUnexpectedReturnNULL "unionInfoGetDiscriminator" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_union_info_get_alignment +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIUnionInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt64) +-- throws : False +-- Skip return : False + +foreign import ccall "g_union_info_get_alignment" g_union_info_get_alignment :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Word64 + +{- | +Obtain the required alignment of the union. +-} +unionInfoGetAlignment :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIUnionInfo/@ -} + -> m Word64 + {- ^ __Returns:__ required alignment in bytes -} +unionInfoGetAlignment info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_union_info_get_alignment info' + touchManagedPtr info + return result + + +-- function g_union_info_find_method +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIUnionInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a method name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_union_info_find_method" g_union_info_find_method :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + CString -> -- name : TBasicType TUTF8 + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain the type information for method named /@name@/. +-} +unionInfoFindMethod :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIUnionInfo/@ -} + -> T.Text + {- ^ /@name@/: a method name -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIFunctionInfo/@, free it with @/g_base_info_unref()/@ +when done. -} +unionInfoFindMethod info name = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + name' <- textToCString name + result <- g_union_info_find_method info' name' + checkUnexpectedReturnNULL "unionInfoFindMethod" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + freeMem name' + return result' + + +-- function g_type_tag_to_string +-- Args : [Arg {argCName = "type", argType = TInterface (Name {namespace = "GIRepository", name = "TypeTag"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the type_tag", 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 "g_type_tag_to_string" g_type_tag_to_string :: + CUInt -> -- type : TInterface (Name {namespace = "GIRepository", name = "TypeTag"}) + IO CString + +{- | +Obtain a string representation of /@type@/ +-} +typeTagToString :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.Enums.TypeTag + {- ^ /@type@/: the type_tag -} + -> m T.Text + {- ^ __Returns:__ the string -} +typeTagToString type_ = liftIO $ do + let type_' = (fromIntegral . fromEnum) type_ + result <- g_type_tag_to_string type_' + checkUnexpectedReturnNULL "typeTagToString" result + result' <- cstringToText result + return result' + + +-- function g_type_info_is_zero_terminated +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GITypeInfo", 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 "g_type_info_is_zero_terminated" g_type_info_is_zero_terminated :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CInt + +{- | +Obtain if the last element of the array is 'Nothing'. The type tag must be a +@/GI_TYPE_TAG_ARRAY/@ or 'False' will returned. +-} +typeInfoIsZeroTerminated :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GITypeInfo/@ -} + -> m Bool + {- ^ __Returns:__ 'True' if zero terminated -} +typeInfoIsZeroTerminated info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_type_info_is_zero_terminated info' + let result' = (/= 0) result + touchManagedPtr info + return result' + + +-- function g_type_info_is_pointer +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GITypeInfo", 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 "g_type_info_is_pointer" g_type_info_is_pointer :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CInt + +{- | +Obtain if the type is passed as a reference. + +Note that the types of 'GI.GIRepository.Enums.DirectionOut' and 'GI.GIRepository.Enums.DirectionInout' parameters +will only be pointers if the underlying type being transferred is a pointer +(i.e. only if the type of the C function’s formal parameter is a pointer to a +pointer). +-} +typeInfoIsPointer :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GITypeInfo/@ -} + -> m Bool + {- ^ __Returns:__ 'True' if it is a pointer -} +typeInfoIsPointer info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_type_info_is_pointer info' + let result' = (/= 0) result + touchManagedPtr info + return result' + + +-- function g_type_info_get_tag +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GITypeInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "TypeTag"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_type_info_get_tag" g_type_info_get_tag :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CUInt + +{- | +Obtain the type tag for the type. See 'GI.GIRepository.Enums.TypeTag' for a list +of type tags. +-} +typeInfoGetTag :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GITypeInfo/@ -} + -> m GIRepository.Enums.TypeTag + {- ^ __Returns:__ the type tag -} +typeInfoGetTag info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_type_info_get_tag info' + let result' = (toEnum . fromIntegral) result + touchManagedPtr info + return result' + + +-- function g_type_info_get_param_type +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GITypeInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of the parameter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_type_info_get_param_type" g_type_info_get_param_type :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Int32 -> -- n : TBasicType TInt + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain the parameter type /@n@/. +-} +typeInfoGetParamType :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GITypeInfo/@ -} + -> Int32 + {- ^ /@n@/: index of the parameter -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the param type info -} +typeInfoGetParamType info n = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_type_info_get_param_type info' n + checkUnexpectedReturnNULL "typeInfoGetParamType" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_type_info_get_interface +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GITypeInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_type_info_get_interface" g_type_info_get_interface :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +For types which have @/GI_TYPE_TAG_INTERFACE/@ such as GObjects and boxed values, +this function returns full information about the referenced type. You can then +inspect the type of the returned 'GI.GIRepository.Structs.BaseInfo.BaseInfo' to further query whether it is +a concrete GObject, a GInterface, a structure, etc. using 'GI.GIRepository.Structs.BaseInfo.baseInfoGetType'. +-} +typeInfoGetInterface :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GITypeInfo/@ -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the 'GI.GIRepository.Structs.BaseInfo.BaseInfo', or 'Nothing'. Free it with +@/g_base_info_unref()/@ when done. -} +typeInfoGetInterface info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_type_info_get_interface info' + checkUnexpectedReturnNULL "typeInfoGetInterface" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_type_info_get_array_type +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GITypeInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "ArrayType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_type_info_get_array_type" g_type_info_get_array_type :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CUInt + +{- | +Obtain the array type for this type. See 'GI.GIRepository.Enums.ArrayType' for a list of +possible values. If the type tag of this type is not array, -1 will be +returned. +-} +typeInfoGetArrayType :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GITypeInfo/@ -} + -> m GIRepository.Enums.ArrayType + {- ^ __Returns:__ the array type or -1 -} +typeInfoGetArrayType info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_type_info_get_array_type info' + let result' = (toEnum . fromIntegral) result + touchManagedPtr info + return result' + + +-- function g_type_info_get_array_length +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GITypeInfo", 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 "g_type_info_get_array_length" g_type_info_get_array_length :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the array length of the type. The type tag must be a +@/GI_TYPE_TAG_ARRAY/@ or -1 will returned. +-} +typeInfoGetArrayLength :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GITypeInfo/@ -} + -> m Int32 + {- ^ __Returns:__ the array length, or -1 if the type is not an array -} +typeInfoGetArrayLength info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_type_info_get_array_length info' + touchManagedPtr info + return result + + +-- function g_type_info_get_array_fixed_size +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GITypeInfo", 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 "g_type_info_get_array_fixed_size" g_type_info_get_array_fixed_size :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the fixed array size of the type. The type tag must be a +@/GI_TYPE_TAG_ARRAY/@ or -1 will returned. +-} +typeInfoGetArrayFixedSize :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GITypeInfo/@ -} + -> m Int32 + {- ^ __Returns:__ the size or -1 if it\'s not an array -} +typeInfoGetArrayFixedSize info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_type_info_get_array_fixed_size info' + touchManagedPtr info + return result + + +-- function g_struct_info_is_gtype_struct +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIStructInfo", 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 "g_struct_info_is_gtype_struct" g_struct_info_is_gtype_struct :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CInt + +{- | +Return true if this structure represents the \"class structure\" for some +'GI.GObject.Objects.Object.Object' or @/GInterface/@. This function is mainly useful to hide this kind of structure +from generated public APIs. +-} +structInfoIsGtypeStruct :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIStructInfo/@ -} + -> m Bool + {- ^ __Returns:__ 'True' if this is a class struct, 'False' otherwise -} +structInfoIsGtypeStruct info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_struct_info_is_gtype_struct info' + let result' = (/= 0) result + touchManagedPtr info + return result' + + +-- function g_struct_info_is_foreign +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", 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 "g_struct_info_is_foreign" g_struct_info_is_foreign :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CInt + +{- | +TODO +-} +structInfoIsForeign :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: TODO -} + -> m Bool + {- ^ __Returns:__ TODO -} +structInfoIsForeign info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_struct_info_is_foreign info' + let result' = (/= 0) result + touchManagedPtr info + return result' + + +-- function g_struct_info_get_size +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIStructInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt64) +-- throws : False +-- Skip return : False + +foreign import ccall "g_struct_info_get_size" g_struct_info_get_size :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Word64 + +{- | +Obtain the total size of the structure. +-} +structInfoGetSize :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIStructInfo/@ -} + -> m Word64 + {- ^ __Returns:__ size of the structure in bytes -} +structInfoGetSize info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_struct_info_get_size info' + touchManagedPtr info + return result + + +-- function g_struct_info_get_n_methods +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIStructInfo", 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 "g_struct_info_get_n_methods" g_struct_info_get_n_methods :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the number of methods this structure has. +-} +structInfoGetNMethods :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIStructInfo/@ -} + -> m Int32 + {- ^ __Returns:__ number of methods -} +structInfoGetNMethods info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_struct_info_get_n_methods info' + touchManagedPtr info + return result + + +-- function g_struct_info_get_n_fields +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIStructInfo", 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 "g_struct_info_get_n_fields" g_struct_info_get_n_fields :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the number of fields this structure has. +-} +structInfoGetNFields :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIStructInfo/@ -} + -> m Int32 + {- ^ __Returns:__ number of fields -} +structInfoGetNFields info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_struct_info_get_n_fields info' + touchManagedPtr info + return result + + +-- function g_struct_info_get_method +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIStructInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a method index", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_struct_info_get_method" g_struct_info_get_method :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Int32 -> -- n : TBasicType TInt + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain the type information for method with specified index. +-} +structInfoGetMethod :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIStructInfo/@ -} + -> Int32 + {- ^ /@n@/: a method index -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIFunctionInfo/@, free it with @/g_base_info_unref()/@ +when done. -} +structInfoGetMethod info n = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_struct_info_get_method info' n + checkUnexpectedReturnNULL "structInfoGetMethod" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_struct_info_get_field +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIStructInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a field index", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_struct_info_get_field" g_struct_info_get_field :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Int32 -> -- n : TBasicType TInt + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain the type information for field with specified index. +-} +structInfoGetField :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIStructInfo/@ -} + -> Int32 + {- ^ /@n@/: a field index -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIFieldInfo/@, free it with @/g_base_info_unref()/@ +when done. -} +structInfoGetField info n = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_struct_info_get_field info' n + checkUnexpectedReturnNULL "structInfoGetField" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_struct_info_get_alignment +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIStructInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt64) +-- throws : False +-- Skip return : False + +foreign import ccall "g_struct_info_get_alignment" g_struct_info_get_alignment :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Word64 + +{- | +Obtain the required alignment of the structure. +-} +structInfoGetAlignment :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIStructInfo/@ -} + -> m Word64 + {- ^ __Returns:__ required alignment in bytes -} +structInfoGetAlignment info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_struct_info_get_alignment info' + touchManagedPtr info + return result + + +-- function g_struct_info_find_method +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIStructInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a method name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_struct_info_find_method" g_struct_info_find_method :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + CString -> -- name : TBasicType TUTF8 + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain the type information for method named /@name@/. +-} +structInfoFindMethod :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIStructInfo/@ -} + -> T.Text + {- ^ /@name@/: a method name -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIFunctionInfo/@, free it with @/g_base_info_unref()/@ +when done. -} +structInfoFindMethod info name = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + name' <- textToCString name + result <- g_struct_info_find_method info' name' + checkUnexpectedReturnNULL "structInfoFindMethod" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + freeMem name' + return result' + + +-- function g_struct_info_find_field +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIStructInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a field name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_struct_info_find_field" g_struct_info_find_field :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + CString -> -- name : TBasicType TUTF8 + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain the type information for field named /@name@/. + +/Since: 1.46/ +-} +structInfoFindField :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIStructInfo/@ -} + -> T.Text + {- ^ /@name@/: a field name -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIFieldInfo/@ or 'Nothing' if not found, +free it with @/g_base_info_unref()/@ when done. -} +structInfoFindField info name = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + name' <- textToCString name + result <- g_struct_info_find_field info' name' + checkUnexpectedReturnNULL "structInfoFindField" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + freeMem name' + return result' + + +-- function g_signal_info_true_stops_emit +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GISignalInfo", 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 "g_signal_info_true_stops_emit" g_signal_info_true_stops_emit :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CInt + +{- | +Obtain if the returning true in the signal handler will +stop the emission of the signal. +-} +signalInfoTrueStopsEmit :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GISignalInfo/@ -} + -> m Bool + {- ^ __Returns:__ 'True' if returning true stops the signal emission -} +signalInfoTrueStopsEmit info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_signal_info_true_stops_emit info' + let result' = (/= 0) result + touchManagedPtr info + return result' + + +-- function g_signal_info_get_flags +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GISignalInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GObject", name = "SignalFlags"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_signal_info_get_flags" g_signal_info_get_flags :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CUInt + +{- | +Obtain the flags for this signal info. See 'GI.GObject.Flags.SignalFlags' for +more information about possible flag values. +-} +signalInfoGetFlags :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GISignalInfo/@ -} + -> m [GObject.Flags.SignalFlags] + {- ^ __Returns:__ the flags -} +signalInfoGetFlags info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_signal_info_get_flags info' + let result' = wordToGFlags result + touchManagedPtr info + return result' + + +-- function g_signal_info_get_class_closure +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GISignalInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_signal_info_get_class_closure" g_signal_info_get_class_closure :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain the class closure for this signal if one is set. The class +closure is a virtual function on the type that the signal belongs to. +If the signal lacks a closure 'Nothing' will be returned. +-} +signalInfoGetClassClosure :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GISignalInfo/@ -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the class closure or 'Nothing' -} +signalInfoGetClassClosure info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_signal_info_get_class_closure info' + checkUnexpectedReturnNULL "signalInfoGetClassClosure" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_registered_type_info_get_type_name +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIRegisteredTypeInfo", 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 "g_registered_type_info_get_type_name" g_registered_type_info_get_type_name :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CString + +{- | +Obtain the type name of the struct within the GObject type system. +This type can be passed to 'GI.GObject.Functions.typeName' to get a 'GType'. +-} +registeredTypeInfoGetTypeName :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIRegisteredTypeInfo/@ -} + -> m T.Text + {- ^ __Returns:__ the type name -} +registeredTypeInfoGetTypeName info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_registered_type_info_get_type_name info' + checkUnexpectedReturnNULL "registeredTypeInfoGetTypeName" result + result' <- cstringToText result + touchManagedPtr info + return result' + + +-- function g_registered_type_info_get_type_init +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIRegisteredTypeInfo", 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 "g_registered_type_info_get_type_init" g_registered_type_info_get_type_init :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CString + +{- | +Obtain the type init function for /@info@/. The type init function is the +function which will register the GType within the GObject type system. +Usually this is not called by langauge bindings or applications, use +'GI.GIRepository.Functions.registeredTypeInfoGetGType' directly instead. +-} +registeredTypeInfoGetTypeInit :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIRegisteredTypeInfo/@ -} + -> m T.Text + {- ^ __Returns:__ the symbol name of the type init function, suitable for +passing into @/g_module_symbol()/@. -} +registeredTypeInfoGetTypeInit info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_registered_type_info_get_type_init info' + checkUnexpectedReturnNULL "registeredTypeInfoGetTypeInit" result + result' <- cstringToText result + touchManagedPtr info + return result' + + +-- function g_registered_type_info_get_g_type +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIRegisteredTypeInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TGType) +-- throws : False +-- Skip return : False + +foreign import ccall "g_registered_type_info_get_g_type" g_registered_type_info_get_g_type :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CGType + +{- | +Obtain the 'GType' for this registered type or G_TYPE_NONE which a special meaning. +It means that either there is no type information associated with this /@info@/ or +that the shared library which provides the type_init function for this +/@info@/ cannot be called. +-} +registeredTypeInfoGetGType :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIRegisteredTypeInfo/@ -} + -> m GType + {- ^ __Returns:__ the 'GType'. -} +registeredTypeInfoGetGType info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_registered_type_info_get_g_type info' + let result' = GType result + touchManagedPtr info + return result' + + +-- function g_property_info_get_type +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIPropertyInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_property_info_get_type" g_property_info_get_type :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain the type information for the property /@info@/. +-} +propertyInfoGetType :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIPropertyInfo/@ -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GITypeInfo/@, free it with +@/g_base_info_unref()/@ when done. -} +propertyInfoGetType info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_property_info_get_type info' + checkUnexpectedReturnNULL "propertyInfoGetType" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_property_info_get_ownership_transfer +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIPropertyInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "Transfer"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_property_info_get_ownership_transfer" g_property_info_get_ownership_transfer :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CUInt + +{- | +Obtain the ownership transfer for this property. See 'GI.GIRepository.Enums.Transfer' for more +information about transfer values. +-} +propertyInfoGetOwnershipTransfer :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIPropertyInfo/@ -} + -> m GIRepository.Enums.Transfer + {- ^ __Returns:__ the transfer -} +propertyInfoGetOwnershipTransfer info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_property_info_get_ownership_transfer info' + let result' = (toEnum . fromIntegral) result + touchManagedPtr info + return result' + + +-- function g_property_info_get_flags +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIPropertyInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GObject", name = "ParamFlags"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_property_info_get_flags" g_property_info_get_flags :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CUInt + +{- | +Obtain the flags for this property info. See 'GI.GObject.Flags.ParamFlags' for +more information about possible flag values. +-} +propertyInfoGetFlags :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIPropertyInfo/@ -} + -> m [GObject.Flags.ParamFlags] + {- ^ __Returns:__ the flags -} +propertyInfoGetFlags info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_property_info_get_flags info' + let result' = wordToGFlags result + touchManagedPtr info + return result' + + +-- function g_object_info_get_vfunc +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of virtual function to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_object_info_get_vfunc" g_object_info_get_vfunc :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Int32 -> -- n : TBasicType TInt + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain an object type virtual function at index /@n@/. +-} +objectInfoGetVfunc :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> Int32 + {- ^ /@n@/: index of virtual function to get -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIVFuncInfo/@. Free the struct by calling +@/g_base_info_unref()/@ when done. -} +objectInfoGetVfunc info n = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_object_info_get_vfunc info' n + checkUnexpectedReturnNULL "objectInfoGetVfunc" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_object_info_get_unref_function +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", 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 "g_object_info_get_unref_function" g_object_info_get_unref_function :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CString + +{- | +Obtain the symbol name of the function that should be called to unref this +object type. It\'s mainly used fundamental types. The type signature for +the symbol is @/GIObjectInfoUnrefFunction/@, to fetch the function pointer +see 'GI.GIRepository.Functions.objectInfoGetUnrefFunction'. +-} +objectInfoGetUnrefFunction :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> m T.Text + {- ^ __Returns:__ the symbol or 'Nothing' -} +objectInfoGetUnrefFunction info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_object_info_get_unref_function info' + checkUnexpectedReturnNULL "objectInfoGetUnrefFunction" result + result' <- cstringToText result + touchManagedPtr info + return result' + + +-- function g_object_info_get_type_name +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", 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 "g_object_info_get_type_name" g_object_info_get_type_name :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CString + +{- | +Obtain the name of the objects class\/type. +-} +objectInfoGetTypeName :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> m T.Text + {- ^ __Returns:__ name of the objects type -} +objectInfoGetTypeName info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_object_info_get_type_name info' + checkUnexpectedReturnNULL "objectInfoGetTypeName" result + result' <- cstringToText result + touchManagedPtr info + return result' + + +-- function g_object_info_get_type_init +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", 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 "g_object_info_get_type_init" g_object_info_get_type_init :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CString + +{- | +Obtain the function which when called will return the GType +function for which this object type is registered. +-} +objectInfoGetTypeInit :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> m T.Text + {- ^ __Returns:__ the type init function -} +objectInfoGetTypeInit info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_object_info_get_type_init info' + checkUnexpectedReturnNULL "objectInfoGetTypeInit" result + result' <- cstringToText result + touchManagedPtr info + return result' + + +-- function g_object_info_get_signal +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of signal to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_object_info_get_signal" g_object_info_get_signal :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Int32 -> -- n : TBasicType TInt + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain an object type signal at index /@n@/. +-} +objectInfoGetSignal :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> Int32 + {- ^ /@n@/: index of signal to get -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GISignalInfo/@. Free the struct by calling +@/g_base_info_unref()/@ when done. -} +objectInfoGetSignal info n = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_object_info_get_signal info' n + checkUnexpectedReturnNULL "objectInfoGetSignal" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_object_info_get_set_value_function +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", 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 "g_object_info_get_set_value_function" g_object_info_get_set_value_function :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CString + +{- | +Obtain the symbol name of the function that should be called to convert +set a GValue giving an object instance pointer of this object type. +I\'s mainly used fundamental types. The type signature for the symbol +is @/GIObjectInfoSetValueFunction/@, to fetch the function pointer +see 'GI.GIRepository.Functions.objectInfoGetSetValueFunction'. +-} +objectInfoGetSetValueFunction :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> m T.Text + {- ^ __Returns:__ the symbol or 'Nothing' -} +objectInfoGetSetValueFunction info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_object_info_get_set_value_function info' + checkUnexpectedReturnNULL "objectInfoGetSetValueFunction" result + result' <- cstringToText result + touchManagedPtr info + return result' + + +-- function g_object_info_get_ref_function +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", 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 "g_object_info_get_ref_function" g_object_info_get_ref_function :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CString + +{- | +Obtain the symbol name of the function that should be called to ref this +object type. It\'s mainly used fundamental types. The type signature for +the symbol is @/GIObjectInfoRefFunction/@, to fetch the function pointer +see 'GI.GIRepository.Functions.objectInfoGetRefFunction'. +-} +objectInfoGetRefFunction :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> m T.Text + {- ^ __Returns:__ the symbol or 'Nothing' -} +objectInfoGetRefFunction info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_object_info_get_ref_function info' + checkUnexpectedReturnNULL "objectInfoGetRefFunction" result + result' <- cstringToText result + touchManagedPtr info + return result' + + +-- function g_object_info_get_property +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of property to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_object_info_get_property" g_object_info_get_property :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Int32 -> -- n : TBasicType TInt + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain an object type property at index /@n@/. +-} +objectInfoGetProperty :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> Int32 + {- ^ /@n@/: index of property to get -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIPropertyInfo/@. Free the struct by calling +@/g_base_info_unref()/@ when done. -} +objectInfoGetProperty info n = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_object_info_get_property info' n + checkUnexpectedReturnNULL "objectInfoGetProperty" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_object_info_get_parent +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_object_info_get_parent" g_object_info_get_parent :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain the parent of the object type. +-} +objectInfoGetParent :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIObjectInfo/@. Free the struct by calling +@/g_base_info_unref()/@ when done. -} +objectInfoGetParent info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_object_info_get_parent info' + checkUnexpectedReturnNULL "objectInfoGetParent" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_object_info_get_n_vfuncs +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", 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 "g_object_info_get_n_vfuncs" g_object_info_get_n_vfuncs :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the number of virtual functions that this object type has. +-} +objectInfoGetNVfuncs :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> m Int32 + {- ^ __Returns:__ number of virtual functions -} +objectInfoGetNVfuncs info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_object_info_get_n_vfuncs info' + touchManagedPtr info + return result + + +-- function g_object_info_get_n_signals +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", 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 "g_object_info_get_n_signals" g_object_info_get_n_signals :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the number of signals that this object type has. +-} +objectInfoGetNSignals :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> m Int32 + {- ^ __Returns:__ number of signals -} +objectInfoGetNSignals info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_object_info_get_n_signals info' + touchManagedPtr info + return result + + +-- function g_object_info_get_n_properties +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", 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 "g_object_info_get_n_properties" g_object_info_get_n_properties :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the number of properties that this object type has. +-} +objectInfoGetNProperties :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> m Int32 + {- ^ __Returns:__ number of properties -} +objectInfoGetNProperties info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_object_info_get_n_properties info' + touchManagedPtr info + return result + + +-- function g_object_info_get_n_methods +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", 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 "g_object_info_get_n_methods" g_object_info_get_n_methods :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the number of methods that this object type has. +-} +objectInfoGetNMethods :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> m Int32 + {- ^ __Returns:__ number of methods -} +objectInfoGetNMethods info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_object_info_get_n_methods info' + touchManagedPtr info + return result + + +-- function g_object_info_get_n_interfaces +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", 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 "g_object_info_get_n_interfaces" g_object_info_get_n_interfaces :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the number of interfaces that this object type has. +-} +objectInfoGetNInterfaces :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> m Int32 + {- ^ __Returns:__ number of interfaces -} +objectInfoGetNInterfaces info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_object_info_get_n_interfaces info' + touchManagedPtr info + return result + + +-- function g_object_info_get_n_fields +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", 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 "g_object_info_get_n_fields" g_object_info_get_n_fields :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the number of fields that this object type has. +-} +objectInfoGetNFields :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> m Int32 + {- ^ __Returns:__ number of fields -} +objectInfoGetNFields info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_object_info_get_n_fields info' + touchManagedPtr info + return result + + +-- function g_object_info_get_n_constants +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", 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 "g_object_info_get_n_constants" g_object_info_get_n_constants :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the number of constants that this object type has. +-} +objectInfoGetNConstants :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> m Int32 + {- ^ __Returns:__ number of constants -} +objectInfoGetNConstants info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_object_info_get_n_constants info' + touchManagedPtr info + return result + + +-- function g_object_info_get_method +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of method to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_object_info_get_method" g_object_info_get_method :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Int32 -> -- n : TBasicType TInt + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain an object type method at index /@n@/. +-} +objectInfoGetMethod :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> Int32 + {- ^ /@n@/: index of method to get -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIFunctionInfo/@. Free the struct by calling +@/g_base_info_unref()/@ when done. -} +objectInfoGetMethod info n = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_object_info_get_method info' n + checkUnexpectedReturnNULL "objectInfoGetMethod" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_object_info_get_interface +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of interface to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_object_info_get_interface" g_object_info_get_interface :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Int32 -> -- n : TBasicType TInt + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain an object type interface at index /@n@/. +-} +objectInfoGetInterface :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> Int32 + {- ^ /@n@/: index of interface to get -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIInterfaceInfo/@. Free the struct by calling +@/g_base_info_unref()/@ when done. -} +objectInfoGetInterface info n = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_object_info_get_interface info' n + checkUnexpectedReturnNULL "objectInfoGetInterface" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_object_info_get_get_value_function +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", 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 "g_object_info_get_get_value_function" g_object_info_get_get_value_function :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CString + +{- | +Obtain the symbol name of the function that should be called to convert +an object instance pointer of this object type to a GValue. +I\'s mainly used fundamental types. The type signature for the symbol +is @/GIObjectInfoGetValueFunction/@, to fetch the function pointer +see 'GI.GIRepository.Functions.objectInfoGetGetValueFunction'. +-} +objectInfoGetGetValueFunction :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> m T.Text + {- ^ __Returns:__ the symbol or 'Nothing' -} +objectInfoGetGetValueFunction info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_object_info_get_get_value_function info' + checkUnexpectedReturnNULL "objectInfoGetGetValueFunction" result + result' <- cstringToText result + touchManagedPtr info + return result' + + +-- function g_object_info_get_fundamental +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", 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 "g_object_info_get_fundamental" g_object_info_get_fundamental :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CInt + +{- | +Obtain if the object type is of a fundamental type which is not +G_TYPE_OBJECT. This is mostly for supporting GstMiniObject. +-} +objectInfoGetFundamental :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> m Bool + {- ^ __Returns:__ 'True' if the object type is a fundamental type -} +objectInfoGetFundamental info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_object_info_get_fundamental info' + let result' = (/= 0) result + touchManagedPtr info + return result' + + +-- function g_object_info_get_field +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of field to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_object_info_get_field" g_object_info_get_field :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Int32 -> -- n : TBasicType TInt + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain an object type field at index /@n@/. +-} +objectInfoGetField :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> Int32 + {- ^ /@n@/: index of field to get -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIFieldInfo/@. Free the struct by calling +@/g_base_info_unref()/@ when done. -} +objectInfoGetField info n = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_object_info_get_field info' n + checkUnexpectedReturnNULL "objectInfoGetField" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_object_info_get_constant +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of constant to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_object_info_get_constant" g_object_info_get_constant :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Int32 -> -- n : TBasicType TInt + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain an object type constant at index /@n@/. +-} +objectInfoGetConstant :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> Int32 + {- ^ /@n@/: index of constant to get -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIConstantInfo/@. Free the struct by calling +@/g_base_info_unref()/@ when done. -} +objectInfoGetConstant info n = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_object_info_get_constant info' n + checkUnexpectedReturnNULL "objectInfoGetConstant" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_object_info_get_class_struct +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_object_info_get_class_struct" g_object_info_get_class_struct :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Every 'GI.GObject.Objects.Object.Object' has two structures; an instance structure and a class +structure. This function returns the metadata for the class structure. +-} +objectInfoGetClassStruct :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIStructInfo/@ or 'Nothing'. Free with +@/g_base_info_unref()/@ when done. -} +objectInfoGetClassStruct info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_object_info_get_class_struct info' + checkUnexpectedReturnNULL "objectInfoGetClassStruct" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_object_info_get_abstract +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", 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 "g_object_info_get_abstract" g_object_info_get_abstract :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CInt + +{- | +Obtain if the object type is an abstract type, eg if it cannot be +instantiated +-} +objectInfoGetAbstract :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> m Bool + {- ^ __Returns:__ 'True' if the object type is abstract -} +objectInfoGetAbstract info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_object_info_get_abstract info' + let result' = (/= 0) result + touchManagedPtr info + return result' + + +-- function g_object_info_find_vfunc_using_interfaces +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of vfunc to obtain", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "implementor", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The implementor of the interface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_object_info_find_vfunc_using_interfaces" g_object_info_find_vfunc_using_interfaces :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + CString -> -- name : TBasicType TUTF8 + Ptr (Ptr GIRepository.BaseInfo.BaseInfo) -> -- implementor : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Locate a virtual function slot with name /@name@/, searching both the object +/@info@/ and any interfaces it implements. Note that the namespace for +virtuals is distinct from that of methods; there may or may not be a +concrete method associated for a virtual. If there is one, it may be +retrieved using 'GI.GIRepository.Functions.vfuncInfoGetInvoker', otherwise 'Nothing' will be +returned. + +Note that this function does *not* search parent classes; you will have +to chain up if that\'s desired. +-} +objectInfoFindVfuncUsingInterfaces :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> T.Text + {- ^ /@name@/: name of vfunc to obtain -} + -> m ((GIRepository.BaseInfo.BaseInfo, GIRepository.BaseInfo.BaseInfo)) + {- ^ __Returns:__ the @/GIVFuncInfo/@. Free the struct by calling +@/g_base_info_unref()/@ when done. -} +objectInfoFindVfuncUsingInterfaces info name = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + name' <- textToCString name + implementor <- allocMem :: IO (Ptr (Ptr GIRepository.BaseInfo.BaseInfo)) + result <- g_object_info_find_vfunc_using_interfaces info' name' implementor + checkUnexpectedReturnNULL "objectInfoFindVfuncUsingInterfaces" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + implementor' <- peek implementor + implementor'' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) implementor' + touchManagedPtr info + freeMem name' + freeMem implementor + return (result', implementor'') + + +-- function g_object_info_find_vfunc +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", 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 "The name of a virtual function to find.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_object_info_find_vfunc" g_object_info_find_vfunc :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + CString -> -- name : TBasicType TUTF8 + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Locate a virtual function slot with name /@name@/. Note that the namespace +for virtuals is distinct from that of methods; there may or may not be +a concrete method associated for a virtual. If there is one, it may +be retrieved using 'GI.GIRepository.Functions.vfuncInfoGetInvoker', otherwise 'Nothing' will be +returned. +See the documentation for 'GI.GIRepository.Functions.vfuncInfoGetInvoker' for more +information on invoking virtuals. +-} +objectInfoFindVfunc :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> T.Text + {- ^ /@name@/: The name of a virtual function to find. -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIVFuncInfo/@, or 'Nothing'. Free it with +@/g_base_info_unref()/@ when done. -} +objectInfoFindVfunc info name = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + name' <- textToCString name + result <- g_object_info_find_vfunc info' name' + checkUnexpectedReturnNULL "objectInfoFindVfunc" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + freeMem name' + return result' + + +-- function g_object_info_find_signal +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of signal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_object_info_find_signal" g_object_info_find_signal :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + CString -> -- name : TBasicType TUTF8 + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +TODO +-} +objectInfoFindSignal :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> T.Text + {- ^ /@name@/: Name of signal -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ Info for the signal with name /@name@/ in /@info@/, or 'Nothing' on failure. -} +objectInfoFindSignal info name = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + name' <- textToCString name + result <- g_object_info_find_signal info' name' + checkUnexpectedReturnNULL "objectInfoFindSignal" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + freeMem name' + return result' + + +-- function g_object_info_find_method_using_interfaces +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of method to obtain", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "implementor", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The implementor of the interface", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_object_info_find_method_using_interfaces" g_object_info_find_method_using_interfaces :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + CString -> -- name : TBasicType TUTF8 + Ptr (Ptr GIRepository.BaseInfo.BaseInfo) -> -- implementor : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain a method of the object given a /@name@/, searching both the +object /@info@/ and any interfaces it implements. 'Nothing' will be +returned if there\'s no method available with that name. + +Note that this function does *not* search parent classes; you will have +to chain up if that\'s desired. +-} +objectInfoFindMethodUsingInterfaces :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> T.Text + {- ^ /@name@/: name of method to obtain -} + -> m ((GIRepository.BaseInfo.BaseInfo, GIRepository.BaseInfo.BaseInfo)) + {- ^ __Returns:__ the @/GIFunctionInfo/@. Free the struct by calling +@/g_base_info_unref()/@ when done. -} +objectInfoFindMethodUsingInterfaces info name = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + name' <- textToCString name + implementor <- allocMem :: IO (Ptr (Ptr GIRepository.BaseInfo.BaseInfo)) + result <- g_object_info_find_method_using_interfaces info' name' implementor + checkUnexpectedReturnNULL "objectInfoFindMethodUsingInterfaces" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + implementor' <- peek implementor + implementor'' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) implementor' + touchManagedPtr info + freeMem name' + freeMem implementor + return (result', implementor'') + + +-- function g_object_info_find_method +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIObjectInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of method to obtain", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_object_info_find_method" g_object_info_find_method :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + CString -> -- name : TBasicType TUTF8 + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain a method of the object type given a /@name@/. 'Nothing' will be +returned if there\'s no method available with that name. +-} +objectInfoFindMethod :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIObjectInfo/@ -} + -> T.Text + {- ^ /@name@/: name of method to obtain -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIFunctionInfo/@. Free the struct by calling +@/g_base_info_unref()/@ when done. -} +objectInfoFindMethod info name = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + name' <- textToCString name + result <- g_object_info_find_method info' name' + checkUnexpectedReturnNULL "objectInfoFindMethod" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + freeMem name' + return result' + + +-- function g_invoke_error_quark +-- Args : [] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "g_invoke_error_quark" g_invoke_error_quark :: + IO Word32 + +{- | +TODO +-} +invokeErrorQuark :: + (B.CallStack.HasCallStack, MonadIO m) => + m Word32 + {- ^ __Returns:__ TODO -} +invokeErrorQuark = liftIO $ do + result <- g_invoke_error_quark + return result + + +-- function g_interface_info_get_vfunc +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of virtual function to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_interface_info_get_vfunc" g_interface_info_get_vfunc :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Int32 -> -- n : TBasicType TInt + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain an interface type virtual function at index /@n@/. +-} +interfaceInfoGetVfunc :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIInterfaceInfo/@ -} + -> Int32 + {- ^ /@n@/: index of virtual function to get -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIVFuncInfo/@. Free the struct by calling +@/g_base_info_unref()/@ when done. -} +interfaceInfoGetVfunc info n = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_interface_info_get_vfunc info' n + checkUnexpectedReturnNULL "interfaceInfoGetVfunc" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_interface_info_get_signal +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of signal to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_interface_info_get_signal" g_interface_info_get_signal :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Int32 -> -- n : TBasicType TInt + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain an interface type signal at index /@n@/. +-} +interfaceInfoGetSignal :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIInterfaceInfo/@ -} + -> Int32 + {- ^ /@n@/: index of signal to get -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GISignalInfo/@. Free the struct by calling +@/g_base_info_unref()/@ when done. -} +interfaceInfoGetSignal info n = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_interface_info_get_signal info' n + checkUnexpectedReturnNULL "interfaceInfoGetSignal" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_interface_info_get_property +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of property to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_interface_info_get_property" g_interface_info_get_property :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Int32 -> -- n : TBasicType TInt + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain an interface type property at index /@n@/. +-} +interfaceInfoGetProperty :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIInterfaceInfo/@ -} + -> Int32 + {- ^ /@n@/: index of property to get -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIPropertyInfo/@. Free the struct by calling +@/g_base_info_unref()/@ when done. -} +interfaceInfoGetProperty info n = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_interface_info_get_property info' n + checkUnexpectedReturnNULL "interfaceInfoGetProperty" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_interface_info_get_prerequisite +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of prerequisites to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_interface_info_get_prerequisite" g_interface_info_get_prerequisite :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Int32 -> -- n : TBasicType TInt + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain an interface type prerequisites index /@n@/. +-} +interfaceInfoGetPrerequisite :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIInterfaceInfo/@ -} + -> Int32 + {- ^ /@n@/: index of prerequisites to get -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the prerequisites as a 'GI.GIRepository.Structs.BaseInfo.BaseInfo'. Free the struct by calling +@/g_base_info_unref()/@ when done. -} +interfaceInfoGetPrerequisite info n = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_interface_info_get_prerequisite info' n + checkUnexpectedReturnNULL "interfaceInfoGetPrerequisite" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_interface_info_get_n_vfuncs +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", 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 "g_interface_info_get_n_vfuncs" g_interface_info_get_n_vfuncs :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the number of virtual functions that this interface type has. +-} +interfaceInfoGetNVfuncs :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIInterfaceInfo/@ -} + -> m Int32 + {- ^ __Returns:__ number of virtual functions -} +interfaceInfoGetNVfuncs info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_interface_info_get_n_vfuncs info' + touchManagedPtr info + return result + + +-- function g_interface_info_get_n_signals +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", 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 "g_interface_info_get_n_signals" g_interface_info_get_n_signals :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the number of signals that this interface type has. +-} +interfaceInfoGetNSignals :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIInterfaceInfo/@ -} + -> m Int32 + {- ^ __Returns:__ number of signals -} +interfaceInfoGetNSignals info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_interface_info_get_n_signals info' + touchManagedPtr info + return result + + +-- function g_interface_info_get_n_properties +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", 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 "g_interface_info_get_n_properties" g_interface_info_get_n_properties :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the number of properties that this interface type has. +-} +interfaceInfoGetNProperties :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIInterfaceInfo/@ -} + -> m Int32 + {- ^ __Returns:__ number of properties -} +interfaceInfoGetNProperties info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_interface_info_get_n_properties info' + touchManagedPtr info + return result + + +-- function g_interface_info_get_n_prerequisites +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", 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 "g_interface_info_get_n_prerequisites" g_interface_info_get_n_prerequisites :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the number of prerequisites for this interface type. +A prerequisites is another interface that needs to be implemented for +interface, similar to an base class for GObjects. +-} +interfaceInfoGetNPrerequisites :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIInterfaceInfo/@ -} + -> m Int32 + {- ^ __Returns:__ number of prerequisites -} +interfaceInfoGetNPrerequisites info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_interface_info_get_n_prerequisites info' + touchManagedPtr info + return result + + +-- function g_interface_info_get_n_methods +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", 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 "g_interface_info_get_n_methods" g_interface_info_get_n_methods :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the number of methods that this interface type has. +-} +interfaceInfoGetNMethods :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIInterfaceInfo/@ -} + -> m Int32 + {- ^ __Returns:__ number of methods -} +interfaceInfoGetNMethods info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_interface_info_get_n_methods info' + touchManagedPtr info + return result + + +-- function g_interface_info_get_n_constants +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", 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 "g_interface_info_get_n_constants" g_interface_info_get_n_constants :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the number of constants that this interface type has. +-} +interfaceInfoGetNConstants :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIInterfaceInfo/@ -} + -> m Int32 + {- ^ __Returns:__ number of constants -} +interfaceInfoGetNConstants info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_interface_info_get_n_constants info' + touchManagedPtr info + return result + + +-- function g_interface_info_get_method +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of method to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_interface_info_get_method" g_interface_info_get_method :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Int32 -> -- n : TBasicType TInt + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain an interface type method at index /@n@/. +-} +interfaceInfoGetMethod :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIInterfaceInfo/@ -} + -> Int32 + {- ^ /@n@/: index of method to get -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIFunctionInfo/@. Free the struct by calling +@/g_base_info_unref()/@ when done. -} +interfaceInfoGetMethod info n = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_interface_info_get_method info' n + checkUnexpectedReturnNULL "interfaceInfoGetMethod" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_interface_info_get_iface_struct +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_interface_info_get_iface_struct" g_interface_info_get_iface_struct :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Returns the layout C structure associated with this @/GInterface/@. +-} +interfaceInfoGetIfaceStruct :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIInterfaceInfo/@ -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIStructInfo/@ or 'Nothing'. Free it with +@/g_base_info_unref()/@ when done. -} +interfaceInfoGetIfaceStruct info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_interface_info_get_iface_struct info' + checkUnexpectedReturnNULL "interfaceInfoGetIfaceStruct" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_interface_info_get_constant +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of constant to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_interface_info_get_constant" g_interface_info_get_constant :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Int32 -> -- n : TBasicType TInt + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain an interface type constant at index /@n@/. +-} +interfaceInfoGetConstant :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIInterfaceInfo/@ -} + -> Int32 + {- ^ /@n@/: index of constant to get -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIConstantInfo/@. Free the struct by calling +@/g_base_info_unref()/@ when done. -} +interfaceInfoGetConstant info n = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_interface_info_get_constant info' n + checkUnexpectedReturnNULL "interfaceInfoGetConstant" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_interface_info_find_vfunc +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", 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 "The name of a virtual function to find.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_interface_info_find_vfunc" g_interface_info_find_vfunc :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + CString -> -- name : TBasicType TUTF8 + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Locate a virtual function slot with name /@name@/. See the documentation +for 'GI.GIRepository.Functions.objectInfoFindVfunc' for more information on virtuals. +-} +interfaceInfoFindVfunc :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIInterfaceInfo/@ -} + -> T.Text + {- ^ /@name@/: The name of a virtual function to find. -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIVFuncInfo/@, or 'Nothing'. Free it with +@/g_base_info_unref()/@ when done. -} +interfaceInfoFindVfunc info name = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + name' <- textToCString name + result <- g_interface_info_find_vfunc info' name' + checkUnexpectedReturnNULL "interfaceInfoFindVfunc" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + freeMem name' + return result' + + +-- function g_interface_info_find_signal +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name of signal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_interface_info_find_signal" g_interface_info_find_signal :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + CString -> -- name : TBasicType TUTF8 + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +TODO + +/Since: 1.34/ +-} +interfaceInfoFindSignal :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIInterfaceInfo/@ -} + -> T.Text + {- ^ /@name@/: Name of signal -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ Info for the signal with name /@name@/ in /@info@/, or +'Nothing' on failure. -} +interfaceInfoFindSignal info name = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + name' <- textToCString name + result <- g_interface_info_find_signal info' name' + checkUnexpectedReturnNULL "interfaceInfoFindSignal" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + freeMem name' + return result' + + +-- function g_interface_info_find_method +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIInterfaceInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of method to obtain", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_interface_info_find_method" g_interface_info_find_method :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + CString -> -- name : TBasicType TUTF8 + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain a method of the interface type given a /@name@/. 'Nothing' will be +returned if there\'s no method available with that name. +-} +interfaceInfoFindMethod :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIInterfaceInfo/@ -} + -> T.Text + {- ^ /@name@/: name of method to obtain -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIFunctionInfo/@ or 'Nothing' if none found. +Free the struct by calling @/g_base_info_unref()/@ when done. -} +interfaceInfoFindMethod info name = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + name' <- textToCString name + result <- g_interface_info_find_method info' name' + checkUnexpectedReturnNULL "interfaceInfoFindMethod" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + freeMem name' + return result' + + +-- function g_info_type_to_string +-- Args : [Arg {argCName = "type", argType = TInterface (Name {namespace = "GIRepository", name = "InfoType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the info type", 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 "g_info_type_to_string" g_info_type_to_string :: + CUInt -> -- type : TInterface (Name {namespace = "GIRepository", name = "InfoType"}) + IO CString + +{- | +Obtain a string representation of /@type@/ +-} +infoTypeToString :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.Enums.InfoType + {- ^ /@type@/: the info type -} + -> m T.Text + {- ^ __Returns:__ the string -} +infoTypeToString type_ = liftIO $ do + let type_' = (fromIntegral . fromEnum) type_ + result <- g_info_type_to_string type_' + checkUnexpectedReturnNULL "infoTypeToString" result + result' <- cstringToText result + return result' + + +-- function g_info_new +-- Args : [Arg {argCName = "type", argType = TInterface (Name {namespace = "GIRepository", name = "InfoType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "container", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "typelib", argType = TInterface (Name {namespace = "GIRepository", name = "Typelib"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_info_new" g_info_new :: + CUInt -> -- type : TInterface (Name {namespace = "GIRepository", name = "InfoType"}) + Ptr GIRepository.BaseInfo.BaseInfo -> -- container : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Ptr GIRepository.Typelib.Typelib -> -- typelib : TInterface (Name {namespace = "GIRepository", name = "Typelib"}) + Word32 -> -- offset : TBasicType TUInt32 + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +TODO +-} +infoNew :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.Enums.InfoType + {- ^ /@type@/: TODO -} + -> GIRepository.BaseInfo.BaseInfo + {- ^ /@container@/: TODO -} + -> GIRepository.Typelib.Typelib + {- ^ /@typelib@/: TODO -} + -> Word32 + {- ^ /@offset@/: TODO -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ TODO -} +infoNew type_ container typelib offset = liftIO $ do + let type_' = (fromIntegral . fromEnum) type_ + container' <- unsafeManagedPtrGetPtr container + typelib' <- unsafeManagedPtrGetPtr typelib + result <- g_info_new type_' container' typelib' offset + checkUnexpectedReturnNULL "infoNew" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr container + touchManagedPtr typelib + return result' + + +-- function g_function_info_get_vfunc +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIFunctionInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_function_info_get_vfunc" g_function_info_get_vfunc :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain the virtual function associated with this @/GIFunctionInfo/@. +Only @/GIFunctionInfo/@ with the flag 'GI.GIRepository.Flags.FunctionInfoFlagsWrapsVfunc' has +a virtual function set. For other cases, 'Nothing' will be returned. +-} +functionInfoGetVfunc :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIFunctionInfo/@ -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the virtual function or 'Nothing' if not set. +Free it by calling @/g_base_info_unref()/@ when done. -} +functionInfoGetVfunc info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_function_info_get_vfunc info' + checkUnexpectedReturnNULL "functionInfoGetVfunc" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_function_info_get_symbol +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIFunctionInfo", 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 "g_function_info_get_symbol" g_function_info_get_symbol :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CString + +{- | +Obtain the symbol of the function. The symbol is the name of the +exported function, suitable to be used as an argument to +@/g_module_symbol()/@. +-} +functionInfoGetSymbol :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIFunctionInfo/@ -} + -> m T.Text + {- ^ __Returns:__ the symbol -} +functionInfoGetSymbol info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_function_info_get_symbol info' + checkUnexpectedReturnNULL "functionInfoGetSymbol" result + result' <- cstringToText result + touchManagedPtr info + return result' + + +-- function g_function_info_get_property +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIFunctionInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_function_info_get_property" g_function_info_get_property :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain the property associated with this @/GIFunctionInfo/@. +Only @/GIFunctionInfo/@ with the flag 'GI.GIRepository.Flags.FunctionInfoFlagsIsGetter' or +'GI.GIRepository.Flags.FunctionInfoFlagsIsSetter' have a property set. For other cases, +'Nothing' will be returned. +-} +functionInfoGetProperty :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIFunctionInfo/@ -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the property or 'Nothing' if not set. Free it with +@/g_base_info_unref()/@ when done. -} +functionInfoGetProperty info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_function_info_get_property info' + checkUnexpectedReturnNULL "functionInfoGetProperty" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_function_info_get_flags +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIFunctionInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "FunctionInfoFlags"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_function_info_get_flags" g_function_info_get_flags :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CUInt + +{- | +Obtain the 'GI.GIRepository.Flags.FunctionInfoFlags' for the /@info@/. +-} +functionInfoGetFlags :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIFunctionInfo/@ -} + -> m [GIRepository.Flags.FunctionInfoFlags] + {- ^ __Returns:__ the flags -} +functionInfoGetFlags info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_function_info_get_flags info' + let result' = wordToGFlags result + touchManagedPtr info + return result' + + +-- function g_field_info_get_type +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIFieldInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_field_info_get_type" g_field_info_get_type :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain the type of a field as a @/GITypeInfo/@. +-} +fieldInfoGetType :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIFieldInfo/@ -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GITypeInfo/@. Free the struct by calling +@/g_base_info_unref()/@ when done. -} +fieldInfoGetType info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_field_info_get_type info' + checkUnexpectedReturnNULL "fieldInfoGetType" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_field_info_get_size +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIFieldInfo", 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 "g_field_info_get_size" g_field_info_get_size :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the size in bits of the field member, this is how +much space you need to allocate to store the field. +-} +fieldInfoGetSize :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIFieldInfo/@ -} + -> m Int32 + {- ^ __Returns:__ the field size -} +fieldInfoGetSize info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_field_info_get_size info' + touchManagedPtr info + return result + + +-- function g_field_info_get_offset +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIFieldInfo", 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 "g_field_info_get_offset" g_field_info_get_offset :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the offset in bytes of the field member, this is relative +to the beginning of the struct or union. +-} +fieldInfoGetOffset :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIFieldInfo/@ -} + -> m Int32 + {- ^ __Returns:__ the field offset -} +fieldInfoGetOffset info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_field_info_get_offset info' + touchManagedPtr info + return result + + +-- function g_field_info_get_flags +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIFieldInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "FieldInfoFlags"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_field_info_get_flags" g_field_info_get_flags :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CUInt + +{- | +Obtain the flags for this @/GIFieldInfo/@. See 'GI.GIRepository.Flags.FieldInfoFlags' for possible +flag values. +-} +fieldInfoGetFlags :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIFieldInfo/@ -} + -> m [GIRepository.Flags.FieldInfoFlags] + {- ^ __Returns:__ the flags -} +fieldInfoGetFlags info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_field_info_get_flags info' + let result' = wordToGFlags result + touchManagedPtr info + return result' + + +-- function g_enum_info_get_value +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIEnumInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of value to fetch", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_enum_info_get_value" g_enum_info_get_value :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Int32 -> -- n : TBasicType TInt + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain a value for this enumeration. +-} +enumInfoGetValue :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIEnumInfo/@ -} + -> Int32 + {- ^ /@n@/: index of value to fetch -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the enumeration value or 'Nothing' if type tag is wrong, +free the struct with @/g_base_info_unref()/@ when done. -} +enumInfoGetValue info n = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_enum_info_get_value info' n + checkUnexpectedReturnNULL "enumInfoGetValue" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_enum_info_get_storage_type +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIEnumInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "TypeTag"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_enum_info_get_storage_type" g_enum_info_get_storage_type :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CUInt + +{- | +Obtain the tag of the type used for the enum in the C ABI. This will +will be a signed or unsigned integral type. + +Note that in the current implementation the width of the type is +computed correctly, but the signed or unsigned nature of the type +may not match the sign of the type used by the C compiler. +-} +enumInfoGetStorageType :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIEnumInfo/@ -} + -> m GIRepository.Enums.TypeTag + {- ^ __Returns:__ the storage type for the enumeration -} +enumInfoGetStorageType info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_enum_info_get_storage_type info' + let result' = (toEnum . fromIntegral) result + touchManagedPtr info + return result' + + +-- function g_enum_info_get_n_values +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIEnumInfo", 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 "g_enum_info_get_n_values" g_enum_info_get_n_values :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the number of values this enumeration contains. +-} +enumInfoGetNValues :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIEnumInfo/@ -} + -> m Int32 + {- ^ __Returns:__ the number of enumeration values -} +enumInfoGetNValues info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_enum_info_get_n_values info' + touchManagedPtr info + return result + + +-- function g_enum_info_get_n_methods +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIEnumInfo", 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 "g_enum_info_get_n_methods" g_enum_info_get_n_methods :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the number of methods that this enum type has. + +/Since: 1.30/ +-} +enumInfoGetNMethods :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIEnumInfo/@ -} + -> m Int32 + {- ^ __Returns:__ number of methods -} +enumInfoGetNMethods info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_enum_info_get_n_methods info' + touchManagedPtr info + return result + + +-- function g_enum_info_get_method +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIEnumInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "index of method to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_enum_info_get_method" g_enum_info_get_method :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Int32 -> -- n : TBasicType TInt + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain an enum type method at index /@n@/. + +/Since: 1.30/ +-} +enumInfoGetMethod :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIEnumInfo/@ -} + -> Int32 + {- ^ /@n@/: index of method to get -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIFunctionInfo/@. Free the struct by calling +@/g_base_info_unref()/@ when done. -} +enumInfoGetMethod info n = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_enum_info_get_method info' n + checkUnexpectedReturnNULL "enumInfoGetMethod" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_enum_info_get_error_domain +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIEnumInfo", 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 "g_enum_info_get_error_domain" g_enum_info_get_error_domain :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CString + +{- | +Obtain the string form of the quark for the error domain associated with +this enum, if any. + +/Since: 1.30/ +-} +enumInfoGetErrorDomain :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIEnumInfo/@ -} + -> m T.Text + {- ^ __Returns:__ the string form of the error domain associated +with this enum, or 'Nothing'. -} +enumInfoGetErrorDomain info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_enum_info_get_error_domain info' + checkUnexpectedReturnNULL "enumInfoGetErrorDomain" result + result' <- cstringToText result + touchManagedPtr info + return result' + + +-- function g_constant_info_get_type +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIConstantInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_constant_info_get_type" g_constant_info_get_type :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain the type of the constant as a @/GITypeInfo/@. +-} +constantInfoGetType :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIConstantInfo/@ -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GITypeInfo/@. Free the struct by calling +@/g_base_info_unref()/@ when done. -} +constantInfoGetType info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_constant_info_get_type info' + checkUnexpectedReturnNULL "constantInfoGetType" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function gi_cclosure_marshal_generic +-- Args : [Arg {argCName = "closure", argType = TGClosure Nothing, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "return_gvalue", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_param_values", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "param_values", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "invocation_hint", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "marshal_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, 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 "gi_cclosure_marshal_generic" gi_cclosure_marshal_generic :: + Ptr (GClosure ()) -> -- closure : TGClosure Nothing + Ptr GValue -> -- return_gvalue : TInterface (Name {namespace = "GObject", name = "Value"}) + Word32 -> -- n_param_values : TBasicType TUInt + Ptr GValue -> -- param_values : TInterface (Name {namespace = "GObject", name = "Value"}) + Ptr () -> -- invocation_hint : TBasicType TPtr + Ptr () -> -- marshal_data : TBasicType TPtr + IO () + +{- | +/No description available in the introspection data./ +-} +cclosureMarshalGeneric :: + (B.CallStack.HasCallStack, MonadIO m) => + GClosure a + -> GValue + -> Word32 + -> GValue + -> Ptr () + -> Ptr () + -> m () +cclosureMarshalGeneric closure returnGvalue nParamValues paramValues invocationHint marshalData = liftIO $ do + closure' <- unsafeManagedPtrCastPtr closure + returnGvalue' <- unsafeManagedPtrGetPtr returnGvalue + paramValues' <- unsafeManagedPtrGetPtr paramValues + gi_cclosure_marshal_generic closure' returnGvalue' nParamValues paramValues' invocationHint marshalData + touchManagedPtr closure + touchManagedPtr returnGvalue + touchManagedPtr paramValues + return () + + +-- function g_callable_info_skip_return +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", 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 "g_callable_info_skip_return" g_callable_info_skip_return :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CInt + +{- | +See if a callable\'s return value is only useful in C. +-} +callableInfoSkipReturn :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GICallableInfo/@ -} + -> m Bool + {- ^ __Returns:__ 'True' if return value is only useful in C. -} +callableInfoSkipReturn info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_callable_info_skip_return info' + let result' = (/= 0) result + touchManagedPtr info + return result' + + +-- function g_callable_info_may_return_null +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", 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 "g_callable_info_may_return_null" g_callable_info_may_return_null :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CInt + +{- | +See if a callable could return 'Nothing'. +-} +callableInfoMayReturnNull :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GICallableInfo/@ -} + -> m Bool + {- ^ __Returns:__ 'True' if callable could return 'Nothing' -} +callableInfoMayReturnNull info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_callable_info_may_return_null info' + let result' = (/= 0) result + touchManagedPtr info + return result' + + +-- function g_callable_info_load_return_type +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Initialized with return type of @info", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "g_callable_info_load_return_type" g_callable_info_load_return_type :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Ptr GIRepository.BaseInfo.BaseInfo -> -- type : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO () + +{- | +Obtain information about a return value of callable; this +function is a variant of 'GI.GIRepository.Functions.callableInfoGetReturnType' designed for stack +allocation. + +The initialized /@type@/ must not be referenced after /@info@/ is deallocated. +-} +callableInfoLoadReturnType :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GICallableInfo/@ -} + -> m (GIRepository.BaseInfo.BaseInfo) +callableInfoLoadReturnType info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + type_ <- callocBoxedBytes 72 :: IO (Ptr GIRepository.BaseInfo.BaseInfo) + g_callable_info_load_return_type info' type_ + type_' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) type_ + touchManagedPtr info + return type_' + + +-- function g_callable_info_load_arg +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the argument index to fetch", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "arg", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Initialize with argument number @n", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "g_callable_info_load_arg" g_callable_info_load_arg :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Int32 -> -- n : TBasicType TInt + Ptr GIRepository.BaseInfo.BaseInfo -> -- arg : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO () + +{- | +Obtain information about a particular argument of this callable; this +function is a variant of 'GI.GIRepository.Functions.callableInfoGetArg' designed for stack +allocation. + +The initialized /@arg@/ must not be referenced after /@info@/ is deallocated. +-} +callableInfoLoadArg :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GICallableInfo/@ -} + -> Int32 + {- ^ /@n@/: the argument index to fetch -} + -> m (GIRepository.BaseInfo.BaseInfo) +callableInfoLoadArg info n = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + arg <- callocBoxedBytes 72 :: IO (Ptr GIRepository.BaseInfo.BaseInfo) + g_callable_info_load_arg info' n arg + arg' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) arg + touchManagedPtr info + return arg' + + +-- function g_callable_info_iterate_return_attributes +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iterator", argType = TInterface (Name {namespace = "GIRepository", name = "AttributeIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIAttributeIter structure, must be initialized; see below", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Returned name, must not be freed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Returned name, must not be freed", 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 "g_callable_info_iterate_return_attributes" g_callable_info_iterate_return_attributes :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Ptr GIRepository.AttributeIter.AttributeIter -> -- iterator : TInterface (Name {namespace = "GIRepository", name = "AttributeIter"}) + Ptr CString -> -- name : TBasicType TUTF8 + Ptr CString -> -- value : TBasicType TUTF8 + IO CInt + +{- | +Iterate over all attributes associated with the return value. The +iterator structure is typically stack allocated, and must have its +first member initialized to 'Nothing'. + +Both the /@name@/ and /@value@/ should be treated as constants +and must not be freed. + +See 'GI.GIRepository.Structs.BaseInfo.baseInfoIterateAttributes' for an example of how to use a +similar API. +-} +callableInfoIterateReturnAttributes :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GICallableInfo/@ -} + -> GIRepository.AttributeIter.AttributeIter + {- ^ /@iterator@/: a 'GI.GIRepository.Structs.AttributeIter.AttributeIter' structure, must be initialized; see below -} + -> m ((Bool, T.Text, T.Text)) + {- ^ __Returns:__ 'True' if there are more attributes -} +callableInfoIterateReturnAttributes info iterator = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + iterator' <- unsafeManagedPtrGetPtr iterator + name <- allocMem :: IO (Ptr CString) + value <- allocMem :: IO (Ptr CString) + result <- g_callable_info_iterate_return_attributes info' iterator' name value + let result' = (/= 0) result + name' <- peek name + name'' <- cstringToText name' + value' <- peek value + value'' <- cstringToText value' + touchManagedPtr info + touchManagedPtr iterator + freeMem name + freeMem value + return (result', name'', value'') + + +-- function g_callable_info_is_method +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", 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 "g_callable_info_is_method" g_callable_info_is_method :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CInt + +{- | +Determines if the callable info is a method. For @/GIVFuncInfo/@\s, +@/GICallbackInfo/@\s, and @/GISignalInfo/@\s, +this is always true. Otherwise, this looks at the 'GI.GIRepository.Flags.FunctionInfoFlagsIsMethod' +flag on the @/GIFunctionInfo/@. + +Concretely, this function returns whether 'GI.GIRepository.Functions.callableInfoGetNArgs' +matches the number of arguments in the raw C method. For methods, there +is one more C argument than is exposed by introspection: the \"self\" +or \"this\" object. + +/Since: 1.34/ +-} +callableInfoIsMethod :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GICallableInfo/@ -} + -> m Bool + {- ^ __Returns:__ 'True' if /@info@/ is a method, 'False' otherwise -} +callableInfoIsMethod info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_callable_info_is_method info' + let result' = (/= 0) result + touchManagedPtr info + return result' + + +-- function g_callable_info_invoke +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "function", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "in_args", argType = TCArray False (-1) 3 (TInterface (Name {namespace = "GIRepository", name = "Argument"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_in_args", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_args", argType = TCArray False (-1) 5 (TInterface (Name {namespace = "GIRepository", name = "Argument"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_out_args", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "return_value", argType = TInterface (Name {namespace = "GIRepository", name = "Argument"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_method", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "throws", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "n_out_args", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_in_args", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "g_callable_info_invoke" g_callable_info_invoke :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Ptr () -> -- function : TBasicType TPtr + Ptr GIRepository.Argument.Argument -> -- in_args : TCArray False (-1) 3 (TInterface (Name {namespace = "GIRepository", name = "Argument"})) + Int32 -> -- n_in_args : TBasicType TInt + Ptr GIRepository.Argument.Argument -> -- out_args : TCArray False (-1) 5 (TInterface (Name {namespace = "GIRepository", name = "Argument"})) + Int32 -> -- n_out_args : TBasicType TInt + Ptr GIRepository.Argument.Argument -> -- return_value : TInterface (Name {namespace = "GIRepository", name = "Argument"}) + CInt -> -- is_method : TBasicType TBoolean + CInt -> -- throws : TBasicType TBoolean + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +TODO +-} +callableInfoInvoke :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: TODO -} + -> Ptr () + {- ^ /@function@/: TODO -} + -> [GIRepository.Argument.Argument] + {- ^ /@inArgs@/: TODO -} + -> [GIRepository.Argument.Argument] + {- ^ /@outArgs@/: TODO -} + -> GIRepository.Argument.Argument + {- ^ /@returnValue@/: TODO -} + -> Bool + {- ^ /@isMethod@/: TODO -} + -> Bool + {- ^ /@throws@/: TODO -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +callableInfoInvoke info function inArgs outArgs returnValue isMethod throws = liftIO $ do + let nOutArgs = fromIntegral $ length outArgs + let nInArgs = fromIntegral $ length inArgs + info' <- unsafeManagedPtrGetPtr info + inArgs' <- mapM unsafeManagedPtrGetPtr inArgs + inArgs'' <- packBlockArray 8 inArgs' + outArgs' <- mapM unsafeManagedPtrGetPtr outArgs + outArgs'' <- packBlockArray 8 outArgs' + returnValue' <- unsafeManagedPtrGetPtr returnValue + let isMethod' = (fromIntegral . fromEnum) isMethod + let throws' = (fromIntegral . fromEnum) throws + onException (do + _ <- propagateGError $ g_callable_info_invoke info' function inArgs'' nInArgs outArgs'' nOutArgs returnValue' isMethod' throws' + touchManagedPtr info + mapM_ touchManagedPtr inArgs + mapM_ touchManagedPtr outArgs + touchManagedPtr returnValue + freeMem inArgs'' + freeMem outArgs'' + return () + ) (do + freeMem inArgs'' + freeMem outArgs'' + ) + + +-- function g_callable_info_get_return_type +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_callable_info_get_return_type" g_callable_info_get_return_type :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain the return type of a callable item as a @/GITypeInfo/@. +-} +callableInfoGetReturnType :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GICallableInfo/@ -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GITypeInfo/@. Free the struct by calling +@/g_base_info_unref()/@ when done. -} +callableInfoGetReturnType info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_callable_info_get_return_type info' + checkUnexpectedReturnNULL "callableInfoGetReturnType" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_callable_info_get_return_attribute +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a freeform string naming an attribute", 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 "g_callable_info_get_return_attribute" g_callable_info_get_return_attribute :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + CString -> -- name : TBasicType TUTF8 + IO CString + +{- | +Retrieve an arbitrary attribute associated with the return value. +-} +callableInfoGetReturnAttribute :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GICallableInfo/@ -} + -> T.Text + {- ^ /@name@/: a freeform string naming an attribute -} + -> m T.Text + {- ^ __Returns:__ The value of the attribute, or 'Nothing' if no such attribute exists -} +callableInfoGetReturnAttribute info name = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + name' <- textToCString name + result <- g_callable_info_get_return_attribute info' name' + checkUnexpectedReturnNULL "callableInfoGetReturnAttribute" result + result' <- cstringToText result + touchManagedPtr info + freeMem name' + return result' + + +-- function g_callable_info_get_n_args +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", 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 "g_callable_info_get_n_args" g_callable_info_get_n_args :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the number of arguments (both IN and OUT) for this callable. +-} +callableInfoGetNArgs :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GICallableInfo/@ -} + -> m Int32 + {- ^ __Returns:__ The number of arguments this callable expects. -} +callableInfoGetNArgs info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_callable_info_get_n_args info' + touchManagedPtr info + return result + + +-- function g_callable_info_get_instance_ownership_transfer +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "Transfer"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_callable_info_get_instance_ownership_transfer" g_callable_info_get_instance_ownership_transfer :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CUInt + +{- | +Obtains the ownership transfer for the instance argument. +'GI.GIRepository.Enums.Transfer' contains a list of possible transfer values. + +/Since: 1.42/ +-} +callableInfoGetInstanceOwnershipTransfer :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GICallableInfo/@ -} + -> m GIRepository.Enums.Transfer + {- ^ __Returns:__ the transfer mode of the instance argument -} +callableInfoGetInstanceOwnershipTransfer info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_callable_info_get_instance_ownership_transfer info' + let result' = (toEnum . fromIntegral) result + touchManagedPtr info + return result' + + +-- function g_callable_info_get_caller_owns +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "Transfer"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_callable_info_get_caller_owns" g_callable_info_get_caller_owns :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CUInt + +{- | +See whether the caller owns the return value of this callable. +'GI.GIRepository.Enums.Transfer' contains a list of possible transfer values. +-} +callableInfoGetCallerOwns :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GICallableInfo/@ -} + -> m GIRepository.Enums.Transfer + {- ^ __Returns:__ the transfer mode for the return value of the callable -} +callableInfoGetCallerOwns info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_callable_info_get_caller_owns info' + let result' = (toEnum . fromIntegral) result + touchManagedPtr info + return result' + + +-- function g_callable_info_get_arg +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the argument index to fetch", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_callable_info_get_arg" g_callable_info_get_arg :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Int32 -> -- n : TBasicType TInt + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain information about a particular argument of this callable. +-} +callableInfoGetArg :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GICallableInfo/@ -} + -> Int32 + {- ^ /@n@/: the argument index to fetch -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GIArgInfo/@. Free it with +@/g_base_info_unref()/@ when done. -} +callableInfoGetArg info n = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_callable_info_get_arg info' n + checkUnexpectedReturnNULL "callableInfoGetArg" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_callable_info_can_throw_gerror +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GICallableInfo", 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 "g_callable_info_can_throw_gerror" g_callable_info_can_throw_gerror :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CInt + +{- | +TODO + +/Since: 1.34/ +-} +callableInfoCanThrowGerror :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GICallableInfo/@ -} + -> m Bool + {- ^ __Returns:__ 'True' if this @/GICallableInfo/@ can throw a 'GError' -} +callableInfoCanThrowGerror info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_callable_info_can_throw_gerror info' + let result' = (/= 0) result + touchManagedPtr info + return result' + + +-- function g_arg_info_may_be_null +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIArgInfo", 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 "g_arg_info_may_be_null" g_arg_info_may_be_null :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CInt + +{- | +Obtain if the type of the argument includes the possibility of 'Nothing'. +For \'in\' values this means that 'Nothing' is a valid value. For \'out\' +values, this means that 'Nothing' may be returned. + +See also 'GI.GIRepository.Functions.argInfoIsOptional'. +-} +argInfoMayBeNull :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIArgInfo/@ -} + -> m Bool + {- ^ __Returns:__ 'True' if the value may be 'Nothing' -} +argInfoMayBeNull info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_arg_info_may_be_null info' + let result' = (/= 0) result + touchManagedPtr info + return result' + + +-- function g_arg_info_load_type +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIArgInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Initialized with information about type of @info", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "g_arg_info_load_type" g_arg_info_load_type :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Ptr GIRepository.BaseInfo.BaseInfo -> -- type : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO () + +{- | +Obtain information about a the type of given argument /@info@/; this +function is a variant of 'GI.GIRepository.Functions.argInfoGetType' designed for stack +allocation. + +The initialized /@type@/ must not be referenced after /@info@/ is deallocated. +-} +argInfoLoadType :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIArgInfo/@ -} + -> m (GIRepository.BaseInfo.BaseInfo) +argInfoLoadType info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + type_ <- callocBoxedBytes 72 :: IO (Ptr GIRepository.BaseInfo.BaseInfo) + g_arg_info_load_type info' type_ + type_' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) type_ + touchManagedPtr info + return type_' + + +-- function g_arg_info_is_skip +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIArgInfo", 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 "g_arg_info_is_skip" g_arg_info_is_skip :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CInt + +{- | +Obtain if an argument is only useful in C. + +/Since: 1.30/ +-} +argInfoIsSkip :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIArgInfo/@ -} + -> m Bool + {- ^ __Returns:__ 'True' if argument is only useful in C. -} +argInfoIsSkip info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_arg_info_is_skip info' + let result' = (/= 0) result + touchManagedPtr info + return result' + + +-- function g_arg_info_is_return_value +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIArgInfo", 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 "g_arg_info_is_return_value" g_arg_info_is_return_value :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CInt + +{- | +Obtain if the argument is a return value. It can either be a +parameter or a return value. +-} +argInfoIsReturnValue :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIArgInfo/@ -} + -> m Bool + {- ^ __Returns:__ 'True' if it is a return value -} +argInfoIsReturnValue info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_arg_info_is_return_value info' + let result' = (/= 0) result + touchManagedPtr info + return result' + + +-- function g_arg_info_is_optional +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIArgInfo", 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 "g_arg_info_is_optional" g_arg_info_is_optional :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CInt + +{- | +Obtain if the argument is optional. For \'out\' arguments this means +that you can pass 'Nothing' in order to ignore the result. +-} +argInfoIsOptional :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIArgInfo/@ -} + -> m Bool + {- ^ __Returns:__ 'True' if it is an optional argument -} +argInfoIsOptional info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_arg_info_is_optional info' + let result' = (/= 0) result + touchManagedPtr info + return result' + + +-- function g_arg_info_is_caller_allocates +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIArgInfo", 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 "g_arg_info_is_caller_allocates" g_arg_info_is_caller_allocates :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CInt + +{- | +Obtain if the argument is a pointer to a struct or object that will +receive an output of a function. The default assumption for +'GI.GIRepository.Enums.DirectionOut' arguments which have allocation is that the +callee allocates; if this is 'True', then the caller must allocate. +-} +argInfoIsCallerAllocates :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIArgInfo/@ -} + -> m Bool + {- ^ __Returns:__ 'True' if caller is required to have allocated the argument -} +argInfoIsCallerAllocates info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_arg_info_is_caller_allocates info' + let result' = (/= 0) result + touchManagedPtr info + return result' + + +-- function g_arg_info_get_type +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIArgInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_arg_info_get_type" g_arg_info_get_type :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Obtain the type information for /@info@/. +-} +argInfoGetType :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIArgInfo/@ -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ the @/GITypeInfo/@ holding the type + information for /@info@/, free it with @/g_base_info_unref()/@ + when done. -} +argInfoGetType info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_arg_info_get_type info' + checkUnexpectedReturnNULL "argInfoGetType" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr info + return result' + + +-- function g_arg_info_get_scope +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIArgInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "ScopeType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_arg_info_get_scope" g_arg_info_get_scope :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CUInt + +{- | +Obtain the scope type for this argument. The scope type explains +how a callback is going to be invoked, most importantly when +the resources required to invoke it can be freed. +'GI.GIRepository.Enums.ScopeType' contains a list of possible values. +-} +argInfoGetScope :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIArgInfo/@ -} + -> m GIRepository.Enums.ScopeType + {- ^ __Returns:__ the scope type -} +argInfoGetScope info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_arg_info_get_scope info' + let result' = (toEnum . fromIntegral) result + touchManagedPtr info + return result' + + +-- function g_arg_info_get_ownership_transfer +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIArgInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "Transfer"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_arg_info_get_ownership_transfer" g_arg_info_get_ownership_transfer :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CUInt + +{- | +Obtain the ownership transfer for this argument. +'GI.GIRepository.Enums.Transfer' contains a list of possible values. +-} +argInfoGetOwnershipTransfer :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIArgInfo/@ -} + -> m GIRepository.Enums.Transfer + {- ^ __Returns:__ the transfer -} +argInfoGetOwnershipTransfer info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_arg_info_get_ownership_transfer info' + let result' = (toEnum . fromIntegral) result + touchManagedPtr info + return result' + + +-- function g_arg_info_get_direction +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIArgInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "Direction"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_arg_info_get_direction" g_arg_info_get_direction :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CUInt + +{- | +Obtain the direction of the argument. Check 'GI.GIRepository.Enums.Direction' for possible +direction values. +-} +argInfoGetDirection :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIArgInfo/@ -} + -> m GIRepository.Enums.Direction + {- ^ __Returns:__ the direction -} +argInfoGetDirection info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_arg_info_get_direction info' + let result' = (toEnum . fromIntegral) result + touchManagedPtr info + return result' + + +-- function g_arg_info_get_destroy +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIArgInfo", 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 "g_arg_info_get_destroy" g_arg_info_get_destroy :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtains the index of the 'GI.GLib.Callbacks.DestroyNotify' argument. This is only valid +for arguments which are callbacks. +-} +argInfoGetDestroy :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIArgInfo/@ -} + -> m Int32 + {- ^ __Returns:__ index of the 'GI.GLib.Callbacks.DestroyNotify' argument or -1 if there is none -} +argInfoGetDestroy info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_arg_info_get_destroy info' + touchManagedPtr info + return result + + +-- function g_arg_info_get_closure +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIArgInfo", 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 "g_arg_info_get_closure" g_arg_info_get_closure :: + Ptr GIRepository.BaseInfo.BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO Int32 + +{- | +Obtain the index of the user data argument. This is only valid +for arguments which are callbacks. +-} +argInfoGetClosure :: + (B.CallStack.HasCallStack, MonadIO m) => + GIRepository.BaseInfo.BaseInfo + {- ^ /@info@/: a @/GIArgInfo/@ -} + -> m Int32 + {- ^ __Returns:__ index of the user data argument or -1 if there is none -} +argInfoGetClosure info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_arg_info_get_closure info' + touchManagedPtr info + return result + + + diff --git a/GI/GIRepository/Objects.hs b/GI/GIRepository/Objects.hs new file mode 100644 --- /dev/null +++ b/GI/GIRepository/Objects.hs @@ -0,0 +1,41 @@ + + +{- | +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.GIRepository.Objects + ( module GI.GIRepository.Objects.Repository, + + + ) where + +import GI.GIRepository.Objects.Repository + +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/GIRepository/Objects/Repository.hs b/GI/GIRepository/Objects/Repository.hs new file mode 100644 --- /dev/null +++ b/GI/GIRepository/Objects/Repository.hs @@ -0,0 +1,1461 @@ + + +{- | +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.GIRepository.Objects.Repository.Repository' is used to manage repositories of namespaces. Namespaces +are represented on disk by type libraries (.typelib files). + +=== Discovery of type libraries + +'GI.GIRepository.Objects.Repository.Repository' will typically look for a @girepository-1.0@ directory +under the library directory used when compiling gobject-introspection. + +It is possible to control the search paths programmatically, using +'GI.GIRepository.Objects.Repository.repositoryPrependSearchPath'. It is also possible to modify +the search paths by using the @GI_TYPELIB_PATH@ environment variable. +The environment variable takes precedence over the default search path +and the 'GI.GIRepository.Objects.Repository.repositoryPrependSearchPath' calls. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GIRepository.Objects.Repository + ( + +-- * Exported types + Repository(..) , + IsRepository , + toRepository , + noRepository , + + + -- * Methods +-- ** dump #method:dump# + + repositoryDump , + + +-- ** enumerateVersions #method:enumerateVersions# + +#if ENABLE_OVERLOADING + RepositoryEnumerateVersionsMethodInfo , +#endif + repositoryEnumerateVersions , + + +-- ** errorQuark #method:errorQuark# + + repositoryErrorQuark , + + +-- ** findByErrorDomain #method:findByErrorDomain# + +#if ENABLE_OVERLOADING + RepositoryFindByErrorDomainMethodInfo , +#endif + repositoryFindByErrorDomain , + + +-- ** findByGtype #method:findByGtype# + +#if ENABLE_OVERLOADING + RepositoryFindByGtypeMethodInfo , +#endif + repositoryFindByGtype , + + +-- ** findByName #method:findByName# + +#if ENABLE_OVERLOADING + RepositoryFindByNameMethodInfo , +#endif + repositoryFindByName , + + +-- ** getCPrefix #method:getCPrefix# + +#if ENABLE_OVERLOADING + RepositoryGetCPrefixMethodInfo , +#endif + repositoryGetCPrefix , + + +-- ** getDefault #method:getDefault# + + repositoryGetDefault , + + +-- ** getDependencies #method:getDependencies# + +#if ENABLE_OVERLOADING + RepositoryGetDependenciesMethodInfo , +#endif + repositoryGetDependencies , + + +-- ** getImmediateDependencies #method:getImmediateDependencies# + +#if ENABLE_OVERLOADING + RepositoryGetImmediateDependenciesMethodInfo, +#endif + repositoryGetImmediateDependencies , + + +-- ** getInfo #method:getInfo# + +#if ENABLE_OVERLOADING + RepositoryGetInfoMethodInfo , +#endif + repositoryGetInfo , + + +-- ** getLoadedNamespaces #method:getLoadedNamespaces# + +#if ENABLE_OVERLOADING + RepositoryGetLoadedNamespacesMethodInfo , +#endif + repositoryGetLoadedNamespaces , + + +-- ** getNInfos #method:getNInfos# + +#if ENABLE_OVERLOADING + RepositoryGetNInfosMethodInfo , +#endif + repositoryGetNInfos , + + +-- ** getObjectGtypeInterfaces #method:getObjectGtypeInterfaces# + +#if ENABLE_OVERLOADING + RepositoryGetObjectGtypeInterfacesMethodInfo, +#endif + repositoryGetObjectGtypeInterfaces , + + +-- ** getOptionGroup #method:getOptionGroup# + + repositoryGetOptionGroup , + + +-- ** getSearchPath #method:getSearchPath# + + repositoryGetSearchPath , + + +-- ** getSharedLibrary #method:getSharedLibrary# + +#if ENABLE_OVERLOADING + RepositoryGetSharedLibraryMethodInfo , +#endif + repositoryGetSharedLibrary , + + +-- ** getTypelibPath #method:getTypelibPath# + +#if ENABLE_OVERLOADING + RepositoryGetTypelibPathMethodInfo , +#endif + repositoryGetTypelibPath , + + +-- ** getVersion #method:getVersion# + +#if ENABLE_OVERLOADING + RepositoryGetVersionMethodInfo , +#endif + repositoryGetVersion , + + +-- ** isRegistered #method:isRegistered# + +#if ENABLE_OVERLOADING + RepositoryIsRegisteredMethodInfo , +#endif + repositoryIsRegistered , + + +-- ** loadTypelib #method:loadTypelib# + +#if ENABLE_OVERLOADING + RepositoryLoadTypelibMethodInfo , +#endif + repositoryLoadTypelib , + + +-- ** prependLibraryPath #method:prependLibraryPath# + + repositoryPrependLibraryPath , + + +-- ** prependSearchPath #method:prependSearchPath# + + repositoryPrependSearchPath , + + +-- ** require #method:require# + +#if ENABLE_OVERLOADING + RepositoryRequireMethodInfo , +#endif + repositoryRequire , + + +-- ** requirePrivate #method:requirePrivate# + +#if ENABLE_OVERLOADING + RepositoryRequirePrivateMethodInfo , +#endif + repositoryRequirePrivate , + + + + + ) 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 {-# SOURCE #-} qualified GI.GIRepository.Flags as GIRepository.Flags +import {-# SOURCE #-} qualified GI.GIRepository.Structs.BaseInfo as GIRepository.BaseInfo +import {-# SOURCE #-} qualified GI.GIRepository.Structs.Typelib as GIRepository.Typelib +import qualified GI.GLib.Structs.OptionGroup as GLib.OptionGroup +import qualified GI.GObject.Objects.Object as GObject.Object + +-- | Memory-managed wrapper type. +newtype Repository = Repository (ManagedPtr Repository) +foreign import ccall "g_irepository_get_type" + c_g_irepository_get_type :: IO GType + +instance GObject Repository where + gobjectType = c_g_irepository_get_type + + +-- | Type class for types which can be safely cast to `Repository`, for instance with `toRepository`. +class (GObject o, O.IsDescendantOf Repository o) => IsRepository o +instance (GObject o, O.IsDescendantOf Repository o) => IsRepository o + +instance O.HasParentTypes Repository +type instance O.ParentTypes Repository = '[GObject.Object.Object] + +-- | Cast to `Repository`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toRepository :: (MonadIO m, IsRepository o) => o -> m Repository +toRepository = liftIO . unsafeCastTo Repository + +-- | A convenience alias for `Nothing` :: `Maybe` `Repository`. +noRepository :: Maybe Repository +noRepository = Nothing + +#if ENABLE_OVERLOADING +type family ResolveRepositoryMethod (t :: Symbol) (o :: *) :: * where + ResolveRepositoryMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveRepositoryMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveRepositoryMethod "enumerateVersions" o = RepositoryEnumerateVersionsMethodInfo + ResolveRepositoryMethod "findByErrorDomain" o = RepositoryFindByErrorDomainMethodInfo + ResolveRepositoryMethod "findByGtype" o = RepositoryFindByGtypeMethodInfo + ResolveRepositoryMethod "findByName" o = RepositoryFindByNameMethodInfo + ResolveRepositoryMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveRepositoryMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveRepositoryMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveRepositoryMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveRepositoryMethod "isRegistered" o = RepositoryIsRegisteredMethodInfo + ResolveRepositoryMethod "loadTypelib" o = RepositoryLoadTypelibMethodInfo + ResolveRepositoryMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveRepositoryMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveRepositoryMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveRepositoryMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveRepositoryMethod "require" o = RepositoryRequireMethodInfo + ResolveRepositoryMethod "requirePrivate" o = RepositoryRequirePrivateMethodInfo + ResolveRepositoryMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveRepositoryMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveRepositoryMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveRepositoryMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveRepositoryMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveRepositoryMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveRepositoryMethod "getCPrefix" o = RepositoryGetCPrefixMethodInfo + ResolveRepositoryMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveRepositoryMethod "getDependencies" o = RepositoryGetDependenciesMethodInfo + ResolveRepositoryMethod "getImmediateDependencies" o = RepositoryGetImmediateDependenciesMethodInfo + ResolveRepositoryMethod "getInfo" o = RepositoryGetInfoMethodInfo + ResolveRepositoryMethod "getLoadedNamespaces" o = RepositoryGetLoadedNamespacesMethodInfo + ResolveRepositoryMethod "getNInfos" o = RepositoryGetNInfosMethodInfo + ResolveRepositoryMethod "getObjectGtypeInterfaces" o = RepositoryGetObjectGtypeInterfacesMethodInfo + ResolveRepositoryMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveRepositoryMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveRepositoryMethod "getSharedLibrary" o = RepositoryGetSharedLibraryMethodInfo + ResolveRepositoryMethod "getTypelibPath" o = RepositoryGetTypelibPathMethodInfo + ResolveRepositoryMethod "getVersion" o = RepositoryGetVersionMethodInfo + ResolveRepositoryMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveRepositoryMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveRepositoryMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRepositoryMethod t Repository, O.MethodInfo info Repository p) => OL.IsLabel t (Repository -> 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 Repository +type instance O.AttributeList Repository = RepositoryAttributeList +type RepositoryAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Repository = RepositorySignalList +type RepositorySignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Repository::enumerate_versions +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "GI namespace, e.g. \"Gtk\"", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGList (TBasicType TUTF8)) +-- throws : False +-- Skip return : False + +foreign import ccall "g_irepository_enumerate_versions" g_irepository_enumerate_versions :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"}) + CString -> -- namespace_ : TBasicType TUTF8 + IO (Ptr (GList CString)) + +{- | +Obtain an unordered list of versions (either currently loaded or +available) for /@namespace_@/ in this /@repository@/. +-} +repositoryEnumerateVersions :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton + process-global default 'GI.GIRepository.Objects.Repository.Repository' -} + -> T.Text + {- ^ /@namespace_@/: GI namespace, e.g. \"Gtk\" -} + -> m [T.Text] + {- ^ __Returns:__ the array of versions. -} +repositoryEnumerateVersions repository namespace_ = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + namespace_' <- textToCString namespace_ + result <- g_irepository_enumerate_versions repository' namespace_' + result' <- unpackGList result + result'' <- mapM cstringToText result' + mapGList freeMem result + g_list_free result + touchManagedPtr repository + freeMem namespace_' + return result'' + +#if ENABLE_OVERLOADING +data RepositoryEnumerateVersionsMethodInfo +instance (signature ~ (T.Text -> m [T.Text]), MonadIO m, IsRepository a) => O.MethodInfo RepositoryEnumerateVersionsMethodInfo a signature where + overloadedMethod _ = repositoryEnumerateVersions + +#endif + +-- method Repository::find_by_error_domain +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "domain", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GError domain", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_irepository_find_by_error_domain" g_irepository_find_by_error_domain :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"}) + Word32 -> -- domain : TBasicType TUInt32 + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Searches for the enum type corresponding to the given 'GError' +domain. Before calling this function for a particular namespace, +you must call 'GI.GIRepository.Objects.Repository.repositoryRequire' once to load the namespace, or +otherwise ensure the namespace has already been loaded. + +/Since: 1.30/ +-} +repositoryFindByErrorDomain :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton + process-global default 'GI.GIRepository.Objects.Repository.Repository' -} + -> Word32 + {- ^ /@domain@/: a 'GError' domain -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ @/GIEnumInfo/@ representing metadata about /@domain@/\'s +enum type, or 'Nothing' -} +repositoryFindByErrorDomain repository domain = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + result <- g_irepository_find_by_error_domain repository' domain + checkUnexpectedReturnNULL "repositoryFindByErrorDomain" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr repository + return result' + +#if ENABLE_OVERLOADING +data RepositoryFindByErrorDomainMethodInfo +instance (signature ~ (Word32 -> m GIRepository.BaseInfo.BaseInfo), MonadIO m, IsRepository a) => O.MethodInfo RepositoryFindByErrorDomainMethodInfo a signature where + overloadedMethod _ = repositoryFindByErrorDomain + +#endif + +-- method Repository::find_by_gtype +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gtype", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "GType to search for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_irepository_find_by_gtype" g_irepository_find_by_gtype :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"}) + CGType -> -- gtype : TBasicType TGType + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Searches all loaded namespaces for a particular 'GType'. Note that +in order to locate the metadata, the namespace corresponding to +the type must first have been loaded. There is currently no +mechanism for determining the namespace which corresponds to an +arbitrary GType - thus, this function will operate most reliably +when you know the GType to originate from be from a loaded namespace. +-} +repositoryFindByGtype :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton + process-global default 'GI.GIRepository.Objects.Repository.Repository' -} + -> GType + {- ^ /@gtype@/: GType to search for -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ 'GI.GIRepository.Structs.BaseInfo.BaseInfo' representing metadata about /@type@/, or 'Nothing' -} +repositoryFindByGtype repository gtype = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + let gtype' = gtypeToCGType gtype + result <- g_irepository_find_by_gtype repository' gtype' + checkUnexpectedReturnNULL "repositoryFindByGtype" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr repository + return result' + +#if ENABLE_OVERLOADING +data RepositoryFindByGtypeMethodInfo +instance (signature ~ (GType -> m GIRepository.BaseInfo.BaseInfo), MonadIO m, IsRepository a) => O.MethodInfo RepositoryFindByGtypeMethodInfo a signature where + overloadedMethod _ = repositoryFindByGtype + +#endif + +-- method Repository::find_by_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Namespace which will be searched", 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 "Entry name to find", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_irepository_find_by_name" g_irepository_find_by_name :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"}) + CString -> -- namespace_ : TBasicType TUTF8 + CString -> -- name : TBasicType TUTF8 + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +Searches for a particular entry in a namespace. Before calling +this function for a particular namespace, you must call +'GI.GIRepository.Objects.Repository.repositoryRequire' once to load the namespace, or otherwise +ensure the namespace has already been loaded. +-} +repositoryFindByName :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton + process-global default 'GI.GIRepository.Objects.Repository.Repository' -} + -> T.Text + {- ^ /@namespace_@/: Namespace which will be searched -} + -> T.Text + {- ^ /@name@/: Entry name to find -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ 'GI.GIRepository.Structs.BaseInfo.BaseInfo' representing metadata about /@name@/, or 'Nothing' -} +repositoryFindByName repository namespace_ name = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + namespace_' <- textToCString namespace_ + name' <- textToCString name + result <- g_irepository_find_by_name repository' namespace_' name' + checkUnexpectedReturnNULL "repositoryFindByName" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr repository + freeMem namespace_' + freeMem name' + return result' + +#if ENABLE_OVERLOADING +data RepositoryFindByNameMethodInfo +instance (signature ~ (T.Text -> T.Text -> m GIRepository.BaseInfo.BaseInfo), MonadIO m, IsRepository a) => O.MethodInfo RepositoryFindByNameMethodInfo a signature where + overloadedMethod _ = repositoryFindByName + +#endif + +-- method Repository::get_c_prefix +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Namespace to inspect", 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 "g_irepository_get_c_prefix" g_irepository_get_c_prefix :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"}) + CString -> -- namespace_ : TBasicType TUTF8 + IO CString + +{- | +This function returns the \"C prefix\", or the C level namespace +associated with the given introspection namespace. Each C symbol +starts with this prefix, as well each 'GType' in the library. + +Note: The namespace must have already been loaded using a function +such as 'GI.GIRepository.Objects.Repository.repositoryRequire' before calling this function. +-} +repositoryGetCPrefix :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton + process-global default 'GI.GIRepository.Objects.Repository.Repository' -} + -> T.Text + {- ^ /@namespace_@/: Namespace to inspect -} + -> m T.Text + {- ^ __Returns:__ C namespace prefix, or 'Nothing' if none associated -} +repositoryGetCPrefix repository namespace_ = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + namespace_' <- textToCString namespace_ + result <- g_irepository_get_c_prefix repository' namespace_' + checkUnexpectedReturnNULL "repositoryGetCPrefix" result + result' <- cstringToText result + touchManagedPtr repository + freeMem namespace_' + return result' + +#if ENABLE_OVERLOADING +data RepositoryGetCPrefixMethodInfo +instance (signature ~ (T.Text -> m T.Text), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetCPrefixMethodInfo a signature where + overloadedMethod _ = repositoryGetCPrefix + +#endif + +-- method Repository::get_dependencies +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Namespace of interest", 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 "g_irepository_get_dependencies" g_irepository_get_dependencies :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"}) + CString -> -- namespace_ : TBasicType TUTF8 + IO (Ptr CString) + +{- | +Return an array of all (transitive) versioned dependencies for +/@namespace_@/. Returned strings are of the form +\namespace-version\<\/code>. + +Note: /@namespace_@/ must have already been loaded using a function +such as 'GI.GIRepository.Objects.Repository.repositoryRequire' before calling this function. + +To get only the immediate dependencies for /@namespace_@/, use +'GI.GIRepository.Objects.Repository.repositoryGetImmediateDependencies'. +-} +repositoryGetDependencies :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton + process-global default 'GI.GIRepository.Objects.Repository.Repository' -} + -> T.Text + {- ^ /@namespace_@/: Namespace of interest -} + -> m [T.Text] + {- ^ __Returns:__ Zero-terminated string array of all versioned + dependencies -} +repositoryGetDependencies repository namespace_ = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + namespace_' <- textToCString namespace_ + result <- g_irepository_get_dependencies repository' namespace_' + checkUnexpectedReturnNULL "repositoryGetDependencies" result + result' <- unpackZeroTerminatedUTF8CArray result + mapZeroTerminatedCArray freeMem result + freeMem result + touchManagedPtr repository + freeMem namespace_' + return result' + +#if ENABLE_OVERLOADING +data RepositoryGetDependenciesMethodInfo +instance (signature ~ (T.Text -> m [T.Text]), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetDependenciesMethodInfo a signature where + overloadedMethod _ = repositoryGetDependencies + +#endif + +-- method Repository::get_immediate_dependencies +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Namespace of interest", 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 "g_irepository_get_immediate_dependencies" g_irepository_get_immediate_dependencies :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"}) + CString -> -- namespace_ : TBasicType TUTF8 + IO (Ptr CString) + +{- | +Return an array of the immediate versioned dependencies for /@namespace_@/. +Returned strings are of the form \namespace-version\<\/code>. + +Note: /@namespace_@/ must have already been loaded using a function +such as 'GI.GIRepository.Objects.Repository.repositoryRequire' before calling this function. + +To get the transitive closure of dependencies for /@namespace_@/, use +'GI.GIRepository.Objects.Repository.repositoryGetDependencies'. + +/Since: 1.44/ +-} +repositoryGetImmediateDependencies :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton + process-global default 'GI.GIRepository.Objects.Repository.Repository' -} + -> T.Text + {- ^ /@namespace_@/: Namespace of interest -} + -> m [T.Text] + {- ^ __Returns:__ Zero-terminated string array of immediate versioned + dependencies -} +repositoryGetImmediateDependencies repository namespace_ = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + namespace_' <- textToCString namespace_ + result <- g_irepository_get_immediate_dependencies repository' namespace_' + checkUnexpectedReturnNULL "repositoryGetImmediateDependencies" result + result' <- unpackZeroTerminatedUTF8CArray result + mapZeroTerminatedCArray freeMem result + freeMem result + touchManagedPtr repository + freeMem namespace_' + return result' + +#if ENABLE_OVERLOADING +data RepositoryGetImmediateDependenciesMethodInfo +instance (signature ~ (T.Text -> m [T.Text]), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetImmediateDependenciesMethodInfo a signature where + overloadedMethod _ = repositoryGetImmediateDependencies + +#endif + +-- method Repository::get_info +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Namespace to inspect", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "0-based offset into namespace metadata for entry", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_irepository_get_info" g_irepository_get_info :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"}) + CString -> -- namespace_ : TBasicType TUTF8 + Int32 -> -- index : TBasicType TInt + IO (Ptr GIRepository.BaseInfo.BaseInfo) + +{- | +This function returns a particular metadata entry in the +given namespace /@namespace_@/. The namespace must have +already been loaded before calling this function. +See 'GI.GIRepository.Objects.Repository.repositoryGetNInfos' to find the maximum number of +entries. +-} +repositoryGetInfo :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton + process-global default 'GI.GIRepository.Objects.Repository.Repository' -} + -> T.Text + {- ^ /@namespace_@/: Namespace to inspect -} + -> Int32 + {- ^ /@index@/: 0-based offset into namespace metadata for entry -} + -> m GIRepository.BaseInfo.BaseInfo + {- ^ __Returns:__ 'GI.GIRepository.Structs.BaseInfo.BaseInfo' containing metadata -} +repositoryGetInfo repository namespace_ index = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + namespace_' <- textToCString namespace_ + result <- g_irepository_get_info repository' namespace_' index + checkUnexpectedReturnNULL "repositoryGetInfo" result + result' <- (wrapBoxed GIRepository.BaseInfo.BaseInfo) result + touchManagedPtr repository + freeMem namespace_' + return result' + +#if ENABLE_OVERLOADING +data RepositoryGetInfoMethodInfo +instance (signature ~ (T.Text -> Int32 -> m GIRepository.BaseInfo.BaseInfo), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetInfoMethodInfo a signature where + overloadedMethod _ = repositoryGetInfo + +#endif + +-- method Repository::get_loaded_namespaces +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n process-global default #GIRepository", 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 "g_irepository_get_loaded_namespaces" g_irepository_get_loaded_namespaces :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"}) + IO (Ptr CString) + +{- | +Return the list of currently loaded namespaces. +-} +repositoryGetLoadedNamespaces :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton + process-global default 'GI.GIRepository.Objects.Repository.Repository' -} + -> m [T.Text] + {- ^ __Returns:__ List of namespaces -} +repositoryGetLoadedNamespaces repository = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + result <- g_irepository_get_loaded_namespaces repository' + checkUnexpectedReturnNULL "repositoryGetLoadedNamespaces" result + result' <- unpackZeroTerminatedUTF8CArray result + mapZeroTerminatedCArray freeMem result + freeMem result + touchManagedPtr repository + return result' + +#if ENABLE_OVERLOADING +data RepositoryGetLoadedNamespacesMethodInfo +instance (signature ~ (m [T.Text]), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetLoadedNamespacesMethodInfo a signature where + overloadedMethod _ = repositoryGetLoadedNamespaces + +#endif + +-- method Repository::get_n_infos +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Namespace to inspect", 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 "g_irepository_get_n_infos" g_irepository_get_n_infos :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"}) + CString -> -- namespace_ : TBasicType TUTF8 + IO Int32 + +{- | +This function returns the number of metadata entries in +given namespace /@namespace_@/. The namespace must have +already been loaded before calling this function. +-} +repositoryGetNInfos :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton + process-global default 'GI.GIRepository.Objects.Repository.Repository' -} + -> T.Text + {- ^ /@namespace_@/: Namespace to inspect -} + -> m Int32 + {- ^ __Returns:__ number of metadata entries -} +repositoryGetNInfos repository namespace_ = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + namespace_' <- textToCString namespace_ + result <- g_irepository_get_n_infos repository' namespace_' + touchManagedPtr repository + freeMem namespace_' + return result + +#if ENABLE_OVERLOADING +data RepositoryGetNInfosMethodInfo +instance (signature ~ (T.Text -> m Int32), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetNInfosMethodInfo a signature where + overloadedMethod _ = repositoryGetNInfos + +#endif + +-- method Repository::get_object_gtype_interfaces +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIRepository, or %NULL for the default repository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gtype", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GType whose fundamental type is G_TYPE_OBJECT", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_interfaces_out", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Number of interfaces", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "interfaces_out", argType = TCArray False (-1) 2 (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Interfaces for @gtype", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "n_interfaces_out", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Number of interfaces", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "g_irepository_get_object_gtype_interfaces" g_irepository_get_object_gtype_interfaces :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"}) + CGType -> -- gtype : TBasicType TGType + Ptr Word32 -> -- n_interfaces_out : TBasicType TUInt + Ptr (Ptr GIRepository.BaseInfo.BaseInfo) -> -- interfaces_out : TCArray False (-1) 2 (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) + IO () + +{- | +Look up the implemented interfaces for /@gtype@/. This function +cannot fail per se; but for a totally \"unknown\" 'GType', it may +return 0 implemented interfaces. + +The semantics of this function are designed for a dynamic binding, +where in certain cases (such as a function which returns an +interface which may have \"hidden\" implementation classes), not all +data may be statically known, and will have to be determined from +the 'GType' of the object. An example is @/g_file_new_for_path()/@ +returning a concrete class of @/GLocalFile/@, which is a 'GType' we +see at runtime, but not statically. + +/Since: 1.60/ +-} +repositoryGetObjectGtypeInterfaces :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: a 'GI.GIRepository.Objects.Repository.Repository', or 'Nothing' for the default repository -} + -> GType + {- ^ /@gtype@/: a 'GType' whose fundamental type is G_TYPE_OBJECT -} + -> m ([GIRepository.BaseInfo.BaseInfo]) +repositoryGetObjectGtypeInterfaces repository gtype = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + let gtype' = gtypeToCGType gtype + nInterfacesOut <- allocMem :: IO (Ptr Word32) + interfacesOut <- allocMem :: IO (Ptr (Ptr GIRepository.BaseInfo.BaseInfo)) + g_irepository_get_object_gtype_interfaces repository' gtype' nInterfacesOut interfacesOut + nInterfacesOut' <- peek nInterfacesOut + interfacesOut' <- peek interfacesOut + interfacesOut'' <- (unpackBoxedArrayWithLength 72 nInterfacesOut') interfacesOut' + interfacesOut''' <- mapM (newBoxed GIRepository.BaseInfo.BaseInfo) interfacesOut'' + touchManagedPtr repository + freeMem nInterfacesOut + freeMem interfacesOut + return interfacesOut''' + +#if ENABLE_OVERLOADING +data RepositoryGetObjectGtypeInterfacesMethodInfo +instance (signature ~ (GType -> m ([GIRepository.BaseInfo.BaseInfo])), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetObjectGtypeInterfacesMethodInfo a signature where + overloadedMethod _ = repositoryGetObjectGtypeInterfaces + +#endif + +-- method Repository::get_shared_library +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Namespace to inspect", 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 "g_irepository_get_shared_library" g_irepository_get_shared_library :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"}) + CString -> -- namespace_ : TBasicType TUTF8 + IO CString + +{- | +This function returns a comma-separated list of paths to the +shared C libraries associated with the given namespace /@namespace_@/. +There may be no shared library path associated, in which case this +function will return 'Nothing'. + +Note: The namespace must have already been loaded using a function +such as 'GI.GIRepository.Objects.Repository.repositoryRequire' before calling this function. +-} +repositoryGetSharedLibrary :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton + process-global default 'GI.GIRepository.Objects.Repository.Repository' -} + -> T.Text + {- ^ /@namespace_@/: Namespace to inspect -} + -> m T.Text + {- ^ __Returns:__ Comma-separated list of paths to shared libraries, + or 'Nothing' if none are associated -} +repositoryGetSharedLibrary repository namespace_ = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + namespace_' <- textToCString namespace_ + result <- g_irepository_get_shared_library repository' namespace_' + checkUnexpectedReturnNULL "repositoryGetSharedLibrary" result + result' <- cstringToText result + touchManagedPtr repository + freeMem namespace_' + return result' + +#if ENABLE_OVERLOADING +data RepositoryGetSharedLibraryMethodInfo +instance (signature ~ (T.Text -> m T.Text), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetSharedLibraryMethodInfo a signature where + overloadedMethod _ = repositoryGetSharedLibrary + +#endif + +-- method Repository::get_typelib_path +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "GI namespace to use, e.g. \"Gtk\"", 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 "g_irepository_get_typelib_path" g_irepository_get_typelib_path :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"}) + CString -> -- namespace_ : TBasicType TUTF8 + IO CString + +{- | +If namespace /@namespace_@/ is loaded, return the full path to the +.typelib file it was loaded from. If the typelib for +namespace /@namespace_@/ was included in a shared library, return +the special string \"<builtin>\". +-} +repositoryGetTypelibPath :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton + process-global default 'GI.GIRepository.Objects.Repository.Repository' -} + -> T.Text + {- ^ /@namespace_@/: GI namespace to use, e.g. \"Gtk\" -} + -> m T.Text + {- ^ __Returns:__ Filesystem path (or $lt;builtin$gt;) if successful, 'Nothing' if namespace is not loaded -} +repositoryGetTypelibPath repository namespace_ = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + namespace_' <- textToCString namespace_ + result <- g_irepository_get_typelib_path repository' namespace_' + checkUnexpectedReturnNULL "repositoryGetTypelibPath" result + result' <- cstringToText result + touchManagedPtr repository + freeMem namespace_' + return result' + +#if ENABLE_OVERLOADING +data RepositoryGetTypelibPathMethodInfo +instance (signature ~ (T.Text -> m T.Text), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetTypelibPathMethodInfo a signature where + overloadedMethod _ = repositoryGetTypelibPath + +#endif + +-- method Repository::get_version +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Namespace to inspect", 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 "g_irepository_get_version" g_irepository_get_version :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"}) + CString -> -- namespace_ : TBasicType TUTF8 + IO CString + +{- | +This function returns the loaded version associated with the given +namespace /@namespace_@/. + +Note: The namespace must have already been loaded using a function +such as 'GI.GIRepository.Objects.Repository.repositoryRequire' before calling this function. +-} +repositoryGetVersion :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton + process-global default 'GI.GIRepository.Objects.Repository.Repository' -} + -> T.Text + {- ^ /@namespace_@/: Namespace to inspect -} + -> m T.Text + {- ^ __Returns:__ Loaded version -} +repositoryGetVersion repository namespace_ = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + namespace_' <- textToCString namespace_ + result <- g_irepository_get_version repository' namespace_' + checkUnexpectedReturnNULL "repositoryGetVersion" result + result' <- cstringToText result + touchManagedPtr repository + freeMem namespace_' + return result' + +#if ENABLE_OVERLOADING +data RepositoryGetVersionMethodInfo +instance (signature ~ (T.Text -> m T.Text), MonadIO m, IsRepository a) => O.MethodInfo RepositoryGetVersionMethodInfo a signature where + overloadedMethod _ = repositoryGetVersion + +#endif + +-- method Repository::is_registered +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Namespace of interest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "version", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Required version, may be %NULL for latest", 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 "g_irepository_is_registered" g_irepository_is_registered :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"}) + CString -> -- namespace_ : TBasicType TUTF8 + CString -> -- version : TBasicType TUTF8 + IO CInt + +{- | +Check whether a particular namespace (and optionally, a specific +version thereof) is currently loaded. This function is likely to +only be useful in unusual circumstances; in order to act upon +metadata in the namespace, you should call 'GI.GIRepository.Objects.Repository.repositoryRequire' +instead which will ensure the namespace is loaded, and return as +quickly as this function will if it has already been loaded. +-} +repositoryIsRegistered :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton + process-global default 'GI.GIRepository.Objects.Repository.Repository' -} + -> T.Text + {- ^ /@namespace_@/: Namespace of interest -} + -> Maybe (T.Text) + {- ^ /@version@/: Required version, may be 'Nothing' for latest -} + -> m Bool + {- ^ __Returns:__ 'True' if namespace-version is loaded, 'False' otherwise -} +repositoryIsRegistered repository namespace_ version = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + namespace_' <- textToCString namespace_ + maybeVersion <- case version of + Nothing -> return nullPtr + Just jVersion -> do + jVersion' <- textToCString jVersion + return jVersion' + result <- g_irepository_is_registered repository' namespace_' maybeVersion + let result' = (/= 0) result + touchManagedPtr repository + freeMem namespace_' + freeMem maybeVersion + return result' + +#if ENABLE_OVERLOADING +data RepositoryIsRegisteredMethodInfo +instance (signature ~ (T.Text -> Maybe (T.Text) -> m Bool), MonadIO m, IsRepository a) => O.MethodInfo RepositoryIsRegisteredMethodInfo a signature where + overloadedMethod _ = repositoryIsRegistered + +#endif + +-- method Repository::load_typelib +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "typelib", argType = TInterface (Name {namespace = "GIRepository", name = "Typelib"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GIRepository", name = "RepositoryLoadFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "TODO", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : True +-- Skip return : False + +foreign import ccall "g_irepository_load_typelib" g_irepository_load_typelib :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"}) + Ptr GIRepository.Typelib.Typelib -> -- typelib : TInterface (Name {namespace = "GIRepository", name = "Typelib"}) + CUInt -> -- flags : TInterface (Name {namespace = "GIRepository", name = "RepositoryLoadFlags"}) + Ptr (Ptr GError) -> -- error + IO CString + +{- | +TODO +-} +repositoryLoadTypelib :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton + process-global default 'GI.GIRepository.Objects.Repository.Repository' -} + -> GIRepository.Typelib.Typelib + {- ^ /@typelib@/: TODO -} + -> [GIRepository.Flags.RepositoryLoadFlags] + {- ^ /@flags@/: TODO -} + -> m T.Text + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryLoadTypelib repository typelib flags = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + typelib' <- unsafeManagedPtrGetPtr typelib + let flags' = gflagsToWord flags + onException (do + result <- propagateGError $ g_irepository_load_typelib repository' typelib' flags' + checkUnexpectedReturnNULL "repositoryLoadTypelib" result + result' <- cstringToText result + touchManagedPtr repository + touchManagedPtr typelib + return result' + ) (do + return () + ) + +#if ENABLE_OVERLOADING +data RepositoryLoadTypelibMethodInfo +instance (signature ~ (GIRepository.Typelib.Typelib -> [GIRepository.Flags.RepositoryLoadFlags] -> m T.Text), MonadIO m, IsRepository a) => O.MethodInfo RepositoryLoadTypelibMethodInfo a signature where + overloadedMethod _ = repositoryLoadTypelib + +#endif + +-- method Repository::require +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "GI namespace to use, e.g. \"Gtk\"", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "version", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Version of namespace, may be %NULL for latest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GIRepository", name = "RepositoryLoadFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Set of %GIRepositoryLoadFlags, may be 0", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "Typelib"})) +-- throws : True +-- Skip return : False + +foreign import ccall "g_irepository_require" g_irepository_require :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"}) + CString -> -- namespace_ : TBasicType TUTF8 + CString -> -- version : TBasicType TUTF8 + CUInt -> -- flags : TInterface (Name {namespace = "GIRepository", name = "RepositoryLoadFlags"}) + Ptr (Ptr GError) -> -- error + IO (Ptr GIRepository.Typelib.Typelib) + +{- | +Force the namespace /@namespace_@/ to be loaded if it isn\'t already. +If /@namespace_@/ is not loaded, this function will search for a +\".typelib\" file using the repository search path. In addition, a +version /@version@/ of namespace may be specified. If /@version@/ is +not specified, the latest will be used. +-} +repositoryRequire :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton + process-global default 'GI.GIRepository.Objects.Repository.Repository' -} + -> T.Text + {- ^ /@namespace_@/: GI namespace to use, e.g. \"Gtk\" -} + -> Maybe (T.Text) + {- ^ /@version@/: Version of namespace, may be 'Nothing' for latest -} + -> [GIRepository.Flags.RepositoryLoadFlags] + {- ^ /@flags@/: Set of @/GIRepositoryLoadFlags/@, may be 0 -} + -> m GIRepository.Typelib.Typelib + {- ^ __Returns:__ a pointer to the 'GI.GIRepository.Structs.Typelib.Typelib' if successful, 'Nothing' otherwise /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryRequire repository namespace_ version flags = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + namespace_' <- textToCString namespace_ + maybeVersion <- case version of + Nothing -> return nullPtr + Just jVersion -> do + jVersion' <- textToCString jVersion + return jVersion' + let flags' = gflagsToWord flags + onException (do + result <- propagateGError $ g_irepository_require repository' namespace_' maybeVersion flags' + checkUnexpectedReturnNULL "repositoryRequire" result + result' <- (newPtr GIRepository.Typelib.Typelib) result + touchManagedPtr repository + freeMem namespace_' + freeMem maybeVersion + return result' + ) (do + freeMem namespace_' + freeMem maybeVersion + ) + +#if ENABLE_OVERLOADING +data RepositoryRequireMethodInfo +instance (signature ~ (T.Text -> Maybe (T.Text) -> [GIRepository.Flags.RepositoryLoadFlags] -> m GIRepository.Typelib.Typelib), MonadIO m, IsRepository a) => O.MethodInfo RepositoryRequireMethodInfo a signature where + overloadedMethod _ = repositoryRequire + +#endif + +-- method Repository::require_private +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "repository", argType = TInterface (Name {namespace = "GIRepository", name = "Repository"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIRepository or %NULL for the singleton\n process-global default #GIRepository", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "typelib_dir", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Private directory where to find the requested typelib", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "namespace_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "GI namespace to use, e.g. \"Gtk\"", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "version", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Version of namespace, may be %NULL for latest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GIRepository", name = "RepositoryLoadFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Set of %GIRepositoryLoadFlags, may be 0", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "Typelib"})) +-- throws : True +-- Skip return : False + +foreign import ccall "g_irepository_require_private" g_irepository_require_private :: + Ptr Repository -> -- repository : TInterface (Name {namespace = "GIRepository", name = "Repository"}) + CString -> -- typelib_dir : TBasicType TUTF8 + CString -> -- namespace_ : TBasicType TUTF8 + CString -> -- version : TBasicType TUTF8 + CUInt -> -- flags : TInterface (Name {namespace = "GIRepository", name = "RepositoryLoadFlags"}) + Ptr (Ptr GError) -> -- error + IO (Ptr GIRepository.Typelib.Typelib) + +{- | +Force the namespace /@namespace_@/ to be loaded if it isn\'t already. +If /@namespace_@/ is not loaded, this function will search for a +\".typelib\" file within the private directory only. In addition, a +version /@version@/ of namespace should be specified. If /@version@/ is +not specified, the latest will be used. +-} +repositoryRequirePrivate :: + (B.CallStack.HasCallStack, MonadIO m, IsRepository a) => + a + {- ^ /@repository@/: A 'GI.GIRepository.Objects.Repository.Repository' or 'Nothing' for the singleton + process-global default 'GI.GIRepository.Objects.Repository.Repository' -} + -> T.Text + {- ^ /@typelibDir@/: Private directory where to find the requested typelib -} + -> T.Text + {- ^ /@namespace_@/: GI namespace to use, e.g. \"Gtk\" -} + -> Maybe (T.Text) + {- ^ /@version@/: Version of namespace, may be 'Nothing' for latest -} + -> [GIRepository.Flags.RepositoryLoadFlags] + {- ^ /@flags@/: Set of @/GIRepositoryLoadFlags/@, may be 0 -} + -> m GIRepository.Typelib.Typelib + {- ^ __Returns:__ a pointer to the 'GI.GIRepository.Structs.Typelib.Typelib' if successful, 'Nothing' otherwise /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryRequirePrivate repository typelibDir namespace_ version flags = liftIO $ do + repository' <- unsafeManagedPtrCastPtr repository + typelibDir' <- textToCString typelibDir + namespace_' <- textToCString namespace_ + maybeVersion <- case version of + Nothing -> return nullPtr + Just jVersion -> do + jVersion' <- textToCString jVersion + return jVersion' + let flags' = gflagsToWord flags + onException (do + result <- propagateGError $ g_irepository_require_private repository' typelibDir' namespace_' maybeVersion flags' + checkUnexpectedReturnNULL "repositoryRequirePrivate" result + result' <- (newPtr GIRepository.Typelib.Typelib) result + touchManagedPtr repository + freeMem typelibDir' + freeMem namespace_' + freeMem maybeVersion + return result' + ) (do + freeMem typelibDir' + freeMem namespace_' + freeMem maybeVersion + ) + +#if ENABLE_OVERLOADING +data RepositoryRequirePrivateMethodInfo +instance (signature ~ (T.Text -> T.Text -> Maybe (T.Text) -> [GIRepository.Flags.RepositoryLoadFlags] -> m GIRepository.Typelib.Typelib), MonadIO m, IsRepository a) => O.MethodInfo RepositoryRequirePrivateMethodInfo a signature where + overloadedMethod _ = repositoryRequirePrivate + +#endif + +-- method Repository::dump +-- method type : MemberFunction +-- Args : [Arg {argCName = "arg", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, 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 "g_irepository_dump" g_irepository_dump :: + CString -> -- arg : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +/No description available in the introspection data./ +-} +repositoryDump :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +repositoryDump arg = liftIO $ do + arg' <- textToCString arg + onException (do + _ <- propagateGError $ g_irepository_dump arg' + freeMem arg' + return () + ) (do + freeMem arg' + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Repository::error_quark +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "g_irepository_error_quark" g_irepository_error_quark :: + IO Word32 + +{- | +/No description available in the introspection data./ +-} +repositoryErrorQuark :: + (B.CallStack.HasCallStack, MonadIO m) => + m Word32 +repositoryErrorQuark = liftIO $ do + result <- g_irepository_error_quark + return result + +#if ENABLE_OVERLOADING +#endif + +-- method Repository::get_default +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "Repository"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_irepository_get_default" g_irepository_get_default :: + IO (Ptr Repository) + +{- | +Returns the singleton process-global default 'GI.GIRepository.Objects.Repository.Repository'. It is +not currently supported to have multiple repositories in a +particular process, but this function is provided in the unlikely +eventuality that it would become possible, and as a convenience for +higher level language bindings to conform to the GObject method +call conventions. + +All methods on 'GI.GIRepository.Objects.Repository.Repository' also accept 'Nothing' as an instance +parameter to mean this default repository, which is usually more +convenient for C. +-} +repositoryGetDefault :: + (B.CallStack.HasCallStack, MonadIO m) => + m Repository + {- ^ __Returns:__ The global singleton 'GI.GIRepository.Objects.Repository.Repository' -} +repositoryGetDefault = liftIO $ do + result <- g_irepository_get_default + checkUnexpectedReturnNULL "repositoryGetDefault" result + result' <- (newObject Repository) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Repository::get_option_group +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GLib", name = "OptionGroup"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_irepository_get_option_group" g_irepository_get_option_group :: + IO (Ptr GLib.OptionGroup.OptionGroup) + +{- | +Obtain the option group for girepository, it\'s used +by the dumper and for programs that wants to provide +introspection information +-} +repositoryGetOptionGroup :: + (B.CallStack.HasCallStack, MonadIO m) => + m GLib.OptionGroup.OptionGroup + {- ^ __Returns:__ the option group -} +repositoryGetOptionGroup = liftIO $ do + result <- g_irepository_get_option_group + checkUnexpectedReturnNULL "repositoryGetOptionGroup" result + result' <- (wrapBoxed GLib.OptionGroup.OptionGroup) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Repository::get_search_path +-- method type : MemberFunction +-- Args : [] +-- Lengths : [] +-- returnType : Just (TGSList (TBasicType TFileName)) +-- throws : False +-- Skip return : False + +foreign import ccall "g_irepository_get_search_path" g_irepository_get_search_path :: + IO (Ptr (GSList CString)) + +{- | +Returns the current search path 'GI.GIRepository.Objects.Repository.Repository' will use when loading +typelib files. The list is internal to 'GI.GIRepository.Objects.Repository.Repository' and should not +be freed, nor should its string elements. +-} +repositoryGetSearchPath :: + (B.CallStack.HasCallStack, MonadIO m) => + m [[Char]] + {- ^ __Returns:__ 'GI.GLib.Structs.SList.SList' of strings -} +repositoryGetSearchPath = liftIO $ do + result <- g_irepository_get_search_path + result' <- unpackGSList result + result'' <- mapM cstringToString result' + return result'' + +#if ENABLE_OVERLOADING +#endif + +-- method Repository::prepend_library_path +-- method type : MemberFunction +-- Args : [Arg {argCName = "directory", argType = TBasicType TUTF8, 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 "g_irepository_prepend_library_path" g_irepository_prepend_library_path :: + CString -> -- directory : TBasicType TUTF8 + IO () + +{- | +/No description available in the introspection data./ +-} +repositoryPrependLibraryPath :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -> m () +repositoryPrependLibraryPath directory = liftIO $ do + directory' <- textToCString directory + g_irepository_prepend_library_path directory' + freeMem directory' + return () + +#if ENABLE_OVERLOADING +#endif + +-- method Repository::prepend_search_path +-- method type : MemberFunction +-- Args : [Arg {argCName = "directory", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "directory name to prepend to the typelib\n search path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "g_irepository_prepend_search_path" g_irepository_prepend_search_path :: + CString -> -- directory : TBasicType TFileName + IO () + +{- | +Prepends /@directory@/ to the typelib search path. + +See also: 'GI.GIRepository.Objects.Repository.repositoryGetSearchPath'. +-} +repositoryPrependSearchPath :: + (B.CallStack.HasCallStack, MonadIO m) => + [Char] + {- ^ /@directory@/: directory name to prepend to the typelib + search path -} + -> m () +repositoryPrependSearchPath directory = liftIO $ do + directory' <- stringToCString directory + g_irepository_prepend_search_path directory' + freeMem directory' + return () + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/GIRepository/Objects/Repository.hs-boot b/GI/GIRepository/Objects/Repository.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GIRepository/Objects/Repository.hs-boot @@ -0,0 +1,83 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GIRepository.Objects.Repository 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 Repository = Repository (ManagedPtr Repository) +instance GObject Repository where +class (GObject o, O.IsDescendantOf Repository o) => IsRepository o +instance (GObject o, O.IsDescendantOf Repository o) => IsRepository o +instance O.HasParentTypes Repository +#if ENABLE_OVERLOADING +data RepositoryEnumerateVersionsMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryFindByErrorDomainMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryFindByGtypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryFindByNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryGetCPrefixMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryGetDependenciesMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryGetImmediateDependenciesMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryGetInfoMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryGetLoadedNamespacesMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryGetNInfosMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryGetObjectGtypeInterfacesMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryGetSharedLibraryMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryGetTypelibPathMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryGetVersionMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryIsRegisteredMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryLoadTypelibMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryRequireMethodInfo +#endif +#if ENABLE_OVERLOADING +data RepositoryRequirePrivateMethodInfo +#endif diff --git a/GI/GIRepository/Structs.hs b/GI/GIRepository/Structs.hs new file mode 100644 --- /dev/null +++ b/GI/GIRepository/Structs.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.GIRepository.Structs + ( module GI.GIRepository.Structs.AttributeIter, + module GI.GIRepository.Structs.BaseInfo , + module GI.GIRepository.Structs.Typelib , + module GI.GIRepository.Structs.UnresolvedInfo, + + + ) where + +import GI.GIRepository.Structs.AttributeIter +import GI.GIRepository.Structs.BaseInfo +import GI.GIRepository.Structs.Typelib +import GI.GIRepository.Structs.UnresolvedInfo + +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/GIRepository/Structs/AttributeIter.hs b/GI/GIRepository/Structs/AttributeIter.hs new file mode 100644 --- /dev/null +++ b/GI/GIRepository/Structs/AttributeIter.hs @@ -0,0 +1,89 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +An opaque structure used to iterate over attributes +in a 'GI.GIRepository.Structs.BaseInfo.BaseInfo' struct. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GIRepository.Structs.AttributeIter + ( + +-- * Exported types + AttributeIter(..) , + newZeroAttributeIter , + noAttributeIter , + + + ) 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 AttributeIter = AttributeIter (ManagedPtr AttributeIter) +instance WrappedPtr AttributeIter where + wrappedPtrCalloc = callocBytes 32 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 32 >=> wrapPtr AttributeIter) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `AttributeIter` struct initialized to zero. +newZeroAttributeIter :: MonadIO m => m AttributeIter +newZeroAttributeIter = liftIO $ wrappedPtrCalloc >>= wrapPtr AttributeIter + +instance tag ~ 'AttrSet => Constructible AttributeIter tag where + new _ attrs = do + o <- newZeroAttributeIter + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `AttributeIter`. +noAttributeIter :: Maybe AttributeIter +noAttributeIter = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList AttributeIter +type instance O.AttributeList AttributeIter = AttributeIterAttributeList +type AttributeIterAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveAttributeIterMethod (t :: Symbol) (o :: *) :: * where + ResolveAttributeIterMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveAttributeIterMethod t AttributeIter, O.MethodInfo info AttributeIter p) => OL.IsLabel t (AttributeIter -> 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/GIRepository/Structs/AttributeIter.hs-boot b/GI/GIRepository/Structs/AttributeIter.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GIRepository/Structs/AttributeIter.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GIRepository.Structs.AttributeIter 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 AttributeIter = AttributeIter (ManagedPtr AttributeIter) +instance WrappedPtr AttributeIter where diff --git a/GI/GIRepository/Structs/BaseInfo.hs b/GI/GIRepository/Structs/BaseInfo.hs new file mode 100644 --- /dev/null +++ b/GI/GIRepository/Structs/BaseInfo.hs @@ -0,0 +1,591 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +GIBaseInfo is the common base struct of all other *Info structs +accessible through the 'GI.GIRepository.Objects.Repository.Repository' API. +All other structs can be casted to a 'GI.GIRepository.Structs.BaseInfo.BaseInfo', for instance: +\ +\Casting a @/GIFunctionInfo/@ to 'GI.GIRepository.Structs.BaseInfo.BaseInfo'\<\/title> +\<programlisting> + GIFunctionInfo *function_info = ...; + GIBaseInfo *info = (GIBaseInfo*)function_info; +\<\/programlisting> +\<\/example> +Most 'GI.GIRepository.Objects.Repository.Repository' APIs returning a 'GI.GIRepository.Structs.BaseInfo.BaseInfo' is actually creating a new struct, in other +words, @/g_base_info_unref()/@ has to be called when done accessing the data. +GIBaseInfos are normally accessed by calling either +'GI.GIRepository.Objects.Repository.repositoryFindByName', 'GI.GIRepository.Objects.Repository.repositoryFindByGtype' or 'GI.GIRepository.Objects.Repository.repositoryGetInfo'. + +\<example> +\<title>Getting the Button of the Gtk typelib\<\/title> +\<programlisting> + GIBaseInfo *button_info = g_irepository_find_by_name(NULL, \"Gtk\", \"Button\"); + ... use button_info ... + g_base_info_unref(button_info); +\<\/programlisting> +\<\/example> + +\<refsect1 id=\"gi-gibaseinfo.struct-hierarchy\" role=\"struct_hierarchy\"> +\<title role=\"struct_hierarchy.title\">Struct hierarchy\<\/title> +\<synopsis> + GIBaseInfo + +----\<link linkend=\"gi-GIArgInfo\">GIArgInfo\<\/link> + +----\<link linkend=\"gi-GICallableInfo\">GICallableInfo\<\/link> + +----\<link linkend=\"gi-GIConstantInfo\">GIConstantInfo\<\/link> + +----\<link linkend=\"gi-GIFieldInfo\">GIFieldInfo\<\/link> + +----\<link linkend=\"gi-GIPropertyInfo\">GIPropertyInfo\<\/link> + +----\<link linkend=\"gi-GIRegisteredTypeInfo\">GIRegisteredTypeInfo\<\/link> + +----\<link linkend=\"gi-GITypeInfo\">GITypeInfo\<\/link> +\<\/synopsis> +\<\/refsect1> +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GIRepository.Structs.BaseInfo + ( + +-- * Exported types + BaseInfo(..) , + newZeroBaseInfo , + noBaseInfo , + + + -- * Methods +-- ** equal #method:equal# + +#if ENABLE_OVERLOADING + BaseInfoEqualMethodInfo , +#endif + baseInfoEqual , + + +-- ** getAttribute #method:getAttribute# + +#if ENABLE_OVERLOADING + BaseInfoGetAttributeMethodInfo , +#endif + baseInfoGetAttribute , + + +-- ** getContainer #method:getContainer# + +#if ENABLE_OVERLOADING + BaseInfoGetContainerMethodInfo , +#endif + baseInfoGetContainer , + + +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + BaseInfoGetNameMethodInfo , +#endif + baseInfoGetName , + + +-- ** getNamespace #method:getNamespace# + +#if ENABLE_OVERLOADING + BaseInfoGetNamespaceMethodInfo , +#endif + baseInfoGetNamespace , + + +-- ** getType #method:getType# + +#if ENABLE_OVERLOADING + BaseInfoGetTypeMethodInfo , +#endif + baseInfoGetType , + + +-- ** getTypelib #method:getTypelib# + +#if ENABLE_OVERLOADING + BaseInfoGetTypelibMethodInfo , +#endif + baseInfoGetTypelib , + + +-- ** isDeprecated #method:isDeprecated# + +#if ENABLE_OVERLOADING + BaseInfoIsDeprecatedMethodInfo , +#endif + baseInfoIsDeprecated , + + +-- ** iterateAttributes #method:iterateAttributes# + +#if ENABLE_OVERLOADING + BaseInfoIterateAttributesMethodInfo , +#endif + baseInfoIterateAttributes , + + + + + ) 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 {-# SOURCE #-} qualified GI.GIRepository.Enums as GIRepository.Enums +import {-# SOURCE #-} qualified GI.GIRepository.Structs.AttributeIter as GIRepository.AttributeIter +import {-# SOURCE #-} qualified GI.GIRepository.Structs.Typelib as GIRepository.Typelib + +-- | Memory-managed wrapper type. +newtype BaseInfo = BaseInfo (ManagedPtr BaseInfo) +foreign import ccall "g_base_info_gtype_get_type" c_g_base_info_gtype_get_type :: + IO GType + +instance BoxedObject BaseInfo where + boxedType _ = c_g_base_info_gtype_get_type + +-- | Construct a `BaseInfo` struct initialized to zero. +newZeroBaseInfo :: MonadIO m => m BaseInfo +newZeroBaseInfo = liftIO $ callocBoxedBytes 72 >>= wrapBoxed BaseInfo + +instance tag ~ 'AttrSet => Constructible BaseInfo tag where + new _ attrs = do + o <- newZeroBaseInfo + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `BaseInfo`. +noBaseInfo :: Maybe BaseInfo +noBaseInfo = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList BaseInfo +type instance O.AttributeList BaseInfo = BaseInfoAttributeList +type BaseInfoAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method BaseInfo::equal +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info1", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIBaseInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info2", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIBaseInfo", 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 "g_base_info_equal" g_base_info_equal :: + Ptr BaseInfo -> -- info1 : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Ptr BaseInfo -> -- info2 : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CInt + +{- | +Compare two 'GI.GIRepository.Structs.BaseInfo.BaseInfo'. + +Using pointer comparison is not practical since many functions return +different instances of 'GI.GIRepository.Structs.BaseInfo.BaseInfo' that refers to the same part of the +TypeLib; use this function instead to do 'GI.GIRepository.Structs.BaseInfo.BaseInfo' comparisons. +-} +baseInfoEqual :: + (B.CallStack.HasCallStack, MonadIO m) => + BaseInfo + {- ^ /@info1@/: a 'GI.GIRepository.Structs.BaseInfo.BaseInfo' -} + -> BaseInfo + {- ^ /@info2@/: a 'GI.GIRepository.Structs.BaseInfo.BaseInfo' -} + -> m Bool + {- ^ __Returns:__ 'True' if and only if /@info1@/ equals /@info2@/. -} +baseInfoEqual info1 info2 = liftIO $ do + info1' <- unsafeManagedPtrGetPtr info1 + info2' <- unsafeManagedPtrGetPtr info2 + result <- g_base_info_equal info1' info2' + let result' = (/= 0) result + touchManagedPtr info1 + touchManagedPtr info2 + return result' + +#if ENABLE_OVERLOADING +data BaseInfoEqualMethodInfo +instance (signature ~ (BaseInfo -> m Bool), MonadIO m) => O.MethodInfo BaseInfoEqualMethodInfo BaseInfo signature where + overloadedMethod _ = baseInfoEqual + +#endif + +-- method BaseInfo::get_attribute +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIBaseInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a freeform string naming an attribute", 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 "g_base_info_get_attribute" g_base_info_get_attribute :: + Ptr BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + CString -> -- name : TBasicType TUTF8 + IO CString + +{- | +Retrieve an arbitrary attribute associated with this node. +-} +baseInfoGetAttribute :: + (B.CallStack.HasCallStack, MonadIO m) => + BaseInfo + {- ^ /@info@/: a 'GI.GIRepository.Structs.BaseInfo.BaseInfo' -} + -> T.Text + {- ^ /@name@/: a freeform string naming an attribute -} + -> m T.Text + {- ^ __Returns:__ The value of the attribute, or 'Nothing' if no such attribute exists -} +baseInfoGetAttribute info name = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + name' <- textToCString name + result <- g_base_info_get_attribute info' name' + checkUnexpectedReturnNULL "baseInfoGetAttribute" result + result' <- cstringToText result + touchManagedPtr info + freeMem name' + return result' + +#if ENABLE_OVERLOADING +data BaseInfoGetAttributeMethodInfo +instance (signature ~ (T.Text -> m T.Text), MonadIO m) => O.MethodInfo BaseInfoGetAttributeMethodInfo BaseInfo signature where + overloadedMethod _ = baseInfoGetAttribute + +#endif + +-- method BaseInfo::get_container +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIBaseInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "BaseInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_base_info_get_container" g_base_info_get_container :: + Ptr BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO (Ptr BaseInfo) + +{- | +Obtain the container of the /@info@/. The container is the parent +GIBaseInfo. For instance, the parent of a @/GIFunctionInfo/@ is an +@/GIObjectInfo/@ or @/GIInterfaceInfo/@. +-} +baseInfoGetContainer :: + (B.CallStack.HasCallStack, MonadIO m) => + BaseInfo + {- ^ /@info@/: a 'GI.GIRepository.Structs.BaseInfo.BaseInfo' -} + -> m BaseInfo + {- ^ __Returns:__ the container -} +baseInfoGetContainer info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_base_info_get_container info' + checkUnexpectedReturnNULL "baseInfoGetContainer" result + result' <- (newBoxed BaseInfo) result + touchManagedPtr info + return result' + +#if ENABLE_OVERLOADING +data BaseInfoGetContainerMethodInfo +instance (signature ~ (m BaseInfo), MonadIO m) => O.MethodInfo BaseInfoGetContainerMethodInfo BaseInfo signature where + overloadedMethod _ = baseInfoGetContainer + +#endif + +-- method BaseInfo::get_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIBaseInfo", 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 "g_base_info_get_name" g_base_info_get_name :: + Ptr BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CString + +{- | +Obtain the name of the /@info@/. What the name represents depends on +the 'GI.GIRepository.Enums.InfoType' of the /@info@/. For instance for @/GIFunctionInfo/@ it is +the name of the function. +-} +baseInfoGetName :: + (B.CallStack.HasCallStack, MonadIO m) => + BaseInfo + {- ^ /@info@/: a 'GI.GIRepository.Structs.BaseInfo.BaseInfo' -} + -> m T.Text + {- ^ __Returns:__ the name of /@info@/ or 'Nothing' if it lacks a name. -} +baseInfoGetName info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_base_info_get_name info' + checkUnexpectedReturnNULL "baseInfoGetName" result + result' <- cstringToText result + touchManagedPtr info + return result' + +#if ENABLE_OVERLOADING +data BaseInfoGetNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo BaseInfoGetNameMethodInfo BaseInfo signature where + overloadedMethod _ = baseInfoGetName + +#endif + +-- method BaseInfo::get_namespace +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIBaseInfo", 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 "g_base_info_get_namespace" g_base_info_get_namespace :: + Ptr BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CString + +{- | +Obtain the namespace of /@info@/. +-} +baseInfoGetNamespace :: + (B.CallStack.HasCallStack, MonadIO m) => + BaseInfo + {- ^ /@info@/: a 'GI.GIRepository.Structs.BaseInfo.BaseInfo' -} + -> m T.Text + {- ^ __Returns:__ the namespace -} +baseInfoGetNamespace info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_base_info_get_namespace info' + checkUnexpectedReturnNULL "baseInfoGetNamespace" result + result' <- cstringToText result + touchManagedPtr info + return result' + +#if ENABLE_OVERLOADING +data BaseInfoGetNamespaceMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo BaseInfoGetNamespaceMethodInfo BaseInfo signature where + overloadedMethod _ = baseInfoGetNamespace + +#endif + +-- method BaseInfo::get_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIBaseInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "InfoType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_base_info_get_type" g_base_info_get_type :: + Ptr BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CUInt + +{- | +Obtain the info type of the GIBaseInfo. +-} +baseInfoGetType :: + (B.CallStack.HasCallStack, MonadIO m) => + BaseInfo + {- ^ /@info@/: a 'GI.GIRepository.Structs.BaseInfo.BaseInfo' -} + -> m GIRepository.Enums.InfoType + {- ^ __Returns:__ the info type of /@info@/ -} +baseInfoGetType info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_base_info_get_type info' + let result' = (toEnum . fromIntegral) result + touchManagedPtr info + return result' + +#if ENABLE_OVERLOADING +data BaseInfoGetTypeMethodInfo +instance (signature ~ (m GIRepository.Enums.InfoType), MonadIO m) => O.MethodInfo BaseInfoGetTypeMethodInfo BaseInfo signature where + overloadedMethod _ = baseInfoGetType + +#endif + +-- method BaseInfo::get_typelib +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIBaseInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GIRepository", name = "Typelib"})) +-- throws : False +-- Skip return : False + +foreign import ccall "g_base_info_get_typelib" g_base_info_get_typelib :: + Ptr BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO (Ptr GIRepository.Typelib.Typelib) + +{- | +Obtain the typelib this /@info@/ belongs to +-} +baseInfoGetTypelib :: + (B.CallStack.HasCallStack, MonadIO m) => + BaseInfo + {- ^ /@info@/: a 'GI.GIRepository.Structs.BaseInfo.BaseInfo' -} + -> m GIRepository.Typelib.Typelib + {- ^ __Returns:__ the typelib. -} +baseInfoGetTypelib info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_base_info_get_typelib info' + checkUnexpectedReturnNULL "baseInfoGetTypelib" result + result' <- (newPtr GIRepository.Typelib.Typelib) result + touchManagedPtr info + return result' + +#if ENABLE_OVERLOADING +data BaseInfoGetTypelibMethodInfo +instance (signature ~ (m GIRepository.Typelib.Typelib), MonadIO m) => O.MethodInfo BaseInfoGetTypelibMethodInfo BaseInfo signature where + overloadedMethod _ = baseInfoGetTypelib + +#endif + +-- method BaseInfo::is_deprecated +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIBaseInfo", 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 "g_base_info_is_deprecated" g_base_info_is_deprecated :: + Ptr BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + IO CInt + +{- | +Obtain whether the /@info@/ is represents a metadata which is +deprecated or not. +-} +baseInfoIsDeprecated :: + (B.CallStack.HasCallStack, MonadIO m) => + BaseInfo + {- ^ /@info@/: a 'GI.GIRepository.Structs.BaseInfo.BaseInfo' -} + -> m Bool + {- ^ __Returns:__ 'True' if deprecated -} +baseInfoIsDeprecated info = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + result <- g_base_info_is_deprecated info' + let result' = (/= 0) result + touchManagedPtr info + return result' + +#if ENABLE_OVERLOADING +data BaseInfoIsDeprecatedMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo BaseInfoIsDeprecatedMethodInfo BaseInfo signature where + overloadedMethod _ = baseInfoIsDeprecated + +#endif + +-- method BaseInfo::iterate_attributes +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIBaseInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iterator", argType = TInterface (Name {namespace = "GIRepository", name = "AttributeIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIAttributeIter structure, must be initialized; see below", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Returned name, must not be freed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Returned name, must not be freed", 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 "g_base_info_iterate_attributes" g_base_info_iterate_attributes :: + Ptr BaseInfo -> -- info : TInterface (Name {namespace = "GIRepository", name = "BaseInfo"}) + Ptr GIRepository.AttributeIter.AttributeIter -> -- iterator : TInterface (Name {namespace = "GIRepository", name = "AttributeIter"}) + Ptr CString -> -- name : TBasicType TUTF8 + Ptr CString -> -- value : TBasicType TUTF8 + IO CInt + +{- | +Iterate over all attributes associated with this node. The iterator +structure is typically stack allocated, and must have its first +member initialized to 'Nothing'. Attributes are arbitrary namespaced key–value +pairs which can be attached to almost any item. They are intended for use +by software higher in the toolchain than bindings, and are distinct from +normal GIR annotations. + +Both the /@name@/ and /@value@/ should be treated as constants +and must not be freed. + +\<example> +\<title>Iterating over attributes\<\/title> +\<programlisting> +void +print_attributes (GIBaseInfo *info) +{ + GIAttributeIter iter = { 0, }; + char *name; + char *value; + while (g_base_info_iterate_attributes (info, &iter, &name, &value)) + { + g_print (\"attribute name: @/s/@ value: @/s/@\", name, value); + } +} +\<\/programlisting> +\<\/example> +-} +baseInfoIterateAttributes :: + (B.CallStack.HasCallStack, MonadIO m) => + BaseInfo + {- ^ /@info@/: a 'GI.GIRepository.Structs.BaseInfo.BaseInfo' -} + -> GIRepository.AttributeIter.AttributeIter + {- ^ /@iterator@/: a 'GI.GIRepository.Structs.AttributeIter.AttributeIter' structure, must be initialized; see below -} + -> m ((Bool, T.Text, T.Text)) + {- ^ __Returns:__ 'True' if there are more attributes -} +baseInfoIterateAttributes info iterator = liftIO $ do + info' <- unsafeManagedPtrGetPtr info + iterator' <- unsafeManagedPtrGetPtr iterator + name <- allocMem :: IO (Ptr CString) + value <- allocMem :: IO (Ptr CString) + result <- g_base_info_iterate_attributes info' iterator' name value + let result' = (/= 0) result + name' <- peek name + name'' <- cstringToText name' + value' <- peek value + value'' <- cstringToText value' + touchManagedPtr info + touchManagedPtr iterator + freeMem name + freeMem value + return (result', name'', value'') + +#if ENABLE_OVERLOADING +data BaseInfoIterateAttributesMethodInfo +instance (signature ~ (GIRepository.AttributeIter.AttributeIter -> m ((Bool, T.Text, T.Text))), MonadIO m) => O.MethodInfo BaseInfoIterateAttributesMethodInfo BaseInfo signature where + overloadedMethod _ = baseInfoIterateAttributes + +#endif + +#if ENABLE_OVERLOADING +type family ResolveBaseInfoMethod (t :: Symbol) (o :: *) :: * where + ResolveBaseInfoMethod "equal" o = BaseInfoEqualMethodInfo + ResolveBaseInfoMethod "isDeprecated" o = BaseInfoIsDeprecatedMethodInfo + ResolveBaseInfoMethod "iterateAttributes" o = BaseInfoIterateAttributesMethodInfo + ResolveBaseInfoMethod "getAttribute" o = BaseInfoGetAttributeMethodInfo + ResolveBaseInfoMethod "getContainer" o = BaseInfoGetContainerMethodInfo + ResolveBaseInfoMethod "getName" o = BaseInfoGetNameMethodInfo + ResolveBaseInfoMethod "getNamespace" o = BaseInfoGetNamespaceMethodInfo + ResolveBaseInfoMethod "getType" o = BaseInfoGetTypeMethodInfo + ResolveBaseInfoMethod "getTypelib" o = BaseInfoGetTypelibMethodInfo + ResolveBaseInfoMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveBaseInfoMethod t BaseInfo, O.MethodInfo info BaseInfo p) => OL.IsLabel t (BaseInfo -> 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/GIRepository/Structs/BaseInfo.hs-boot b/GI/GIRepository/Structs/BaseInfo.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GIRepository/Structs/BaseInfo.hs-boot @@ -0,0 +1,53 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GIRepository.Structs.BaseInfo 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 BaseInfo = BaseInfo (ManagedPtr BaseInfo) +instance BoxedObject BaseInfo where +#if ENABLE_OVERLOADING +data BaseInfoEqualMethodInfo +#endif +#if ENABLE_OVERLOADING +data BaseInfoGetAttributeMethodInfo +#endif +#if ENABLE_OVERLOADING +data BaseInfoGetContainerMethodInfo +#endif +#if ENABLE_OVERLOADING +data BaseInfoGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data BaseInfoGetNamespaceMethodInfo +#endif +#if ENABLE_OVERLOADING +data BaseInfoGetTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data BaseInfoGetTypelibMethodInfo +#endif +#if ENABLE_OVERLOADING +data BaseInfoIsDeprecatedMethodInfo +#endif +#if ENABLE_OVERLOADING +data BaseInfoIterateAttributesMethodInfo +#endif diff --git a/GI/GIRepository/Structs/Typelib.hs b/GI/GIRepository/Structs/Typelib.hs new file mode 100644 --- /dev/null +++ b/GI/GIRepository/Structs/Typelib.hs @@ -0,0 +1,212 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +TODO +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GIRepository.Structs.Typelib + ( + +-- * Exported types + Typelib(..) , + noTypelib , + + + -- * Methods +-- ** free #method:free# + +#if ENABLE_OVERLOADING + TypelibFreeMethodInfo , +#endif + typelibFree , + + +-- ** getNamespace #method:getNamespace# + +#if ENABLE_OVERLOADING + TypelibGetNamespaceMethodInfo , +#endif + typelibGetNamespace , + + +-- ** symbol #method:symbol# + +#if ENABLE_OVERLOADING + TypelibSymbolMethodInfo , +#endif + typelibSymbol , + + + + + ) 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 Typelib = Typelib (ManagedPtr Typelib) +-- XXX Wrapping a foreign struct/union with no known destructor or size, leak? +instance WrappedPtr Typelib where + wrappedPtrCalloc = return nullPtr + wrappedPtrCopy = return + wrappedPtrFree = Nothing + +-- | A convenience alias for `Nothing` :: `Maybe` `Typelib`. +noTypelib :: Maybe Typelib +noTypelib = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Typelib +type instance O.AttributeList Typelib = TypelibAttributeList +type TypelibAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method Typelib::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "typelib", argType = TInterface (Name {namespace = "GIRepository", name = "Typelib"}), 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 "g_typelib_free" g_typelib_free :: + Ptr Typelib -> -- typelib : TInterface (Name {namespace = "GIRepository", name = "Typelib"}) + IO () + +{- | +/No description available in the introspection data./ +-} +typelibFree :: + (B.CallStack.HasCallStack, MonadIO m) => + Typelib + -> m () +typelibFree typelib = liftIO $ do + typelib' <- unsafeManagedPtrGetPtr typelib + g_typelib_free typelib' + touchManagedPtr typelib + return () + +#if ENABLE_OVERLOADING +data TypelibFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo TypelibFreeMethodInfo Typelib signature where + overloadedMethod _ = typelibFree + +#endif + +-- method Typelib::get_namespace +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "typelib", argType = TInterface (Name {namespace = "GIRepository", name = "Typelib"}), 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 "g_typelib_get_namespace" g_typelib_get_namespace :: + Ptr Typelib -> -- typelib : TInterface (Name {namespace = "GIRepository", name = "Typelib"}) + IO CString + +{- | +/No description available in the introspection data./ +-} +typelibGetNamespace :: + (B.CallStack.HasCallStack, MonadIO m) => + Typelib + -> m T.Text +typelibGetNamespace typelib = liftIO $ do + typelib' <- unsafeManagedPtrGetPtr typelib + result <- g_typelib_get_namespace typelib' + checkUnexpectedReturnNULL "typelibGetNamespace" result + result' <- cstringToText result + touchManagedPtr typelib + return result' + +#if ENABLE_OVERLOADING +data TypelibGetNamespaceMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo TypelibGetNamespaceMethodInfo Typelib signature where + overloadedMethod _ = typelibGetNamespace + +#endif + +-- method Typelib::symbol +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "typelib", argType = TInterface (Name {namespace = "GIRepository", name = "Typelib"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "symbol_name", 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 = "symbol", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, 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 "g_typelib_symbol" g_typelib_symbol :: + Ptr Typelib -> -- typelib : TInterface (Name {namespace = "GIRepository", name = "Typelib"}) + CString -> -- symbol_name : TBasicType TUTF8 + Ptr () -> -- symbol : TBasicType TPtr + IO CInt + +{- | +/No description available in the introspection data./ +-} +typelibSymbol :: + (B.CallStack.HasCallStack, MonadIO m) => + Typelib + -> T.Text + -> Ptr () + -> m Bool +typelibSymbol typelib symbolName symbol = liftIO $ do + typelib' <- unsafeManagedPtrGetPtr typelib + symbolName' <- textToCString symbolName + result <- g_typelib_symbol typelib' symbolName' symbol + let result' = (/= 0) result + touchManagedPtr typelib + freeMem symbolName' + return result' + +#if ENABLE_OVERLOADING +data TypelibSymbolMethodInfo +instance (signature ~ (T.Text -> Ptr () -> m Bool), MonadIO m) => O.MethodInfo TypelibSymbolMethodInfo Typelib signature where + overloadedMethod _ = typelibSymbol + +#endif + +#if ENABLE_OVERLOADING +type family ResolveTypelibMethod (t :: Symbol) (o :: *) :: * where + ResolveTypelibMethod "free" o = TypelibFreeMethodInfo + ResolveTypelibMethod "symbol" o = TypelibSymbolMethodInfo + ResolveTypelibMethod "getNamespace" o = TypelibGetNamespaceMethodInfo + ResolveTypelibMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveTypelibMethod t Typelib, O.MethodInfo info Typelib p) => OL.IsLabel t (Typelib -> 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/GIRepository/Structs/Typelib.hs-boot b/GI/GIRepository/Structs/Typelib.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GIRepository/Structs/Typelib.hs-boot @@ -0,0 +1,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GIRepository.Structs.Typelib 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 Typelib = Typelib (ManagedPtr Typelib) +instance WrappedPtr Typelib where +#if ENABLE_OVERLOADING +data TypelibFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data TypelibGetNamespaceMethodInfo +#endif +#if ENABLE_OVERLOADING +data TypelibSymbolMethodInfo +#endif diff --git a/GI/GIRepository/Structs/UnresolvedInfo.hs b/GI/GIRepository/Structs/UnresolvedInfo.hs new file mode 100644 --- /dev/null +++ b/GI/GIRepository/Structs/UnresolvedInfo.hs @@ -0,0 +1,77 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Represents a unresolved type in a typelib. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GIRepository.Structs.UnresolvedInfo + ( + +-- * Exported types + UnresolvedInfo(..) , + noUnresolvedInfo , + + + ) 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 UnresolvedInfo = UnresolvedInfo (ManagedPtr UnresolvedInfo) +-- XXX Wrapping a foreign struct/union with no known destructor or size, leak? +instance WrappedPtr UnresolvedInfo where + wrappedPtrCalloc = return nullPtr + wrappedPtrCopy = return + wrappedPtrFree = Nothing + +-- | A convenience alias for `Nothing` :: `Maybe` `UnresolvedInfo`. +noUnresolvedInfo :: Maybe UnresolvedInfo +noUnresolvedInfo = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList UnresolvedInfo +type instance O.AttributeList UnresolvedInfo = UnresolvedInfoAttributeList +type UnresolvedInfoAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveUnresolvedInfoMethod (t :: Symbol) (o :: *) :: * where + ResolveUnresolvedInfoMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveUnresolvedInfoMethod t UnresolvedInfo, O.MethodInfo info UnresolvedInfo p) => OL.IsLabel t (UnresolvedInfo -> 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/GIRepository/Structs/UnresolvedInfo.hs-boot b/GI/GIRepository/Structs/UnresolvedInfo.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GIRepository/Structs/UnresolvedInfo.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GIRepository.Structs.UnresolvedInfo 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 UnresolvedInfo = UnresolvedInfo (ManagedPtr UnresolvedInfo) +instance WrappedPtr UnresolvedInfo where diff --git a/GI/GIRepository/Unions.hs b/GI/GIRepository/Unions.hs new file mode 100644 --- /dev/null +++ b/GI/GIRepository/Unions.hs @@ -0,0 +1,41 @@ + + +{- | +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.GIRepository.Unions + ( module GI.GIRepository.Unions.Argument , + + + ) where + +import GI.GIRepository.Unions.Argument + +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/GIRepository/Unions/Argument.hs b/GI/GIRepository/Unions/Argument.hs new file mode 100644 --- /dev/null +++ b/GI/GIRepository/Unions/Argument.hs @@ -0,0 +1,1281 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Stores an argument of varying type +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GIRepository.Unions.Argument + ( + +-- * Exported types + Argument(..) , + newZeroArgument , + noArgument , + + + -- * Properties +-- ** vBoolean #attr:vBoolean# +{- | TODO +-} +#if ENABLE_OVERLOADING + argument_vBoolean , +#endif + getArgumentVBoolean , + setArgumentVBoolean , + + +-- ** vDouble #attr:vDouble# +{- | TODO +-} +#if ENABLE_OVERLOADING + argument_vDouble , +#endif + getArgumentVDouble , + setArgumentVDouble , + + +-- ** vFloat #attr:vFloat# +{- | TODO +-} +#if ENABLE_OVERLOADING + argument_vFloat , +#endif + getArgumentVFloat , + setArgumentVFloat , + + +-- ** vInt #attr:vInt# +{- | TODO +-} +#if ENABLE_OVERLOADING + argument_vInt , +#endif + getArgumentVInt , + setArgumentVInt , + + +-- ** vInt16 #attr:vInt16# +{- | TODO +-} +#if ENABLE_OVERLOADING + argument_vInt16 , +#endif + getArgumentVInt16 , + setArgumentVInt16 , + + +-- ** vInt32 #attr:vInt32# +{- | TODO +-} +#if ENABLE_OVERLOADING + argument_vInt32 , +#endif + getArgumentVInt32 , + setArgumentVInt32 , + + +-- ** vInt64 #attr:vInt64# +{- | TODO +-} +#if ENABLE_OVERLOADING + argument_vInt64 , +#endif + getArgumentVInt64 , + setArgumentVInt64 , + + +-- ** vInt8 #attr:vInt8# +{- | TODO +-} +#if ENABLE_OVERLOADING + argument_vInt8 , +#endif + getArgumentVInt8 , + setArgumentVInt8 , + + +-- ** vLong #attr:vLong# +{- | TODO +-} +#if ENABLE_OVERLOADING + argument_vLong , +#endif + getArgumentVLong , + setArgumentVLong , + + +-- ** vPointer #attr:vPointer# +{- | TODO +-} +#if ENABLE_OVERLOADING + argument_vPointer , +#endif + clearArgumentVPointer , + getArgumentVPointer , + setArgumentVPointer , + + +-- ** vShort #attr:vShort# +{- | TODO +-} +#if ENABLE_OVERLOADING + argument_vShort , +#endif + getArgumentVShort , + setArgumentVShort , + + +-- ** vSize #attr:vSize# +{- | TODO +-} +#if ENABLE_OVERLOADING + argument_vSize , +#endif + getArgumentVSize , + setArgumentVSize , + + +-- ** vSsize #attr:vSsize# +{- | TODO +-} +#if ENABLE_OVERLOADING + argument_vSsize , +#endif + getArgumentVSsize , + setArgumentVSsize , + + +-- ** vString #attr:vString# +{- | TODO +-} +#if ENABLE_OVERLOADING + argument_vString , +#endif + clearArgumentVString , + getArgumentVString , + setArgumentVString , + + +-- ** vUint #attr:vUint# +{- | TODO +-} +#if ENABLE_OVERLOADING + argument_vUint , +#endif + getArgumentVUint , + setArgumentVUint , + + +-- ** vUint16 #attr:vUint16# +{- | TODO +-} +#if ENABLE_OVERLOADING + argument_vUint16 , +#endif + getArgumentVUint16 , + setArgumentVUint16 , + + +-- ** vUint32 #attr:vUint32# +{- | TODO +-} +#if ENABLE_OVERLOADING + argument_vUint32 , +#endif + getArgumentVUint32 , + setArgumentVUint32 , + + +-- ** vUint64 #attr:vUint64# +{- | TODO +-} +#if ENABLE_OVERLOADING + argument_vUint64 , +#endif + getArgumentVUint64 , + setArgumentVUint64 , + + +-- ** vUint8 #attr:vUint8# +{- | TODO +-} +#if ENABLE_OVERLOADING + argument_vUint8 , +#endif + getArgumentVUint8 , + setArgumentVUint8 , + + +-- ** vUlong #attr:vUlong# +{- | TODO +-} +#if ENABLE_OVERLOADING + argument_vUlong , +#endif + getArgumentVUlong , + setArgumentVUlong , + + +-- ** vUshort #attr:vUshort# +{- | TODO +-} +#if ENABLE_OVERLOADING + argument_vUshort , +#endif + getArgumentVUshort , + setArgumentVUshort , + + + + + ) 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 Argument = Argument (ManagedPtr Argument) +instance WrappedPtr Argument where + wrappedPtrCalloc = callocBytes 8 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 8 >=> wrapPtr Argument) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `Argument` struct initialized to zero. +newZeroArgument :: MonadIO m => m Argument +newZeroArgument = liftIO $ wrappedPtrCalloc >>= wrapPtr Argument + +instance tag ~ 'AttrSet => Constructible Argument tag where + new _ attrs = do + o <- newZeroArgument + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `Argument`. +noArgument :: Maybe Argument +noArgument = Nothing + +{- | +Get the value of the “@v_boolean@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' argument #vBoolean +@ +-} +getArgumentVBoolean :: MonadIO m => Argument -> m Bool +getArgumentVBoolean s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CInt + let val' = (/= 0) val + return val' + +{- | +Set the value of the “@v_boolean@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' argument [ #vBoolean 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setArgumentVBoolean :: MonadIO m => Argument -> Bool -> m () +setArgumentVBoolean s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 0) (val' :: CInt) + +#if ENABLE_OVERLOADING +data ArgumentVBooleanFieldInfo +instance AttrInfo ArgumentVBooleanFieldInfo where + type AttrAllowedOps ArgumentVBooleanFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ArgumentVBooleanFieldInfo = (~) Bool + type AttrBaseTypeConstraint ArgumentVBooleanFieldInfo = (~) Argument + type AttrGetType ArgumentVBooleanFieldInfo = Bool + type AttrLabel ArgumentVBooleanFieldInfo = "v_boolean" + type AttrOrigin ArgumentVBooleanFieldInfo = Argument + attrGet _ = getArgumentVBoolean + attrSet _ = setArgumentVBoolean + attrConstruct = undefined + attrClear _ = undefined + +argument_vBoolean :: AttrLabelProxy "vBoolean" +argument_vBoolean = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@v_int8@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' argument #vInt8 +@ +-} +getArgumentVInt8 :: MonadIO m => Argument -> m Int8 +getArgumentVInt8 s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Int8 + return val + +{- | +Set the value of the “@v_int8@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' argument [ #vInt8 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setArgumentVInt8 :: MonadIO m => Argument -> Int8 -> m () +setArgumentVInt8 s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Int8) + +#if ENABLE_OVERLOADING +data ArgumentVInt8FieldInfo +instance AttrInfo ArgumentVInt8FieldInfo where + type AttrAllowedOps ArgumentVInt8FieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ArgumentVInt8FieldInfo = (~) Int8 + type AttrBaseTypeConstraint ArgumentVInt8FieldInfo = (~) Argument + type AttrGetType ArgumentVInt8FieldInfo = Int8 + type AttrLabel ArgumentVInt8FieldInfo = "v_int8" + type AttrOrigin ArgumentVInt8FieldInfo = Argument + attrGet _ = getArgumentVInt8 + attrSet _ = setArgumentVInt8 + attrConstruct = undefined + attrClear _ = undefined + +argument_vInt8 :: AttrLabelProxy "vInt8" +argument_vInt8 = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@v_uint8@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' argument #vUint8 +@ +-} +getArgumentVUint8 :: MonadIO m => Argument -> m Word8 +getArgumentVUint8 s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Word8 + return val + +{- | +Set the value of the “@v_uint8@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' argument [ #vUint8 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setArgumentVUint8 :: MonadIO m => Argument -> Word8 -> m () +setArgumentVUint8 s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Word8) + +#if ENABLE_OVERLOADING +data ArgumentVUint8FieldInfo +instance AttrInfo ArgumentVUint8FieldInfo where + type AttrAllowedOps ArgumentVUint8FieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ArgumentVUint8FieldInfo = (~) Word8 + type AttrBaseTypeConstraint ArgumentVUint8FieldInfo = (~) Argument + type AttrGetType ArgumentVUint8FieldInfo = Word8 + type AttrLabel ArgumentVUint8FieldInfo = "v_uint8" + type AttrOrigin ArgumentVUint8FieldInfo = Argument + attrGet _ = getArgumentVUint8 + attrSet _ = setArgumentVUint8 + attrConstruct = undefined + attrClear _ = undefined + +argument_vUint8 :: AttrLabelProxy "vUint8" +argument_vUint8 = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@v_int16@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' argument #vInt16 +@ +-} +getArgumentVInt16 :: MonadIO m => Argument -> m Int16 +getArgumentVInt16 s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Int16 + return val + +{- | +Set the value of the “@v_int16@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' argument [ #vInt16 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setArgumentVInt16 :: MonadIO m => Argument -> Int16 -> m () +setArgumentVInt16 s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Int16) + +#if ENABLE_OVERLOADING +data ArgumentVInt16FieldInfo +instance AttrInfo ArgumentVInt16FieldInfo where + type AttrAllowedOps ArgumentVInt16FieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ArgumentVInt16FieldInfo = (~) Int16 + type AttrBaseTypeConstraint ArgumentVInt16FieldInfo = (~) Argument + type AttrGetType ArgumentVInt16FieldInfo = Int16 + type AttrLabel ArgumentVInt16FieldInfo = "v_int16" + type AttrOrigin ArgumentVInt16FieldInfo = Argument + attrGet _ = getArgumentVInt16 + attrSet _ = setArgumentVInt16 + attrConstruct = undefined + attrClear _ = undefined + +argument_vInt16 :: AttrLabelProxy "vInt16" +argument_vInt16 = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@v_uint16@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' argument #vUint16 +@ +-} +getArgumentVUint16 :: MonadIO m => Argument -> m Word16 +getArgumentVUint16 s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Word16 + return val + +{- | +Set the value of the “@v_uint16@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' argument [ #vUint16 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setArgumentVUint16 :: MonadIO m => Argument -> Word16 -> m () +setArgumentVUint16 s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Word16) + +#if ENABLE_OVERLOADING +data ArgumentVUint16FieldInfo +instance AttrInfo ArgumentVUint16FieldInfo where + type AttrAllowedOps ArgumentVUint16FieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ArgumentVUint16FieldInfo = (~) Word16 + type AttrBaseTypeConstraint ArgumentVUint16FieldInfo = (~) Argument + type AttrGetType ArgumentVUint16FieldInfo = Word16 + type AttrLabel ArgumentVUint16FieldInfo = "v_uint16" + type AttrOrigin ArgumentVUint16FieldInfo = Argument + attrGet _ = getArgumentVUint16 + attrSet _ = setArgumentVUint16 + attrConstruct = undefined + attrClear _ = undefined + +argument_vUint16 :: AttrLabelProxy "vUint16" +argument_vUint16 = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@v_int32@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' argument #vInt32 +@ +-} +getArgumentVInt32 :: MonadIO m => Argument -> m Int32 +getArgumentVInt32 s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Int32 + return val + +{- | +Set the value of the “@v_int32@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' argument [ #vInt32 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setArgumentVInt32 :: MonadIO m => Argument -> Int32 -> m () +setArgumentVInt32 s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Int32) + +#if ENABLE_OVERLOADING +data ArgumentVInt32FieldInfo +instance AttrInfo ArgumentVInt32FieldInfo where + type AttrAllowedOps ArgumentVInt32FieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ArgumentVInt32FieldInfo = (~) Int32 + type AttrBaseTypeConstraint ArgumentVInt32FieldInfo = (~) Argument + type AttrGetType ArgumentVInt32FieldInfo = Int32 + type AttrLabel ArgumentVInt32FieldInfo = "v_int32" + type AttrOrigin ArgumentVInt32FieldInfo = Argument + attrGet _ = getArgumentVInt32 + attrSet _ = setArgumentVInt32 + attrConstruct = undefined + attrClear _ = undefined + +argument_vInt32 :: AttrLabelProxy "vInt32" +argument_vInt32 = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@v_uint32@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' argument #vUint32 +@ +-} +getArgumentVUint32 :: MonadIO m => Argument -> m Word32 +getArgumentVUint32 s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Word32 + return val + +{- | +Set the value of the “@v_uint32@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' argument [ #vUint32 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setArgumentVUint32 :: MonadIO m => Argument -> Word32 -> m () +setArgumentVUint32 s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Word32) + +#if ENABLE_OVERLOADING +data ArgumentVUint32FieldInfo +instance AttrInfo ArgumentVUint32FieldInfo where + type AttrAllowedOps ArgumentVUint32FieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ArgumentVUint32FieldInfo = (~) Word32 + type AttrBaseTypeConstraint ArgumentVUint32FieldInfo = (~) Argument + type AttrGetType ArgumentVUint32FieldInfo = Word32 + type AttrLabel ArgumentVUint32FieldInfo = "v_uint32" + type AttrOrigin ArgumentVUint32FieldInfo = Argument + attrGet _ = getArgumentVUint32 + attrSet _ = setArgumentVUint32 + attrConstruct = undefined + attrClear _ = undefined + +argument_vUint32 :: AttrLabelProxy "vUint32" +argument_vUint32 = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@v_int64@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' argument #vInt64 +@ +-} +getArgumentVInt64 :: MonadIO m => Argument -> m Int64 +getArgumentVInt64 s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Int64 + return val + +{- | +Set the value of the “@v_int64@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' argument [ #vInt64 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setArgumentVInt64 :: MonadIO m => Argument -> Int64 -> m () +setArgumentVInt64 s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Int64) + +#if ENABLE_OVERLOADING +data ArgumentVInt64FieldInfo +instance AttrInfo ArgumentVInt64FieldInfo where + type AttrAllowedOps ArgumentVInt64FieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ArgumentVInt64FieldInfo = (~) Int64 + type AttrBaseTypeConstraint ArgumentVInt64FieldInfo = (~) Argument + type AttrGetType ArgumentVInt64FieldInfo = Int64 + type AttrLabel ArgumentVInt64FieldInfo = "v_int64" + type AttrOrigin ArgumentVInt64FieldInfo = Argument + attrGet _ = getArgumentVInt64 + attrSet _ = setArgumentVInt64 + attrConstruct = undefined + attrClear _ = undefined + +argument_vInt64 :: AttrLabelProxy "vInt64" +argument_vInt64 = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@v_uint64@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' argument #vUint64 +@ +-} +getArgumentVUint64 :: MonadIO m => Argument -> m Word64 +getArgumentVUint64 s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Word64 + return val + +{- | +Set the value of the “@v_uint64@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' argument [ #vUint64 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setArgumentVUint64 :: MonadIO m => Argument -> Word64 -> m () +setArgumentVUint64 s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Word64) + +#if ENABLE_OVERLOADING +data ArgumentVUint64FieldInfo +instance AttrInfo ArgumentVUint64FieldInfo where + type AttrAllowedOps ArgumentVUint64FieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ArgumentVUint64FieldInfo = (~) Word64 + type AttrBaseTypeConstraint ArgumentVUint64FieldInfo = (~) Argument + type AttrGetType ArgumentVUint64FieldInfo = Word64 + type AttrLabel ArgumentVUint64FieldInfo = "v_uint64" + type AttrOrigin ArgumentVUint64FieldInfo = Argument + attrGet _ = getArgumentVUint64 + attrSet _ = setArgumentVUint64 + attrConstruct = undefined + attrClear _ = undefined + +argument_vUint64 :: AttrLabelProxy "vUint64" +argument_vUint64 = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@v_float@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' argument #vFloat +@ +-} +getArgumentVFloat :: MonadIO m => Argument -> m Float +getArgumentVFloat s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CFloat + let val' = realToFrac val + return val' + +{- | +Set the value of the “@v_float@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' argument [ #vFloat 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setArgumentVFloat :: MonadIO m => Argument -> Float -> m () +setArgumentVFloat s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 0) (val' :: CFloat) + +#if ENABLE_OVERLOADING +data ArgumentVFloatFieldInfo +instance AttrInfo ArgumentVFloatFieldInfo where + type AttrAllowedOps ArgumentVFloatFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ArgumentVFloatFieldInfo = (~) Float + type AttrBaseTypeConstraint ArgumentVFloatFieldInfo = (~) Argument + type AttrGetType ArgumentVFloatFieldInfo = Float + type AttrLabel ArgumentVFloatFieldInfo = "v_float" + type AttrOrigin ArgumentVFloatFieldInfo = Argument + attrGet _ = getArgumentVFloat + attrSet _ = setArgumentVFloat + attrConstruct = undefined + attrClear _ = undefined + +argument_vFloat :: AttrLabelProxy "vFloat" +argument_vFloat = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@v_double@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' argument #vDouble +@ +-} +getArgumentVDouble :: MonadIO m => Argument -> m Double +getArgumentVDouble s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@v_double@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' argument [ #vDouble 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setArgumentVDouble :: MonadIO m => Argument -> Double -> m () +setArgumentVDouble s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 0) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data ArgumentVDoubleFieldInfo +instance AttrInfo ArgumentVDoubleFieldInfo where + type AttrAllowedOps ArgumentVDoubleFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ArgumentVDoubleFieldInfo = (~) Double + type AttrBaseTypeConstraint ArgumentVDoubleFieldInfo = (~) Argument + type AttrGetType ArgumentVDoubleFieldInfo = Double + type AttrLabel ArgumentVDoubleFieldInfo = "v_double" + type AttrOrigin ArgumentVDoubleFieldInfo = Argument + attrGet _ = getArgumentVDouble + attrSet _ = setArgumentVDouble + attrConstruct = undefined + attrClear _ = undefined + +argument_vDouble :: AttrLabelProxy "vDouble" +argument_vDouble = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@v_short@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' argument #vShort +@ +-} +getArgumentVShort :: MonadIO m => Argument -> m Int16 +getArgumentVShort s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Int16 + return val + +{- | +Set the value of the “@v_short@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' argument [ #vShort 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setArgumentVShort :: MonadIO m => Argument -> Int16 -> m () +setArgumentVShort s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Int16) + +#if ENABLE_OVERLOADING +data ArgumentVShortFieldInfo +instance AttrInfo ArgumentVShortFieldInfo where + type AttrAllowedOps ArgumentVShortFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ArgumentVShortFieldInfo = (~) Int16 + type AttrBaseTypeConstraint ArgumentVShortFieldInfo = (~) Argument + type AttrGetType ArgumentVShortFieldInfo = Int16 + type AttrLabel ArgumentVShortFieldInfo = "v_short" + type AttrOrigin ArgumentVShortFieldInfo = Argument + attrGet _ = getArgumentVShort + attrSet _ = setArgumentVShort + attrConstruct = undefined + attrClear _ = undefined + +argument_vShort :: AttrLabelProxy "vShort" +argument_vShort = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@v_ushort@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' argument #vUshort +@ +-} +getArgumentVUshort :: MonadIO m => Argument -> m Word16 +getArgumentVUshort s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Word16 + return val + +{- | +Set the value of the “@v_ushort@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' argument [ #vUshort 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setArgumentVUshort :: MonadIO m => Argument -> Word16 -> m () +setArgumentVUshort s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Word16) + +#if ENABLE_OVERLOADING +data ArgumentVUshortFieldInfo +instance AttrInfo ArgumentVUshortFieldInfo where + type AttrAllowedOps ArgumentVUshortFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ArgumentVUshortFieldInfo = (~) Word16 + type AttrBaseTypeConstraint ArgumentVUshortFieldInfo = (~) Argument + type AttrGetType ArgumentVUshortFieldInfo = Word16 + type AttrLabel ArgumentVUshortFieldInfo = "v_ushort" + type AttrOrigin ArgumentVUshortFieldInfo = Argument + attrGet _ = getArgumentVUshort + attrSet _ = setArgumentVUshort + attrConstruct = undefined + attrClear _ = undefined + +argument_vUshort :: AttrLabelProxy "vUshort" +argument_vUshort = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@v_int@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' argument #vInt +@ +-} +getArgumentVInt :: MonadIO m => Argument -> m Int32 +getArgumentVInt s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Int32 + return val + +{- | +Set the value of the “@v_int@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' argument [ #vInt 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setArgumentVInt :: MonadIO m => Argument -> Int32 -> m () +setArgumentVInt s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Int32) + +#if ENABLE_OVERLOADING +data ArgumentVIntFieldInfo +instance AttrInfo ArgumentVIntFieldInfo where + type AttrAllowedOps ArgumentVIntFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ArgumentVIntFieldInfo = (~) Int32 + type AttrBaseTypeConstraint ArgumentVIntFieldInfo = (~) Argument + type AttrGetType ArgumentVIntFieldInfo = Int32 + type AttrLabel ArgumentVIntFieldInfo = "v_int" + type AttrOrigin ArgumentVIntFieldInfo = Argument + attrGet _ = getArgumentVInt + attrSet _ = setArgumentVInt + attrConstruct = undefined + attrClear _ = undefined + +argument_vInt :: AttrLabelProxy "vInt" +argument_vInt = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@v_uint@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' argument #vUint +@ +-} +getArgumentVUint :: MonadIO m => Argument -> m Word32 +getArgumentVUint s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Word32 + return val + +{- | +Set the value of the “@v_uint@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' argument [ #vUint 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setArgumentVUint :: MonadIO m => Argument -> Word32 -> m () +setArgumentVUint s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Word32) + +#if ENABLE_OVERLOADING +data ArgumentVUintFieldInfo +instance AttrInfo ArgumentVUintFieldInfo where + type AttrAllowedOps ArgumentVUintFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ArgumentVUintFieldInfo = (~) Word32 + type AttrBaseTypeConstraint ArgumentVUintFieldInfo = (~) Argument + type AttrGetType ArgumentVUintFieldInfo = Word32 + type AttrLabel ArgumentVUintFieldInfo = "v_uint" + type AttrOrigin ArgumentVUintFieldInfo = Argument + attrGet _ = getArgumentVUint + attrSet _ = setArgumentVUint + attrConstruct = undefined + attrClear _ = undefined + +argument_vUint :: AttrLabelProxy "vUint" +argument_vUint = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@v_long@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' argument #vLong +@ +-} +getArgumentVLong :: MonadIO m => Argument -> m CLong +getArgumentVLong s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CLong + return val + +{- | +Set the value of the “@v_long@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' argument [ #vLong 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setArgumentVLong :: MonadIO m => Argument -> CLong -> m () +setArgumentVLong s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: CLong) + +#if ENABLE_OVERLOADING +data ArgumentVLongFieldInfo +instance AttrInfo ArgumentVLongFieldInfo where + type AttrAllowedOps ArgumentVLongFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ArgumentVLongFieldInfo = (~) CLong + type AttrBaseTypeConstraint ArgumentVLongFieldInfo = (~) Argument + type AttrGetType ArgumentVLongFieldInfo = CLong + type AttrLabel ArgumentVLongFieldInfo = "v_long" + type AttrOrigin ArgumentVLongFieldInfo = Argument + attrGet _ = getArgumentVLong + attrSet _ = setArgumentVLong + attrConstruct = undefined + attrClear _ = undefined + +argument_vLong :: AttrLabelProxy "vLong" +argument_vLong = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@v_ulong@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' argument #vUlong +@ +-} +getArgumentVUlong :: MonadIO m => Argument -> m CULong +getArgumentVUlong s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CULong + return val + +{- | +Set the value of the “@v_ulong@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' argument [ #vUlong 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setArgumentVUlong :: MonadIO m => Argument -> CULong -> m () +setArgumentVUlong s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: CULong) + +#if ENABLE_OVERLOADING +data ArgumentVUlongFieldInfo +instance AttrInfo ArgumentVUlongFieldInfo where + type AttrAllowedOps ArgumentVUlongFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ArgumentVUlongFieldInfo = (~) CULong + type AttrBaseTypeConstraint ArgumentVUlongFieldInfo = (~) Argument + type AttrGetType ArgumentVUlongFieldInfo = CULong + type AttrLabel ArgumentVUlongFieldInfo = "v_ulong" + type AttrOrigin ArgumentVUlongFieldInfo = Argument + attrGet _ = getArgumentVUlong + attrSet _ = setArgumentVUlong + attrConstruct = undefined + attrClear _ = undefined + +argument_vUlong :: AttrLabelProxy "vUlong" +argument_vUlong = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@v_ssize@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' argument #vSsize +@ +-} +getArgumentVSsize :: MonadIO m => Argument -> m Int64 +getArgumentVSsize s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Int64 + return val + +{- | +Set the value of the “@v_ssize@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' argument [ #vSsize 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setArgumentVSsize :: MonadIO m => Argument -> Int64 -> m () +setArgumentVSsize s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Int64) + +#if ENABLE_OVERLOADING +data ArgumentVSsizeFieldInfo +instance AttrInfo ArgumentVSsizeFieldInfo where + type AttrAllowedOps ArgumentVSsizeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ArgumentVSsizeFieldInfo = (~) Int64 + type AttrBaseTypeConstraint ArgumentVSsizeFieldInfo = (~) Argument + type AttrGetType ArgumentVSsizeFieldInfo = Int64 + type AttrLabel ArgumentVSsizeFieldInfo = "v_ssize" + type AttrOrigin ArgumentVSsizeFieldInfo = Argument + attrGet _ = getArgumentVSsize + attrSet _ = setArgumentVSsize + attrConstruct = undefined + attrClear _ = undefined + +argument_vSsize :: AttrLabelProxy "vSsize" +argument_vSsize = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@v_size@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' argument #vSize +@ +-} +getArgumentVSize :: MonadIO m => Argument -> m Word64 +getArgumentVSize s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Word64 + return val + +{- | +Set the value of the “@v_size@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' argument [ #vSize 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setArgumentVSize :: MonadIO m => Argument -> Word64 -> m () +setArgumentVSize s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Word64) + +#if ENABLE_OVERLOADING +data ArgumentVSizeFieldInfo +instance AttrInfo ArgumentVSizeFieldInfo where + type AttrAllowedOps ArgumentVSizeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ArgumentVSizeFieldInfo = (~) Word64 + type AttrBaseTypeConstraint ArgumentVSizeFieldInfo = (~) Argument + type AttrGetType ArgumentVSizeFieldInfo = Word64 + type AttrLabel ArgumentVSizeFieldInfo = "v_size" + type AttrOrigin ArgumentVSizeFieldInfo = Argument + attrGet _ = getArgumentVSize + attrSet _ = setArgumentVSize + attrConstruct = undefined + attrClear _ = undefined + +argument_vSize :: AttrLabelProxy "vSize" +argument_vSize = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@v_string@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' argument #vString +@ +-} +getArgumentVString :: MonadIO m => Argument -> m (Maybe T.Text) +getArgumentVString s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@v_string@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' argument [ #vString 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setArgumentVString :: MonadIO m => Argument -> CString -> m () +setArgumentVString s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: CString) + +{- | +Set the value of the “@v_string@” field to `Nothing`. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #vString +@ +-} +clearArgumentVString :: MonadIO m => Argument -> m () +clearArgumentVString s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data ArgumentVStringFieldInfo +instance AttrInfo ArgumentVStringFieldInfo where + type AttrAllowedOps ArgumentVStringFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ArgumentVStringFieldInfo = (~) CString + type AttrBaseTypeConstraint ArgumentVStringFieldInfo = (~) Argument + type AttrGetType ArgumentVStringFieldInfo = Maybe T.Text + type AttrLabel ArgumentVStringFieldInfo = "v_string" + type AttrOrigin ArgumentVStringFieldInfo = Argument + attrGet _ = getArgumentVString + attrSet _ = setArgumentVString + attrConstruct = undefined + attrClear _ = clearArgumentVString + +argument_vString :: AttrLabelProxy "vString" +argument_vString = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@v_pointer@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' argument #vPointer +@ +-} +getArgumentVPointer :: MonadIO m => Argument -> m (Ptr ()) +getArgumentVPointer s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO (Ptr ()) + return val + +{- | +Set the value of the “@v_pointer@” field. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' argument [ #vPointer 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setArgumentVPointer :: MonadIO m => Argument -> Ptr () -> m () +setArgumentVPointer s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Ptr ()) + +{- | +Set the value of the “@v_pointer@” field to `Nothing`. +When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #vPointer +@ +-} +clearArgumentVPointer :: MonadIO m => Argument -> m () +clearArgumentVPointer s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (FP.nullPtr :: Ptr ()) + +#if ENABLE_OVERLOADING +data ArgumentVPointerFieldInfo +instance AttrInfo ArgumentVPointerFieldInfo where + type AttrAllowedOps ArgumentVPointerFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ArgumentVPointerFieldInfo = (~) (Ptr ()) + type AttrBaseTypeConstraint ArgumentVPointerFieldInfo = (~) Argument + type AttrGetType ArgumentVPointerFieldInfo = Ptr () + type AttrLabel ArgumentVPointerFieldInfo = "v_pointer" + type AttrOrigin ArgumentVPointerFieldInfo = Argument + attrGet _ = getArgumentVPointer + attrSet _ = setArgumentVPointer + attrConstruct = undefined + attrClear _ = clearArgumentVPointer + +argument_vPointer :: AttrLabelProxy "vPointer" +argument_vPointer = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Argument +type instance O.AttributeList Argument = ArgumentAttributeList +type ArgumentAttributeList = ('[ '("vBoolean", ArgumentVBooleanFieldInfo), '("vInt8", ArgumentVInt8FieldInfo), '("vUint8", ArgumentVUint8FieldInfo), '("vInt16", ArgumentVInt16FieldInfo), '("vUint16", ArgumentVUint16FieldInfo), '("vInt32", ArgumentVInt32FieldInfo), '("vUint32", ArgumentVUint32FieldInfo), '("vInt64", ArgumentVInt64FieldInfo), '("vUint64", ArgumentVUint64FieldInfo), '("vFloat", ArgumentVFloatFieldInfo), '("vDouble", ArgumentVDoubleFieldInfo), '("vShort", ArgumentVShortFieldInfo), '("vUshort", ArgumentVUshortFieldInfo), '("vInt", ArgumentVIntFieldInfo), '("vUint", ArgumentVUintFieldInfo), '("vLong", ArgumentVLongFieldInfo), '("vUlong", ArgumentVUlongFieldInfo), '("vSsize", ArgumentVSsizeFieldInfo), '("vSize", ArgumentVSizeFieldInfo), '("vString", ArgumentVStringFieldInfo), '("vPointer", ArgumentVPointerFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveArgumentMethod (t :: Symbol) (o :: *) :: * where + ResolveArgumentMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveArgumentMethod t Argument, O.MethodInfo info Argument p) => OL.IsLabel t (Argument -> 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/GIRepository/Unions/Argument.hs-boot b/GI/GIRepository/Unions/Argument.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GIRepository/Unions/Argument.hs-boot @@ -0,0 +1,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GIRepository.Unions.Argument 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 Argument = Argument (ManagedPtr Argument) +instance WrappedPtr Argument where diff --git a/LICENSE b/LICENSE --- a/LICENSE +++ b/LICENSE @@ -1,3 +1,17 @@ +The gi-girepository 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-girepository 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-girepository libraries, or to link their applications against a +user-supplied version of gi-girepository. If you link applications to a modified +version of gi-girepository, then the changes to gi-girepository 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-girepository-1.0.16/docs/GI-GIRepository.html](https://hackage.haskell.org/package/gi-girepository-1.0.16/docs/GI-GIRepository.html) +[https://hackage.haskell.org/package/gi-girepository-1.0.18/docs/GI-GIRepository.html](https://hackage.haskell.org/package/gi-girepository-1.0.18/docs/GI-GIRepository.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-girepository.cabal b/gi-girepository.cabal --- a/gi-girepository.cabal +++ b/gi-girepository.cabal @@ -1,12 +1,12 @@ name: gi-girepository -version: 1.0.16 +version: 1.0.18 synopsis: GIRepository (gobject-introspection) bindings description: Bindings for GIRepository, 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 @@ -14,20 +14,20 @@ extra-source-files: README.md ChangeLog.md stack.yaml GIRepository.overrides custom-setup - setup-depends: base >= 4.7 && < 5, + setup-depends: base >= 4.9 && < 5, Cabal >= 1.24, - haskell-gi >= 0.21.1 && < 0.22 + 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: gobject-introspection-1.0 build-depends: base >= 4.7 && <5, - haskell-gi-base == 0.21.*, - haskell-gi >= 0.21.1 && < 0.22, + haskell-gi-base >= 0.21.0 && < 0.23, + haskell-gi >= 0.21.0 && < 0.23, haskell-gi-overloading < 1.1, gi-glib == 2.0.*, gi-gobject == 2.0.*, @@ -40,3 +40,18 @@ -- see https://ghc.haskell.org/trac/ghc/ticket/14382 if impl(ghc == 8.2.*) build-depends: haskell-gi-overloading == 0.0 + + exposed-modules: GI.GIRepository, + GI.GIRepository.Constants, + GI.GIRepository.Enums, + GI.GIRepository.Flags, + GI.GIRepository.Functions, + GI.GIRepository.Objects, + GI.GIRepository.Objects.Repository, + GI.GIRepository.Structs, + GI.GIRepository.Structs.AttributeIter, + GI.GIRepository.Structs.BaseInfo, + GI.GIRepository.Structs.Typelib, + GI.GIRepository.Structs.UnresolvedInfo, + GI.GIRepository.Unions, + GI.GIRepository.Unions.Argument 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