Copyright	Will Thompson Iñaki García Etxebarria and Jonas Platte
License	LGPL-2.1
Maintainer	Iñaki García Etxebarria (inaki@blueleaf.cc)
Safe Haskell	None
Language	Haskell2010

GI.GIRepository.Functions

Contents

Methods

Description

Synopsis

argInfoGetClosure :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
argInfoGetDestroy :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
argInfoGetDirection :: (HasCallStack, MonadIO m) => BaseInfo -> m Direction
argInfoGetOwnershipTransfer :: (HasCallStack, MonadIO m) => BaseInfo -> m Transfer
argInfoGetScope :: (HasCallStack, MonadIO m) => BaseInfo -> m ScopeType
argInfoGetType :: (HasCallStack, MonadIO m) => BaseInfo -> m BaseInfo
argInfoIsCallerAllocates :: (HasCallStack, MonadIO m) => BaseInfo -> m Bool
argInfoIsOptional :: (HasCallStack, MonadIO m) => BaseInfo -> m Bool
argInfoIsReturnValue :: (HasCallStack, MonadIO m) => BaseInfo -> m Bool
argInfoIsSkip :: (HasCallStack, MonadIO m) => BaseInfo -> m Bool
argInfoLoadType :: (HasCallStack, MonadIO m) => BaseInfo -> m BaseInfo
argInfoMayBeNull :: (HasCallStack, MonadIO m) => BaseInfo -> m Bool
callableInfoCanThrowGerror :: (HasCallStack, MonadIO m) => BaseInfo -> m Bool
callableInfoGetArg :: (HasCallStack, MonadIO m) => BaseInfo -> Int32 -> m BaseInfo
callableInfoGetCallerOwns :: (HasCallStack, MonadIO m) => BaseInfo -> m Transfer
callableInfoGetInstanceOwnershipTransfer :: (HasCallStack, MonadIO m) => BaseInfo -> m Transfer
callableInfoGetNArgs :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
callableInfoGetReturnAttribute :: (HasCallStack, MonadIO m) => BaseInfo -> Text -> m Text
callableInfoGetReturnType :: (HasCallStack, MonadIO m) => BaseInfo -> m BaseInfo
callableInfoInvoke :: (HasCallStack, MonadIO m) => BaseInfo -> Ptr () -> [Argument] -> [Argument] -> Argument -> Bool -> Bool -> m ()
callableInfoIsMethod :: (HasCallStack, MonadIO m) => BaseInfo -> m Bool
callableInfoIterateReturnAttributes :: (HasCallStack, MonadIO m) => BaseInfo -> AttributeIter -> m (Bool, Text, Text)
callableInfoLoadArg :: (HasCallStack, MonadIO m) => BaseInfo -> Int32 -> m BaseInfo
callableInfoLoadReturnType :: (HasCallStack, MonadIO m) => BaseInfo -> m BaseInfo
callableInfoMayReturnNull :: (HasCallStack, MonadIO m) => BaseInfo -> m Bool
callableInfoSkipReturn :: (HasCallStack, MonadIO m) => BaseInfo -> m Bool
cclosureMarshalGeneric :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
constantInfoGetType :: (HasCallStack, MonadIO m) => BaseInfo -> m BaseInfo
enumInfoGetErrorDomain :: (HasCallStack, MonadIO m) => BaseInfo -> m Text
enumInfoGetMethod :: (HasCallStack, MonadIO m) => BaseInfo -> Int32 -> m BaseInfo
enumInfoGetNMethods :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
enumInfoGetNValues :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
enumInfoGetStorageType :: (HasCallStack, MonadIO m) => BaseInfo -> m TypeTag
enumInfoGetValue :: (HasCallStack, MonadIO m) => BaseInfo -> Int32 -> m BaseInfo
fieldInfoGetFlags :: (HasCallStack, MonadIO m) => BaseInfo -> m [FieldInfoFlags]
fieldInfoGetOffset :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
fieldInfoGetSize :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
fieldInfoGetType :: (HasCallStack, MonadIO m) => BaseInfo -> m BaseInfo
functionInfoGetFlags :: (HasCallStack, MonadIO m) => BaseInfo -> m [FunctionInfoFlags]
functionInfoGetProperty :: (HasCallStack, MonadIO m) => BaseInfo -> m BaseInfo
functionInfoGetSymbol :: (HasCallStack, MonadIO m) => BaseInfo -> m Text
functionInfoGetVfunc :: (HasCallStack, MonadIO m) => BaseInfo -> m BaseInfo
infoNew :: (HasCallStack, MonadIO m) => InfoType -> BaseInfo -> Typelib -> Word32 -> m BaseInfo
infoTypeToString :: (HasCallStack, MonadIO m) => InfoType -> m Text
interfaceInfoFindMethod :: (HasCallStack, MonadIO m) => BaseInfo -> Text -> m BaseInfo
interfaceInfoFindSignal :: (HasCallStack, MonadIO m) => BaseInfo -> Text -> m BaseInfo
interfaceInfoFindVfunc :: (HasCallStack, MonadIO m) => BaseInfo -> Text -> m BaseInfo
interfaceInfoGetConstant :: (HasCallStack, MonadIO m) => BaseInfo -> Int32 -> m BaseInfo
interfaceInfoGetIfaceStruct :: (HasCallStack, MonadIO m) => BaseInfo -> m BaseInfo
interfaceInfoGetMethod :: (HasCallStack, MonadIO m) => BaseInfo -> Int32 -> m BaseInfo
interfaceInfoGetNConstants :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
interfaceInfoGetNMethods :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
interfaceInfoGetNPrerequisites :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
interfaceInfoGetNProperties :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
interfaceInfoGetNSignals :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
interfaceInfoGetNVfuncs :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
interfaceInfoGetPrerequisite :: (HasCallStack, MonadIO m) => BaseInfo -> Int32 -> m BaseInfo
interfaceInfoGetProperty :: (HasCallStack, MonadIO m) => BaseInfo -> Int32 -> m BaseInfo
interfaceInfoGetSignal :: (HasCallStack, MonadIO m) => BaseInfo -> Int32 -> m BaseInfo
interfaceInfoGetVfunc :: (HasCallStack, MonadIO m) => BaseInfo -> Int32 -> m BaseInfo
invokeErrorQuark :: (HasCallStack, MonadIO m) => m Word32
objectInfoFindMethod :: (HasCallStack, MonadIO m) => BaseInfo -> Text -> m BaseInfo
objectInfoFindMethodUsingInterfaces :: (HasCallStack, MonadIO m) => BaseInfo -> Text -> m (BaseInfo, BaseInfo)
objectInfoFindSignal :: (HasCallStack, MonadIO m) => BaseInfo -> Text -> m BaseInfo
objectInfoFindVfunc :: (HasCallStack, MonadIO m) => BaseInfo -> Text -> m BaseInfo
objectInfoFindVfuncUsingInterfaces :: (HasCallStack, MonadIO m) => BaseInfo -> Text -> m (BaseInfo, BaseInfo)
objectInfoGetAbstract :: (HasCallStack, MonadIO m) => BaseInfo -> m Bool
objectInfoGetClassStruct :: (HasCallStack, MonadIO m) => BaseInfo -> m BaseInfo
objectInfoGetConstant :: (HasCallStack, MonadIO m) => BaseInfo -> Int32 -> m BaseInfo
objectInfoGetField :: (HasCallStack, MonadIO m) => BaseInfo -> Int32 -> m BaseInfo
objectInfoGetFundamental :: (HasCallStack, MonadIO m) => BaseInfo -> m Bool
objectInfoGetGetValueFunction :: (HasCallStack, MonadIO m) => BaseInfo -> m Text
objectInfoGetInterface :: (HasCallStack, MonadIO m) => BaseInfo -> Int32 -> m BaseInfo
objectInfoGetMethod :: (HasCallStack, MonadIO m) => BaseInfo -> Int32 -> m BaseInfo
objectInfoGetNConstants :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
objectInfoGetNFields :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
objectInfoGetNInterfaces :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
objectInfoGetNMethods :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
objectInfoGetNProperties :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
objectInfoGetNSignals :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
objectInfoGetNVfuncs :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
objectInfoGetParent :: (HasCallStack, MonadIO m) => BaseInfo -> m BaseInfo
objectInfoGetProperty :: (HasCallStack, MonadIO m) => BaseInfo -> Int32 -> m BaseInfo
objectInfoGetRefFunction :: (HasCallStack, MonadIO m) => BaseInfo -> m Text
objectInfoGetSetValueFunction :: (HasCallStack, MonadIO m) => BaseInfo -> m Text
objectInfoGetSignal :: (HasCallStack, MonadIO m) => BaseInfo -> Int32 -> m BaseInfo
objectInfoGetTypeInit :: (HasCallStack, MonadIO m) => BaseInfo -> m Text
objectInfoGetTypeName :: (HasCallStack, MonadIO m) => BaseInfo -> m Text
objectInfoGetUnrefFunction :: (HasCallStack, MonadIO m) => BaseInfo -> m Text
objectInfoGetVfunc :: (HasCallStack, MonadIO m) => BaseInfo -> Int32 -> m BaseInfo
propertyInfoGetFlags :: (HasCallStack, MonadIO m) => BaseInfo -> m [ParamFlags]
propertyInfoGetOwnershipTransfer :: (HasCallStack, MonadIO m) => BaseInfo -> m Transfer
propertyInfoGetType :: (HasCallStack, MonadIO m) => BaseInfo -> m BaseInfo
registeredTypeInfoGetGType :: (HasCallStack, MonadIO m) => BaseInfo -> m GType
registeredTypeInfoGetTypeInit :: (HasCallStack, MonadIO m) => BaseInfo -> m Text
registeredTypeInfoGetTypeName :: (HasCallStack, MonadIO m) => BaseInfo -> m Text
signalInfoGetClassClosure :: (HasCallStack, MonadIO m) => BaseInfo -> m BaseInfo
signalInfoGetFlags :: (HasCallStack, MonadIO m) => BaseInfo -> m [SignalFlags]
signalInfoTrueStopsEmit :: (HasCallStack, MonadIO m) => BaseInfo -> m Bool
structInfoFindField :: (HasCallStack, MonadIO m) => BaseInfo -> Text -> m BaseInfo
structInfoFindMethod :: (HasCallStack, MonadIO m) => BaseInfo -> Text -> m BaseInfo
structInfoGetAlignment :: (HasCallStack, MonadIO m) => BaseInfo -> m Word64
structInfoGetField :: (HasCallStack, MonadIO m) => BaseInfo -> Int32 -> m BaseInfo
structInfoGetMethod :: (HasCallStack, MonadIO m) => BaseInfo -> Int32 -> m BaseInfo
structInfoGetNFields :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
structInfoGetNMethods :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
structInfoGetSize :: (HasCallStack, MonadIO m) => BaseInfo -> m Word64
structInfoIsForeign :: (HasCallStack, MonadIO m) => BaseInfo -> m Bool
structInfoIsGtypeStruct :: (HasCallStack, MonadIO m) => BaseInfo -> m Bool
typeInfoGetArrayFixedSize :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
typeInfoGetArrayLength :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
typeInfoGetArrayType :: (HasCallStack, MonadIO m) => BaseInfo -> m ArrayType
typeInfoGetInterface :: (HasCallStack, MonadIO m) => BaseInfo -> m BaseInfo
typeInfoGetParamType :: (HasCallStack, MonadIO m) => BaseInfo -> Int32 -> m BaseInfo
typeInfoGetTag :: (HasCallStack, MonadIO m) => BaseInfo -> m TypeTag
typeInfoIsPointer :: (HasCallStack, MonadIO m) => BaseInfo -> m Bool
typeInfoIsZeroTerminated :: (HasCallStack, MonadIO m) => BaseInfo -> m Bool
typeTagToString :: (HasCallStack, MonadIO m) => TypeTag -> m Text
unionInfoFindMethod :: (HasCallStack, MonadIO m) => BaseInfo -> Text -> m BaseInfo
unionInfoGetAlignment :: (HasCallStack, MonadIO m) => BaseInfo -> m Word64
unionInfoGetDiscriminator :: (HasCallStack, MonadIO m) => BaseInfo -> Int32 -> m BaseInfo
unionInfoGetDiscriminatorOffset :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
unionInfoGetDiscriminatorType :: (HasCallStack, MonadIO m) => BaseInfo -> m BaseInfo
unionInfoGetField :: (HasCallStack, MonadIO m) => BaseInfo -> Int32 -> m BaseInfo
unionInfoGetMethod :: (HasCallStack, MonadIO m) => BaseInfo -> Int32 -> m BaseInfo
unionInfoGetNFields :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
unionInfoGetNMethods :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
unionInfoGetSize :: (HasCallStack, MonadIO m) => BaseInfo -> m Word64
unionInfoIsDiscriminated :: (HasCallStack, MonadIO m) => BaseInfo -> m Bool
valueInfoGetValue :: (HasCallStack, MonadIO m) => BaseInfo -> m Int64
vfuncInfoGetAddress :: (HasCallStack, MonadIO m) => BaseInfo -> GType -> m (Ptr ())
vfuncInfoGetFlags :: (HasCallStack, MonadIO m) => BaseInfo -> m [VFuncInfoFlags]
vfuncInfoGetInvoker :: (HasCallStack, MonadIO m) => BaseInfo -> m BaseInfo
vfuncInfoGetOffset :: (HasCallStack, MonadIO m) => BaseInfo -> m Int32
vfuncInfoGetSignal :: (HasCallStack, MonadIO m) => BaseInfo -> m BaseInfo

Methods

argInfoGetClosure

argInfoGetClosure Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIArgInfo`
-> m Int32	Returns: index of the user data argument or -1 if there is none

Obtain the index of the user data argument. This is only valid for arguments which are callbacks.

argInfoGetDestroy

argInfoGetDestroy Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIArgInfo`
-> m Int32	Returns: index of the `DestroyNotify` argument or -1 if there is none

Obtains the index of the DestroyNotify argument. This is only valid for arguments which are callbacks.

argInfoGetDirection

argInfoGetDirection Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIArgInfo`
-> m Direction	Returns: the direction

Obtain the direction of the argument. Check Direction for possible direction values.

argInfoGetOwnershipTransfer

argInfoGetOwnershipTransfer Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIArgInfo`
-> m Transfer	Returns: the transfer

Obtain the ownership transfer for this argument. Transfer contains a list of possible values.

argInfoGetScope

argInfoGetScope Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIArgInfo`
-> m ScopeType	Returns: the scope type

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. ScopeType contains a list of possible values.

argInfoGetType

argInfoGetType Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIArgInfo`
-> m BaseInfo	Returns: the `GITypeInfo` holding the type information for `info`, free it with `g_base_info_unref()` when done.

Obtain the type information for info.

argInfoIsCallerAllocates

argInfoIsCallerAllocates Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIArgInfo`
-> m Bool	Returns: `True` if caller is required to have allocated the argument

Obtain if the argument is a pointer to a struct or object that will receive an output of a function. The default assumption for DirectionOut arguments which have allocation is that the callee allocates; if this is True, then the caller must allocate.

argInfoIsOptional

argInfoIsOptional Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIArgInfo`
-> m Bool	Returns: `True` if it is an optional argument

Obtain if the argument is optional. For 'out' arguments this means that you can pass Nothing in order to ignore the result.

argInfoIsReturnValue

argInfoIsReturnValue Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIArgInfo`
-> m Bool	Returns: `True` if it is a return value

Obtain if the argument is a return value. It can either be a parameter or a return value.

argInfoIsSkip

argInfoIsSkip Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIArgInfo`
-> m Bool	Returns: `True` if argument is only useful in C.

Obtain if an argument is only useful in C.

Since: 1.30

argInfoLoadType

argInfoLoadType Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIArgInfo`
-> m BaseInfo

Obtain information about a the type of given argument info; this function is a variant of argInfoGetType designed for stack allocation.

The initialized type must not be referenced after info is deallocated.

argInfoMayBeNull

argInfoMayBeNull Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIArgInfo`
-> m Bool	Returns: `True` if the value may be `Nothing`

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.

callableInfoCanThrowGerror

callableInfoCanThrowGerror Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GICallableInfo`
-> m Bool	Returns: `True` if this `GICallableInfo` can throw a `GError`

TODO

Since: 1.34

callableInfoGetArg

callableInfoGetArg Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GICallableInfo`
-> Int32	`n`: the argument index to fetch
-> m BaseInfo	Returns: the `GIArgInfo`. Free it with `g_base_info_unref()` when done.

Obtain information about a particular argument of this callable.

callableInfoGetCallerOwns

callableInfoGetCallerOwns Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GICallableInfo`
-> m Transfer	Returns: the transfer mode for the return value of the callable

See whether the caller owns the return value of this callable. Transfer contains a list of possible transfer values.

callableInfoGetInstanceOwnershipTransfer

callableInfoGetInstanceOwnershipTransfer Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GICallableInfo`
-> m Transfer	Returns: the transfer mode of the instance argument

Obtains the ownership transfer for the instance argument. Transfer contains a list of possible transfer values.

Since: 1.42

callableInfoGetNArgs

callableInfoGetNArgs Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GICallableInfo`
-> m Int32	Returns: The number of arguments this callable expects.

Obtain the number of arguments (both IN and OUT) for this callable.

callableInfoGetReturnAttribute

callableInfoGetReturnAttribute Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GICallableInfo`
-> Text	`name`: a freeform string naming an attribute
-> m Text	Returns: The value of the attribute, or `Nothing` if no such attribute exists

Retrieve an arbitrary attribute associated with the return value.

callableInfoGetReturnType

callableInfoGetReturnType Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GICallableInfo`
-> m BaseInfo	Returns: the `GITypeInfo`. Free the struct by calling `g_base_info_unref()` when done.

Obtain the return type of a callable item as a GITypeInfo.

callableInfoInvoke

callableInfoInvoke Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: TODO
-> Ptr ()	`function`: TODO
-> [Argument]	`inArgs`: TODO
-> [Argument]	`outArgs`: TODO
-> Argument	`returnValue`: TODO
-> Bool	`isMethod`: TODO
-> Bool	`throws`: TODO
-> m ()	(Can throw `GError`)

TODO

callableInfoIsMethod

callableInfoIsMethod Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GICallableInfo`
-> m Bool	Returns: `True` if `info` is a method, `False` otherwise

Determines if the callable info is a method. For GIVFuncInfos, GICallbackInfos, and GISignalInfos, this is always true. Otherwise, this looks at the FunctionInfoFlagsIsMethod flag on the GIFunctionInfo.

Concretely, this function returns whether 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

callableInfoIterateReturnAttributes

callableInfoIterateReturnAttributes Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GICallableInfo`
-> AttributeIter	`iterator`: a `AttributeIter` structure, must be initialized; see below
-> m (Bool, Text, Text)	Returns: `True` if there are more attributes

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 baseInfoIterateAttributes for an example of how to use a similar API.

callableInfoLoadArg

callableInfoLoadArg Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GICallableInfo`
-> Int32	`n`: the argument index to fetch
-> m BaseInfo

Obtain information about a particular argument of this callable; this function is a variant of callableInfoGetArg designed for stack allocation.

The initialized arg must not be referenced after info is deallocated.

callableInfoLoadReturnType

callableInfoLoadReturnType Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GICallableInfo`
-> m BaseInfo

Obtain information about a return value of callable; this function is a variant of callableInfoGetReturnType designed for stack allocation.

The initialized type must not be referenced after info is deallocated.

callableInfoMayReturnNull

callableInfoMayReturnNull Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GICallableInfo`
-> m Bool	Returns: `True` if callable could return `Nothing`

See if a callable could return Nothing.

callableInfoSkipReturn

callableInfoSkipReturn Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GICallableInfo`
-> m Bool	Returns: `True` if return value is only useful in C.

See if a callable's return value is only useful in C.

cclosureMarshalGeneric

cclosureMarshalGeneric :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m () Source #

No description available in the introspection data.

constantInfoGetType

constantInfoGetType Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIConstantInfo`
-> m BaseInfo	Returns: the `GITypeInfo`. Free the struct by calling `g_base_info_unref()` when done.

Obtain the type of the constant as a GITypeInfo.

enumInfoGetErrorDomain

enumInfoGetErrorDomain Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIEnumInfo`
-> m Text	Returns: the string form of the error domain associated with this enum, or `Nothing`.

Obtain the string form of the quark for the error domain associated with this enum, if any.

Since: 1.30

enumInfoGetMethod

enumInfoGetMethod Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIEnumInfo`
-> Int32	`n`: index of method to get
-> m BaseInfo	Returns: the `GIFunctionInfo`. Free the struct by calling `g_base_info_unref()` when done.

Obtain an enum type method at index n.

Since: 1.30

enumInfoGetNMethods

enumInfoGetNMethods Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIEnumInfo`
-> m Int32	Returns: number of methods

Obtain the number of methods that this enum type has.

Since: 1.30

enumInfoGetNValues

enumInfoGetNValues Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIEnumInfo`
-> m Int32	Returns: the number of enumeration values

Obtain the number of values this enumeration contains.

enumInfoGetStorageType

enumInfoGetStorageType Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIEnumInfo`
-> m TypeTag	Returns: the storage type for the enumeration

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.

enumInfoGetValue

enumInfoGetValue Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIEnumInfo`
-> Int32	`n`: index of value to fetch
-> m BaseInfo	Returns: the enumeration value or `Nothing` if type tag is wrong, free the struct with `g_base_info_unref()` when done.

Obtain a value for this enumeration.

fieldInfoGetFlags

fieldInfoGetFlags Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIFieldInfo`
-> m [FieldInfoFlags]	Returns: the flags

Obtain the flags for this GIFieldInfo. See FieldInfoFlags for possible flag values.

fieldInfoGetOffset

fieldInfoGetOffset Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIFieldInfo`
-> m Int32	Returns: the field offset

Obtain the offset in bytes of the field member, this is relative to the beginning of the struct or union.

fieldInfoGetSize

fieldInfoGetSize Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIFieldInfo`
-> m Int32	Returns: the field size

Obtain the size in bits of the field member, this is how much space you need to allocate to store the field.

fieldInfoGetType

fieldInfoGetType Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIFieldInfo`
-> m BaseInfo	Returns: the `GITypeInfo`. Free the struct by calling `g_base_info_unref()` when done.

Obtain the type of a field as a GITypeInfo.

functionInfoGetFlags

functionInfoGetFlags Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIFunctionInfo`
-> m [FunctionInfoFlags]	Returns: the flags

Obtain the FunctionInfoFlags for the info.

functionInfoGetProperty

functionInfoGetProperty Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIFunctionInfo`
-> m BaseInfo	Returns: the property or `Nothing` if not set. Free it with `g_base_info_unref()` when done.

Obtain the property associated with this GIFunctionInfo. Only GIFunctionInfo with the flag FunctionInfoFlagsIsGetter or FunctionInfoFlagsIsSetter have a property set. For other cases, Nothing will be returned.

functionInfoGetSymbol

functionInfoGetSymbol Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIFunctionInfo`
-> m Text	Returns: the symbol

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().

functionInfoGetVfunc

functionInfoGetVfunc Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIFunctionInfo`
-> m BaseInfo	Returns: the virtual function or `Nothing` if not set. Free it by calling `g_base_info_unref()` when done.

Obtain the virtual function associated with this GIFunctionInfo. Only GIFunctionInfo with the flag FunctionInfoFlagsWrapsVfunc has a virtual function set. For other cases, Nothing will be returned.

infoNew

infoNew Source #

Arguments

:: (HasCallStack, MonadIO m)
=> InfoType	`type`: TODO
-> BaseInfo	`container`: TODO
-> Typelib	`typelib`: TODO
-> Word32	`offset`: TODO
-> m BaseInfo	Returns: TODO

TODO

infoTypeToString

infoTypeToString Source #

Arguments

:: (HasCallStack, MonadIO m)
=> InfoType	`type`: the info type
-> m Text	Returns: the string

Obtain a string representation of type

interfaceInfoFindMethod

interfaceInfoFindMethod Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIInterfaceInfo`
-> Text	`name`: name of method to obtain
-> m BaseInfo	Returns: the `GIFunctionInfo` or `Nothing` if none found. Free the struct by calling `g_base_info_unref()` when done.

Obtain a method of the interface type given a name. Nothing will be returned if there's no method available with that name.

interfaceInfoFindSignal

interfaceInfoFindSignal Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIInterfaceInfo`
-> Text	`name`: Name of signal
-> m BaseInfo	Returns: Info for the signal with name `name` in `info`, or `Nothing` on failure.

TODO

Since: 1.34

interfaceInfoFindVfunc

interfaceInfoFindVfunc Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIInterfaceInfo`
-> Text	`name`: The name of a virtual function to find.
-> m BaseInfo	Returns: the `GIVFuncInfo`, or `Nothing`. Free it with `g_base_info_unref()` when done.

Locate a virtual function slot with name name. See the documentation for objectInfoFindVfunc for more information on virtuals.

interfaceInfoGetConstant

interfaceInfoGetConstant Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIInterfaceInfo`
-> Int32	`n`: index of constant to get
-> m BaseInfo	Returns: the `GIConstantInfo`. Free the struct by calling `g_base_info_unref()` when done.

Obtain an interface type constant at index n.

interfaceInfoGetIfaceStruct

interfaceInfoGetIfaceStruct Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIInterfaceInfo`
-> m BaseInfo	Returns: the `GIStructInfo` or `Nothing`. Free it with `g_base_info_unref()` when done.

Returns the layout C structure associated with this GInterface.

interfaceInfoGetMethod

interfaceInfoGetMethod Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIInterfaceInfo`
-> Int32	`n`: index of method to get
-> m BaseInfo	Returns: the `GIFunctionInfo`. Free the struct by calling `g_base_info_unref()` when done.

Obtain an interface type method at index n.

interfaceInfoGetNConstants

interfaceInfoGetNConstants Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIInterfaceInfo`
-> m Int32	Returns: number of constants

Obtain the number of constants that this interface type has.

interfaceInfoGetNMethods

interfaceInfoGetNMethods Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIInterfaceInfo`
-> m Int32	Returns: number of methods

Obtain the number of methods that this interface type has.

interfaceInfoGetNPrerequisites

interfaceInfoGetNPrerequisites Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIInterfaceInfo`
-> m Int32	Returns: number of prerequisites

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.

interfaceInfoGetNProperties

interfaceInfoGetNProperties Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIInterfaceInfo`
-> m Int32	Returns: number of properties

Obtain the number of properties that this interface type has.

interfaceInfoGetNSignals

interfaceInfoGetNSignals Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIInterfaceInfo`
-> m Int32	Returns: number of signals

Obtain the number of signals that this interface type has.

interfaceInfoGetNVfuncs

interfaceInfoGetNVfuncs Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIInterfaceInfo`
-> m Int32	Returns: number of virtual functions

Obtain the number of virtual functions that this interface type has.

interfaceInfoGetPrerequisite

interfaceInfoGetPrerequisite Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIInterfaceInfo`
-> Int32	`n`: index of prerequisites to get
-> m BaseInfo	Returns: the prerequisites as a `BaseInfo`. Free the struct by calling `g_base_info_unref()` when done.

Obtain an interface type prerequisites index n.

interfaceInfoGetProperty

interfaceInfoGetProperty Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIInterfaceInfo`
-> Int32	`n`: index of property to get
-> m BaseInfo	Returns: the `GIPropertyInfo`. Free the struct by calling `g_base_info_unref()` when done.

Obtain an interface type property at index n.

interfaceInfoGetSignal

interfaceInfoGetSignal Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIInterfaceInfo`
-> Int32	`n`: index of signal to get
-> m BaseInfo	Returns: the `GISignalInfo`. Free the struct by calling `g_base_info_unref()` when done.

Obtain an interface type signal at index n.

interfaceInfoGetVfunc

interfaceInfoGetVfunc Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIInterfaceInfo`
-> Int32	`n`: index of virtual function to get
-> m BaseInfo	Returns: the `GIVFuncInfo`. Free the struct by calling `g_base_info_unref()` when done.

Obtain an interface type virtual function at index n.

invokeErrorQuark

invokeErrorQuark Source #

Arguments

:: (HasCallStack, MonadIO m)
=> m Word32	Returns: TODO

TODO

objectInfoFindMethod

objectInfoFindMethod Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> Text	`name`: name of method to obtain
-> m BaseInfo	Returns: the `GIFunctionInfo`. Free the struct by calling `g_base_info_unref()` when done.

Obtain a method of the object type given a name. Nothing will be returned if there's no method available with that name.

objectInfoFindMethodUsingInterfaces

objectInfoFindMethodUsingInterfaces Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> Text	`name`: name of method to obtain
-> m (BaseInfo, BaseInfo)	Returns: the `GIFunctionInfo`. Free the struct by calling `g_base_info_unref()` when done.

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.

objectInfoFindSignal

objectInfoFindSignal Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> Text	`name`: Name of signal
-> m BaseInfo	Returns: Info for the signal with name `name` in `info`, or `Nothing` on failure.

TODO

objectInfoFindVfunc

objectInfoFindVfunc Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> Text	`name`: The name of a virtual function to find.
-> m BaseInfo	Returns: the `GIVFuncInfo`, or `Nothing`. Free it with `g_base_info_unref()` when done.

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 vfuncInfoGetInvoker, otherwise Nothing will be returned. See the documentation for vfuncInfoGetInvoker for more information on invoking virtuals.

objectInfoFindVfuncUsingInterfaces

objectInfoFindVfuncUsingInterfaces Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> Text	`name`: name of vfunc to obtain
-> m (BaseInfo, BaseInfo)	Returns: the `GIVFuncInfo`. Free the struct by calling `g_base_info_unref()` when done.

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 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.

objectInfoGetAbstract

objectInfoGetAbstract Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> m Bool	Returns: `True` if the object type is abstract

Obtain if the object type is an abstract type, eg if it cannot be instantiated

objectInfoGetClassStruct

objectInfoGetClassStruct Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> m BaseInfo	Returns: the `GIStructInfo` or `Nothing`. Free with `g_base_info_unref()` when done.

Every Object has two structures; an instance structure and a class structure. This function returns the metadata for the class structure.

objectInfoGetConstant

objectInfoGetConstant Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> Int32	`n`: index of constant to get
-> m BaseInfo	Returns: the `GIConstantInfo`. Free the struct by calling `g_base_info_unref()` when done.

Obtain an object type constant at index n.

objectInfoGetField

objectInfoGetField Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> Int32	`n`: index of field to get
-> m BaseInfo	Returns: the `GIFieldInfo`. Free the struct by calling `g_base_info_unref()` when done.

Obtain an object type field at index n.

objectInfoGetFundamental

objectInfoGetFundamental Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> m Bool	Returns: `True` if the object type is a fundamental type

Obtain if the object type is of a fundamental type which is not G_TYPE_OBJECT. This is mostly for supporting GstMiniObject.

objectInfoGetGetValueFunction

objectInfoGetGetValueFunction Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> m Text	Returns: the symbol or `Nothing`

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 objectInfoGetGetValueFunction.

objectInfoGetInterface

objectInfoGetInterface Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> Int32	`n`: index of interface to get
-> m BaseInfo	Returns: the `GIInterfaceInfo`. Free the struct by calling `g_base_info_unref()` when done.

Obtain an object type interface at index n.

objectInfoGetMethod

objectInfoGetMethod Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> Int32	`n`: index of method to get
-> m BaseInfo	Returns: the `GIFunctionInfo`. Free the struct by calling `g_base_info_unref()` when done.

Obtain an object type method at index n.

objectInfoGetNConstants

objectInfoGetNConstants Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> m Int32	Returns: number of constants

Obtain the number of constants that this object type has.

objectInfoGetNFields

objectInfoGetNFields Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> m Int32	Returns: number of fields

Obtain the number of fields that this object type has.

objectInfoGetNInterfaces

objectInfoGetNInterfaces Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> m Int32	Returns: number of interfaces

Obtain the number of interfaces that this object type has.

objectInfoGetNMethods

objectInfoGetNMethods Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> m Int32	Returns: number of methods

Obtain the number of methods that this object type has.

objectInfoGetNProperties

objectInfoGetNProperties Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> m Int32	Returns: number of properties

Obtain the number of properties that this object type has.

objectInfoGetNSignals

objectInfoGetNSignals Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> m Int32	Returns: number of signals

Obtain the number of signals that this object type has.

objectInfoGetNVfuncs

objectInfoGetNVfuncs Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> m Int32	Returns: number of virtual functions

Obtain the number of virtual functions that this object type has.

objectInfoGetParent

objectInfoGetParent Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> m BaseInfo	Returns: the `GIObjectInfo`. Free the struct by calling `g_base_info_unref()` when done.

Obtain the parent of the object type.

objectInfoGetProperty

objectInfoGetProperty Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> Int32	`n`: index of property to get
-> m BaseInfo	Returns: the `GIPropertyInfo`. Free the struct by calling `g_base_info_unref()` when done.

Obtain an object type property at index n.

objectInfoGetRefFunction

objectInfoGetRefFunction Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> m Text	Returns: the symbol or `Nothing`

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 objectInfoGetRefFunction.

objectInfoGetSetValueFunction

objectInfoGetSetValueFunction Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> m Text	Returns: the symbol or `Nothing`

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 objectInfoGetSetValueFunction.

objectInfoGetSignal

objectInfoGetSignal Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> Int32	`n`: index of signal to get
-> m BaseInfo	Returns: the `GISignalInfo`. Free the struct by calling `g_base_info_unref()` when done.

Obtain an object type signal at index n.

objectInfoGetTypeInit

objectInfoGetTypeInit Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> m Text	Returns: the type init function

Obtain the function which when called will return the GType function for which this object type is registered.

objectInfoGetTypeName

objectInfoGetTypeName Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> m Text	Returns: name of the objects type

Obtain the name of the objects class/type.

objectInfoGetUnrefFunction

objectInfoGetUnrefFunction Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> m Text	Returns: the symbol or `Nothing`

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 objectInfoGetUnrefFunction.

objectInfoGetVfunc

objectInfoGetVfunc Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIObjectInfo`
-> Int32	`n`: index of virtual function to get
-> m BaseInfo	Returns: the `GIVFuncInfo`. Free the struct by calling `g_base_info_unref()` when done.

Obtain an object type virtual function at index n.

propertyInfoGetFlags

propertyInfoGetFlags Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIPropertyInfo`
-> m [ParamFlags]	Returns: the flags

Obtain the flags for this property info. See ParamFlags for more information about possible flag values.

propertyInfoGetOwnershipTransfer

propertyInfoGetOwnershipTransfer Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIPropertyInfo`
-> m Transfer	Returns: the transfer

Obtain the ownership transfer for this property. See Transfer for more information about transfer values.

propertyInfoGetType

propertyInfoGetType Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIPropertyInfo`
-> m BaseInfo	Returns: the `GITypeInfo`, free it with `g_base_info_unref()` when done.

Obtain the type information for the property info.

registeredTypeInfoGetGType

registeredTypeInfoGetGType Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIRegisteredTypeInfo`
-> m GType	Returns: the `GType`.

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.

registeredTypeInfoGetTypeInit

registeredTypeInfoGetTypeInit Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIRegisteredTypeInfo`
-> m Text	Returns: the symbol name of the type init function, suitable for passing into `g_module_symbol()`.

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 registeredTypeInfoGetGType directly instead.

registeredTypeInfoGetTypeName

registeredTypeInfoGetTypeName Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIRegisteredTypeInfo`
-> m Text	Returns: the type name

Obtain the type name of the struct within the GObject type system. This type can be passed to typeName to get a GType.

signalInfoGetClassClosure

signalInfoGetClassClosure Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GISignalInfo`
-> m BaseInfo	Returns: the class closure or `Nothing`

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.

signalInfoGetFlags

signalInfoGetFlags Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GISignalInfo`
-> m [SignalFlags]	Returns: the flags

Obtain the flags for this signal info. See SignalFlags for more information about possible flag values.

signalInfoTrueStopsEmit

signalInfoTrueStopsEmit Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GISignalInfo`
-> m Bool	Returns: `True` if returning true stops the signal emission

Obtain if the returning true in the signal handler will stop the emission of the signal.

structInfoFindField

structInfoFindField Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIStructInfo`
-> Text	`name`: a field name
-> m BaseInfo	Returns: the `GIFieldInfo` or `Nothing` if not found, free it with `g_base_info_unref()` when done.

Obtain the type information for field named name.

Since: 1.46

structInfoFindMethod

structInfoFindMethod Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIStructInfo`
-> Text	`name`: a method name
-> m BaseInfo	Returns: the `GIFunctionInfo`, free it with `g_base_info_unref()` when done.

Obtain the type information for method named name.

structInfoGetAlignment

structInfoGetAlignment Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIStructInfo`
-> m Word64	Returns: required alignment in bytes

Obtain the required alignment of the structure.

structInfoGetField

structInfoGetField Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIStructInfo`
-> Int32	`n`: a field index
-> m BaseInfo	Returns: the `GIFieldInfo`, free it with `g_base_info_unref()` when done.

Obtain the type information for field with specified index.

structInfoGetMethod

structInfoGetMethod Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIStructInfo`
-> Int32	`n`: a method index
-> m BaseInfo	Returns: the `GIFunctionInfo`, free it with `g_base_info_unref()` when done.

Obtain the type information for method with specified index.

structInfoGetNFields

structInfoGetNFields Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIStructInfo`
-> m Int32	Returns: number of fields

Obtain the number of fields this structure has.

structInfoGetNMethods

structInfoGetNMethods Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIStructInfo`
-> m Int32	Returns: number of methods

Obtain the number of methods this structure has.

structInfoGetSize

structInfoGetSize Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIStructInfo`
-> m Word64	Returns: size of the structure in bytes

Obtain the total size of the structure.

structInfoIsForeign

structInfoIsForeign Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: TODO
-> m Bool	Returns: TODO

TODO

structInfoIsGtypeStruct

structInfoIsGtypeStruct Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIStructInfo`
-> m Bool	Returns: `True` if this is a class struct, `False` otherwise

Return true if this structure represents the "class structure" for some Object or GInterface. This function is mainly useful to hide this kind of structure from generated public APIs.

typeInfoGetArrayFixedSize

typeInfoGetArrayFixedSize Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GITypeInfo`
-> m Int32	Returns: the size or -1 if it's not an array

Obtain the fixed array size of the type. The type tag must be a GI_TYPE_TAG_ARRAY or -1 will returned.

typeInfoGetArrayLength

typeInfoGetArrayLength Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GITypeInfo`
-> m Int32	Returns: the array length, or -1 if the type is not an array

Obtain the array length of the type. The type tag must be a GI_TYPE_TAG_ARRAY or -1 will returned.

typeInfoGetArrayType

typeInfoGetArrayType Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GITypeInfo`
-> m ArrayType	Returns: the array type or -1

Obtain the array type for this type. See ArrayType for a list of possible values. If the type tag of this type is not array, -1 will be returned.

typeInfoGetInterface

typeInfoGetInterface Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GITypeInfo`
-> m BaseInfo	Returns: the `BaseInfo`, or `Nothing`. Free it with `g_base_info_unref()` when done.

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 BaseInfo to further query whether it is a concrete GObject, a GInterface, a structure, etc. using baseInfoGetType.

typeInfoGetParamType

typeInfoGetParamType Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GITypeInfo`
-> Int32	`n`: index of the parameter
-> m BaseInfo	Returns: the param type info

Obtain the parameter type n.

typeInfoGetTag

typeInfoGetTag Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GITypeInfo`
-> m TypeTag	Returns: the type tag

Obtain the type tag for the type. See TypeTag for a list of type tags.

typeInfoIsPointer

typeInfoIsPointer Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GITypeInfo`
-> m Bool	Returns: `True` if it is a pointer

Obtain if the type is passed as a reference.

Note that the types of DirectionOut and 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).

typeInfoIsZeroTerminated

typeInfoIsZeroTerminated Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GITypeInfo`
-> m Bool	Returns: `True` if zero terminated

Obtain if the last element of the array is Nothing. The type tag must be a GI_TYPE_TAG_ARRAY or False will returned.

typeTagToString

typeTagToString Source #

Arguments

:: (HasCallStack, MonadIO m)
=> TypeTag	`type`: the type_tag
-> m Text	Returns: the string

Obtain a string representation of type

unionInfoFindMethod

unionInfoFindMethod Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIUnionInfo`
-> Text	`name`: a method name
-> m BaseInfo	Returns: the `GIFunctionInfo`, free it with `g_base_info_unref()` when done.

Obtain the type information for method named name.

unionInfoGetAlignment

unionInfoGetAlignment Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIUnionInfo`
-> m Word64	Returns: required alignment in bytes

Obtain the required alignment of the union.

unionInfoGetDiscriminator

unionInfoGetDiscriminator Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIUnionInfo`
-> Int32	`n`: a union field index
-> m BaseInfo	Returns: the `GIConstantInfo`, free it with `g_base_info_unref()` when done.

Obtain discriminator value assigned for n-th union field, i.e. n-th union field is the active one if discriminator contains this constant.

unionInfoGetDiscriminatorOffset

unionInfoGetDiscriminatorOffset Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIUnionInfo`
-> m Int32	Returns: offset in bytes of the discriminator

Returns offset of the discriminator field in the structure.

unionInfoGetDiscriminatorType

unionInfoGetDiscriminatorType Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIUnionInfo`
-> m BaseInfo	Returns: the `GITypeInfo`, free it with `g_base_info_unref()` when done.

Obtain the type information of the union discriminator.

unionInfoGetField

unionInfoGetField Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIUnionInfo`
-> Int32	`n`: a field index
-> m BaseInfo	Returns: the `GIFieldInfo`, free it with `g_base_info_unref()` when done.

Obtain the type information for field with specified index.

unionInfoGetMethod

unionInfoGetMethod Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIUnionInfo`
-> Int32	`n`: a method index
-> m BaseInfo	Returns: the `GIFunctionInfo`, free it with `g_base_info_unref()` when done.

Obtain the type information for method with specified index.

unionInfoGetNFields

unionInfoGetNFields Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIUnionInfo`
-> m Int32	Returns: number of fields

Obtain the number of fields this union has.

unionInfoGetNMethods

unionInfoGetNMethods Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIUnionInfo`
-> m Int32	Returns: number of methods

Obtain the number of methods this union has.

unionInfoGetSize

unionInfoGetSize Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIUnionInfo`
-> m Word64	Returns: size of the union in bytes

Obtain the total size of the union.

unionInfoIsDiscriminated

unionInfoIsDiscriminated Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIUnionInfo`
-> m Bool	Returns: `True` if this is a discriminated union, `False` otherwise

Return true if this union contains discriminator field.

valueInfoGetValue

valueInfoGetValue Source #

Arguments

:: (HasCallStack, MonadIO m)
=> 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.

Obtain the enumeration value of the GIValueInfo.

vfuncInfoGetAddress

vfuncInfoGetAddress Source #

Arguments

:: (HasCallStack, MonadIO m)
=> 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 `GError`)

This method will look up where inside the type struct of implementorGtype is the implementation for info.

vfuncInfoGetFlags

vfuncInfoGetFlags Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIVFuncInfo`
-> m [VFuncInfoFlags]	Returns: the flags

Obtain the flags for this virtual function info. See VFuncInfoFlags for more information about possible flag values.

vfuncInfoGetInvoker

vfuncInfoGetInvoker Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIVFuncInfo`
-> m BaseInfo	Returns: the `GIVFuncInfo` or `Nothing`. Free it with `g_base_info_unref()` when done.

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.

vfuncInfoGetOffset

vfuncInfoGetOffset Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIVFuncInfo`
-> m Int32	Returns: the struct offset or 0xFFFF if it's unknown

Obtain the offset of the function pointer in the class struct. The value 0xFFFF indicates that the struct offset is unknown.

vfuncInfoGetSignal

vfuncInfoGetSignal Source #

Arguments

:: (HasCallStack, MonadIO m)
=> BaseInfo	`info`: a `GIVFuncInfo`
-> m BaseInfo	Returns: the signal or `Nothing` if none set

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.