GI.GObject.Callbacks

Signals

BaseFinalizeFunc

type BaseFinalizeFunc = TypeClass -> IO ()

type C_BaseFinalizeFunc = Ptr TypeClass -> IO ()

dynamic_BaseFinalizeFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_BaseFinalizeFunc

-> TypeClass

gClass: The TypeClass structure to finalize

-> m ()

genClosure_BaseFinalizeFunc :: BaseFinalizeFunc -> IO Closure

mk_BaseFinalizeFunc :: C_BaseFinalizeFunc -> IO (FunPtr C_BaseFinalizeFunc)

noBaseFinalizeFunc :: Maybe BaseFinalizeFunc

wrap_BaseFinalizeFunc :: Maybe (Ptr (FunPtr C_BaseFinalizeFunc)) -> BaseFinalizeFunc -> Ptr TypeClass -> IO ()

BaseInitFunc

type BaseInitFunc = TypeClass -> IO ()

type C_BaseInitFunc = Ptr TypeClass -> IO ()

dynamic_BaseInitFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_BaseInitFunc

-> TypeClass

gClass: The TypeClass structure to initialize

-> m ()

genClosure_BaseInitFunc :: BaseInitFunc -> IO Closure

mk_BaseInitFunc :: C_BaseInitFunc -> IO (FunPtr C_BaseInitFunc)

noBaseInitFunc :: Maybe BaseInitFunc

wrap_BaseInitFunc :: Maybe (Ptr (FunPtr C_BaseInitFunc)) -> BaseInitFunc -> Ptr TypeClass -> IO ()

BindingTransformFunc

type BindingTransformFunc = Binding -> GValue -> GValue -> IO Bool

type BindingTransformFunc_WithClosures = Binding -> GValue -> GValue -> Ptr () -> IO Bool

type C_BindingTransformFunc = Ptr Binding -> Ptr GValue -> Ptr GValue -> Ptr () -> IO CInt

drop_closures_BindingTransformFunc :: BindingTransformFunc -> BindingTransformFunc_WithClosures

dynamic_BindingTransformFunc

Arguments

:: (HasCallStack, MonadIO m, IsBinding a)

=> FunPtr C_BindingTransformFunc

-> a

binding: a Binding

-> GValue

fromValue: the Value containing the value to transform

-> GValue

toValue: the Value in which to store the transformed value

-> Ptr ()

userData: data passed to the transform function

-> m Bool

Returns: True if the transformation was successful, and False otherwise

genClosure_BindingTransformFunc :: BindingTransformFunc -> IO Closure

mk_BindingTransformFunc :: C_BindingTransformFunc -> IO (FunPtr C_BindingTransformFunc)

noBindingTransformFunc :: Maybe BindingTransformFunc

noBindingTransformFunc_WithClosures :: Maybe BindingTransformFunc_WithClosures

wrap_BindingTransformFunc :: Maybe (Ptr (FunPtr C_BindingTransformFunc)) -> BindingTransformFunc_WithClosures -> Ptr Binding -> Ptr GValue -> Ptr GValue -> Ptr () -> IO CInt

BoxedCopyFunc

type BoxedCopyFunc = Ptr () -> IO (Ptr ())

type C_BoxedCopyFunc = Ptr () -> IO (Ptr ())

dynamic_BoxedCopyFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_BoxedCopyFunc

-> Ptr ()

boxed: The boxed structure to be copied.

-> m (Ptr ())

Returns: The newly created copy of the boxed structure.

genClosure_BoxedCopyFunc :: BoxedCopyFunc -> IO Closure

mk_BoxedCopyFunc :: C_BoxedCopyFunc -> IO (FunPtr C_BoxedCopyFunc)

noBoxedCopyFunc :: Maybe BoxedCopyFunc

wrap_BoxedCopyFunc :: Maybe (Ptr (FunPtr C_BoxedCopyFunc)) -> BoxedCopyFunc -> Ptr () -> IO (Ptr ())

BoxedFreeFunc

type BoxedFreeFunc = Ptr () -> IO ()

type C_BoxedFreeFunc = Ptr () -> IO ()

dynamic_BoxedFreeFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_BoxedFreeFunc

-> Ptr ()

boxed: The boxed structure to be freed.

-> m ()

genClosure_BoxedFreeFunc :: BoxedFreeFunc -> IO Closure

mk_BoxedFreeFunc :: C_BoxedFreeFunc -> IO (FunPtr C_BoxedFreeFunc)

noBoxedFreeFunc :: Maybe BoxedFreeFunc

wrap_BoxedFreeFunc :: Maybe (Ptr (FunPtr C_BoxedFreeFunc)) -> BoxedFreeFunc -> Ptr () -> IO ()

Callback

type C_Callback = IO ()

type Callback = IO ()

dynamic_Callback :: (HasCallStack, MonadIO m) => FunPtr C_Callback -> m ()

genClosure_Callback :: Callback -> IO Closure

mk_Callback :: C_Callback -> IO (FunPtr C_Callback)

noCallback :: Maybe Callback

wrap_Callback :: Maybe (Ptr (FunPtr C_Callback)) -> Callback -> IO ()

ClassFinalizeFunc

type C_ClassFinalizeFunc = Ptr TypeClass -> Ptr () -> IO ()

type ClassFinalizeFunc = TypeClass -> Ptr () -> IO ()

dynamic_ClassFinalizeFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_ClassFinalizeFunc

-> TypeClass

gClass: The TypeClass structure to finalize

-> Ptr ()

classData: The classData member supplied via the TypeInfo structure

-> m ()

genClosure_ClassFinalizeFunc :: ClassFinalizeFunc -> IO Closure

mk_ClassFinalizeFunc :: C_ClassFinalizeFunc -> IO (FunPtr C_ClassFinalizeFunc)

noClassFinalizeFunc :: Maybe ClassFinalizeFunc

wrap_ClassFinalizeFunc :: Maybe (Ptr (FunPtr C_ClassFinalizeFunc)) -> ClassFinalizeFunc -> Ptr TypeClass -> Ptr () -> IO ()

ClassInitFunc

type C_ClassInitFunc = Ptr TypeClass -> Ptr () -> IO ()

type ClassInitFunc = TypeClass -> Ptr () -> IO ()

dynamic_ClassInitFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_ClassInitFunc

-> TypeClass

gClass: The TypeClass structure to initialize.

-> Ptr ()

classData: The classData member supplied via the TypeInfo structure.

-> m ()

genClosure_ClassInitFunc :: ClassInitFunc -> IO Closure

mk_ClassInitFunc :: C_ClassInitFunc -> IO (FunPtr C_ClassInitFunc)

noClassInitFunc :: Maybe ClassInitFunc

wrap_ClassInitFunc :: Maybe (Ptr (FunPtr C_ClassInitFunc)) -> ClassInitFunc -> Ptr TypeClass -> Ptr () -> IO ()

ClosureMarshalFieldCallback

type C_ClosureMarshalFieldCallback = Ptr Closure -> Ptr GValue -> Word32 -> Ptr GValue -> Ptr () -> Ptr () -> IO ()

type ClosureMarshalFieldCallback = Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> IO ()

dynamic_ClosureMarshalFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ClosureMarshalFieldCallback -> Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

genClosure_ClosureMarshalFieldCallback :: ClosureMarshalFieldCallback -> IO Closure

mk_ClosureMarshalFieldCallback :: C_ClosureMarshalFieldCallback -> IO (FunPtr C_ClosureMarshalFieldCallback)

noClosureMarshalFieldCallback :: Maybe ClosureMarshalFieldCallback

wrap_ClosureMarshalFieldCallback :: Maybe (Ptr (FunPtr C_ClosureMarshalFieldCallback)) -> ClosureMarshalFieldCallback -> Ptr Closure -> Ptr GValue -> Word32 -> Ptr GValue -> Ptr () -> Ptr () -> IO ()

ClosureNotify

type C_ClosureNotify = Ptr () -> Ptr Closure -> IO ()

type ClosureNotify = Ptr () -> Closure -> IO ()

dynamic_ClosureNotify

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_ClosureNotify

-> Ptr ()

data: data specified when registering the notification callback

-> Closure

closure: the Closure on which the notification is emitted

-> m ()

genClosure_ClosureNotify :: ClosureNotify -> IO Closure

mk_ClosureNotify :: C_ClosureNotify -> IO (FunPtr C_ClosureNotify)

noClosureNotify :: Maybe ClosureNotify

wrap_ClosureNotify :: Maybe (Ptr (FunPtr C_ClosureNotify)) -> ClosureNotify -> Ptr () -> Ptr Closure -> IO ()

InstanceInitFunc

type C_InstanceInitFunc = Ptr TypeInstance -> Ptr TypeClass -> IO ()

type InstanceInitFunc = TypeInstance -> TypeClass -> IO ()

dynamic_InstanceInitFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_InstanceInitFunc

-> TypeInstance

instance: The instance to initialize

-> TypeClass

gClass: The class of the type the instance is created for

-> m ()

genClosure_InstanceInitFunc :: InstanceInitFunc -> IO Closure

mk_InstanceInitFunc :: C_InstanceInitFunc -> IO (FunPtr C_InstanceInitFunc)

noInstanceInitFunc :: Maybe InstanceInitFunc

wrap_InstanceInitFunc :: Maybe (Ptr (FunPtr C_InstanceInitFunc)) -> InstanceInitFunc -> Ptr TypeInstance -> Ptr TypeClass -> IO ()

InterfaceFinalizeFunc

type C_InterfaceFinalizeFunc = Ptr TypeInterface -> Ptr () -> IO ()

type InterfaceFinalizeFunc = TypeInterface -> Ptr () -> IO ()

dynamic_InterfaceFinalizeFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_InterfaceFinalizeFunc

-> TypeInterface

gIface: The interface structure to finalize

-> Ptr ()

ifaceData: The interfaceData supplied via the InterfaceInfo structure

-> m ()

genClosure_InterfaceFinalizeFunc :: InterfaceFinalizeFunc -> IO Closure

mk_InterfaceFinalizeFunc :: C_InterfaceFinalizeFunc -> IO (FunPtr C_InterfaceFinalizeFunc)

noInterfaceFinalizeFunc :: Maybe InterfaceFinalizeFunc

wrap_InterfaceFinalizeFunc :: Maybe (Ptr (FunPtr C_InterfaceFinalizeFunc)) -> InterfaceFinalizeFunc -> Ptr TypeInterface -> Ptr () -> IO ()

InterfaceInitFunc

type C_InterfaceInitFunc = Ptr TypeInterface -> Ptr () -> IO ()

type InterfaceInitFunc = TypeInterface -> Ptr () -> IO ()

dynamic_InterfaceInitFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_InterfaceInitFunc

-> TypeInterface

gIface: The interface structure to initialize

-> Ptr ()

ifaceData: The interfaceData supplied via the InterfaceInfo structure

-> m ()

genClosure_InterfaceInitFunc :: InterfaceInitFunc -> IO Closure

mk_InterfaceInitFunc :: C_InterfaceInitFunc -> IO (FunPtr C_InterfaceInitFunc)

noInterfaceInitFunc :: Maybe InterfaceInitFunc

wrap_InterfaceInitFunc :: Maybe (Ptr (FunPtr C_InterfaceInitFunc)) -> InterfaceInitFunc -> Ptr TypeInterface -> Ptr () -> IO ()

ObjectFinalizeFunc

type C_ObjectFinalizeFunc = Ptr Object -> IO ()

type ObjectFinalizeFunc = Object -> IO ()

dynamic_ObjectFinalizeFunc

Arguments

:: (HasCallStack, MonadIO m, IsObject a)

=> FunPtr C_ObjectFinalizeFunc

-> a

object: the Object being finalized

-> m ()

genClosure_ObjectFinalizeFunc :: ObjectFinalizeFunc -> IO Closure

mk_ObjectFinalizeFunc :: C_ObjectFinalizeFunc -> IO (FunPtr C_ObjectFinalizeFunc)

noObjectFinalizeFunc :: Maybe ObjectFinalizeFunc

wrap_ObjectFinalizeFunc :: Maybe (Ptr (FunPtr C_ObjectFinalizeFunc)) -> ObjectFinalizeFunc -> Ptr Object -> IO ()

ObjectGetPropertyFunc

type C_ObjectGetPropertyFunc = Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()

type ObjectGetPropertyFunc = Object -> Word32 -> GValue -> GParamSpec -> IO ()

dynamic_ObjectGetPropertyFunc

Arguments

:: (HasCallStack, MonadIO m, IsObject a)

=> FunPtr C_ObjectGetPropertyFunc

-> a

object: a Object

-> Word32

propertyId: the numeric id under which the property was registered with objectClassInstallProperty.

-> GValue

value: a Value to return the property value in

-> GParamSpec

pspec: the ParamSpec describing the property

-> m ()

genClosure_ObjectGetPropertyFunc :: ObjectGetPropertyFunc -> IO Closure

mk_ObjectGetPropertyFunc :: C_ObjectGetPropertyFunc -> IO (FunPtr C_ObjectGetPropertyFunc)

noObjectGetPropertyFunc :: Maybe ObjectGetPropertyFunc

wrap_ObjectGetPropertyFunc :: Maybe (Ptr (FunPtr C_ObjectGetPropertyFunc)) -> ObjectGetPropertyFunc -> Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()

ObjectSetPropertyFunc

type C_ObjectSetPropertyFunc = Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()

type ObjectSetPropertyFunc = Object -> Word32 -> GValue -> GParamSpec -> IO ()

dynamic_ObjectSetPropertyFunc

Arguments

:: (HasCallStack, MonadIO m, IsObject a)

=> FunPtr C_ObjectSetPropertyFunc

-> a

object: a Object

-> Word32

propertyId: the numeric id under which the property was registered with objectClassInstallProperty.

-> GValue

value: the new value for the property

-> GParamSpec

pspec: the ParamSpec describing the property

-> m ()

genClosure_ObjectSetPropertyFunc :: ObjectSetPropertyFunc -> IO Closure

mk_ObjectSetPropertyFunc :: C_ObjectSetPropertyFunc -> IO (FunPtr C_ObjectSetPropertyFunc)

noObjectSetPropertyFunc :: Maybe ObjectSetPropertyFunc

wrap_ObjectSetPropertyFunc :: Maybe (Ptr (FunPtr C_ObjectSetPropertyFunc)) -> ObjectSetPropertyFunc -> Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()

ParamSpecTypeInfoFinalizeFieldCallback

type C_ParamSpecTypeInfoFinalizeFieldCallback = Ptr GParamSpec -> IO ()

type ParamSpecTypeInfoFinalizeFieldCallback = GParamSpec -> IO ()

dynamic_ParamSpecTypeInfoFinalizeFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback -> GParamSpec -> m ()

genClosure_ParamSpecTypeInfoFinalizeFieldCallback :: ParamSpecTypeInfoFinalizeFieldCallback -> IO Closure

mk_ParamSpecTypeInfoFinalizeFieldCallback :: C_ParamSpecTypeInfoFinalizeFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback)

noParamSpecTypeInfoFinalizeFieldCallback :: Maybe ParamSpecTypeInfoFinalizeFieldCallback

wrap_ParamSpecTypeInfoFinalizeFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback)) -> ParamSpecTypeInfoFinalizeFieldCallback -> Ptr GParamSpec -> IO ()

ParamSpecTypeInfoInstanceInitFieldCallback

type C_ParamSpecTypeInfoInstanceInitFieldCallback = Ptr GParamSpec -> IO ()

type ParamSpecTypeInfoInstanceInitFieldCallback = GParamSpec -> IO ()

dynamic_ParamSpecTypeInfoInstanceInitFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback -> GParamSpec -> m ()

genClosure_ParamSpecTypeInfoInstanceInitFieldCallback :: ParamSpecTypeInfoInstanceInitFieldCallback -> IO Closure

mk_ParamSpecTypeInfoInstanceInitFieldCallback :: C_ParamSpecTypeInfoInstanceInitFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback)

noParamSpecTypeInfoInstanceInitFieldCallback :: Maybe ParamSpecTypeInfoInstanceInitFieldCallback

wrap_ParamSpecTypeInfoInstanceInitFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback)) -> ParamSpecTypeInfoInstanceInitFieldCallback -> Ptr GParamSpec -> IO ()

ParamSpecTypeInfoValueSetDefaultFieldCallback

type C_ParamSpecTypeInfoValueSetDefaultFieldCallback = Ptr GParamSpec -> Ptr GValue -> IO ()

type ParamSpecTypeInfoValueSetDefaultFieldCallback = GParamSpec -> GValue -> IO ()

dynamic_ParamSpecTypeInfoValueSetDefaultFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback -> GParamSpec -> GValue -> m ()

genClosure_ParamSpecTypeInfoValueSetDefaultFieldCallback :: ParamSpecTypeInfoValueSetDefaultFieldCallback -> IO Closure

mk_ParamSpecTypeInfoValueSetDefaultFieldCallback :: C_ParamSpecTypeInfoValueSetDefaultFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback)

noParamSpecTypeInfoValueSetDefaultFieldCallback :: Maybe ParamSpecTypeInfoValueSetDefaultFieldCallback

wrap_ParamSpecTypeInfoValueSetDefaultFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback)) -> ParamSpecTypeInfoValueSetDefaultFieldCallback -> Ptr GParamSpec -> Ptr GValue -> IO ()

ParamSpecTypeInfoValueValidateFieldCallback

type C_ParamSpecTypeInfoValueValidateFieldCallback = Ptr GParamSpec -> Ptr GValue -> IO CInt

type ParamSpecTypeInfoValueValidateFieldCallback = GParamSpec -> GValue -> IO Bool

dynamic_ParamSpecTypeInfoValueValidateFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback -> GParamSpec -> GValue -> m Bool

genClosure_ParamSpecTypeInfoValueValidateFieldCallback :: ParamSpecTypeInfoValueValidateFieldCallback -> IO Closure

mk_ParamSpecTypeInfoValueValidateFieldCallback :: C_ParamSpecTypeInfoValueValidateFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback)

noParamSpecTypeInfoValueValidateFieldCallback :: Maybe ParamSpecTypeInfoValueValidateFieldCallback

wrap_ParamSpecTypeInfoValueValidateFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback)) -> ParamSpecTypeInfoValueValidateFieldCallback -> Ptr GParamSpec -> Ptr GValue -> IO CInt

ParamSpecTypeInfoValuesCmpFieldCallback

type C_ParamSpecTypeInfoValuesCmpFieldCallback = Ptr GParamSpec -> Ptr GValue -> Ptr GValue -> IO Int32

type ParamSpecTypeInfoValuesCmpFieldCallback = GParamSpec -> GValue -> GValue -> IO Int32

dynamic_ParamSpecTypeInfoValuesCmpFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback -> GParamSpec -> GValue -> GValue -> m Int32

genClosure_ParamSpecTypeInfoValuesCmpFieldCallback :: ParamSpecTypeInfoValuesCmpFieldCallback -> IO Closure

mk_ParamSpecTypeInfoValuesCmpFieldCallback :: C_ParamSpecTypeInfoValuesCmpFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback)

noParamSpecTypeInfoValuesCmpFieldCallback :: Maybe ParamSpecTypeInfoValuesCmpFieldCallback

wrap_ParamSpecTypeInfoValuesCmpFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback)) -> ParamSpecTypeInfoValuesCmpFieldCallback -> Ptr GParamSpec -> Ptr GValue -> Ptr GValue -> IO Int32

SignalAccumulator

type C_SignalAccumulator = Ptr SignalInvocationHint -> Ptr GValue -> Ptr GValue -> Ptr () -> IO CInt

type SignalAccumulator = SignalInvocationHint -> GValue -> GValue -> Ptr () -> IO Bool

dynamic_SignalAccumulator

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_SignalAccumulator

-> SignalInvocationHint

ihint: Signal invocation hint, see SignalInvocationHint.

-> GValue

returnAccu: Accumulator to collect callback return values in, this is the return value of the current signal emission.

-> GValue

handlerReturn: A Value holding the return value of the signal handler.

-> Ptr ()

data: Callback data that was specified when creating the signal.

-> m Bool

Returns: The accumulator function returns whether the signal emission should be aborted. Returning False means to abort the current emission and True is returned for continuation.

genClosure_SignalAccumulator :: SignalAccumulator -> IO Closure

mk_SignalAccumulator :: C_SignalAccumulator -> IO (FunPtr C_SignalAccumulator)

noSignalAccumulator :: Maybe SignalAccumulator

wrap_SignalAccumulator :: Maybe (Ptr (FunPtr C_SignalAccumulator)) -> SignalAccumulator -> Ptr SignalInvocationHint -> Ptr GValue -> Ptr GValue -> Ptr () -> IO CInt

SignalEmissionHook

type C_SignalEmissionHook = Ptr SignalInvocationHint -> Word32 -> Ptr GValue -> Ptr () -> IO CInt

type SignalEmissionHook = SignalInvocationHint -> [GValue] -> Ptr () -> IO Bool

dynamic_SignalEmissionHook

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_SignalEmissionHook

-> SignalInvocationHint

ihint: Signal invocation hint, see SignalInvocationHint.

-> [GValue]

paramValues: the instance on which the signal was emitted, followed by the parameters of the emission.

-> Ptr ()

data: user data associated with the hook.

-> m Bool

Returns: whether it wants to stay connected. If it returns False, the signal hook is disconnected (and destroyed).

genClosure_SignalEmissionHook :: SignalEmissionHook -> IO Closure

mk_SignalEmissionHook :: C_SignalEmissionHook -> IO (FunPtr C_SignalEmissionHook)

noSignalEmissionHook :: Maybe SignalEmissionHook

wrap_SignalEmissionHook :: Maybe (Ptr (FunPtr C_SignalEmissionHook)) -> SignalEmissionHook -> Ptr SignalInvocationHint -> Word32 -> Ptr GValue -> Ptr () -> IO CInt

ToggleNotify

type C_ToggleNotify = Ptr () -> Ptr Object -> CInt -> IO ()

type ToggleNotify = Ptr () -> Object -> Bool -> IO ()

dynamic_ToggleNotify

Arguments

:: (HasCallStack, MonadIO m, IsObject a)

=> FunPtr C_ToggleNotify

-> Ptr ()

data: Callback data passed to g_object_add_toggle_ref()

-> a

object: The object on which g_object_add_toggle_ref() was called.

-> Bool

isLastRef: True if the toggle reference is now the last reference to the object. False if the toggle reference was the last reference and there are now other references.

-> m ()

genClosure_ToggleNotify :: ToggleNotify -> IO Closure

mk_ToggleNotify :: C_ToggleNotify -> IO (FunPtr C_ToggleNotify)

noToggleNotify :: Maybe ToggleNotify

wrap_ToggleNotify :: Maybe (Ptr (FunPtr C_ToggleNotify)) -> ToggleNotify -> Ptr () -> Ptr Object -> CInt -> IO ()

TypeClassCacheFunc

type C_TypeClassCacheFunc = Ptr () -> Ptr TypeClass -> IO CInt

type TypeClassCacheFunc = Ptr () -> TypeClass -> IO Bool

dynamic_TypeClassCacheFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_TypeClassCacheFunc

-> Ptr ()

cacheData: data that was given to the g_type_add_class_cache_func() call

-> TypeClass

gClass: The TypeClass structure which is unreferenced

-> m Bool

Returns: True to stop further GTypeClassCacheFuncs from being called, False to continue

genClosure_TypeClassCacheFunc :: TypeClassCacheFunc -> IO Closure

mk_TypeClassCacheFunc :: C_TypeClassCacheFunc -> IO (FunPtr C_TypeClassCacheFunc)

noTypeClassCacheFunc :: Maybe TypeClassCacheFunc

wrap_TypeClassCacheFunc :: Maybe (Ptr (FunPtr C_TypeClassCacheFunc)) -> TypeClassCacheFunc -> Ptr () -> Ptr TypeClass -> IO CInt

TypeInterfaceCheckFunc

type C_TypeInterfaceCheckFunc = Ptr () -> Ptr TypeInterface -> IO ()

type TypeInterfaceCheckFunc = Ptr () -> TypeInterface -> IO ()

dynamic_TypeInterfaceCheckFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_TypeInterfaceCheckFunc

-> Ptr ()

checkData: data passed to g_type_add_interface_check()

-> TypeInterface

gIface: the interface that has been initialized

-> m ()

genClosure_TypeInterfaceCheckFunc :: TypeInterfaceCheckFunc -> IO Closure

mk_TypeInterfaceCheckFunc :: C_TypeInterfaceCheckFunc -> IO (FunPtr C_TypeInterfaceCheckFunc)

noTypeInterfaceCheckFunc :: Maybe TypeInterfaceCheckFunc

wrap_TypeInterfaceCheckFunc :: Maybe (Ptr (FunPtr C_TypeInterfaceCheckFunc)) -> TypeInterfaceCheckFunc -> Ptr () -> Ptr TypeInterface -> IO ()

TypePluginCompleteInterfaceInfo

type C_TypePluginCompleteInterfaceInfo = Ptr TypePlugin -> CGType -> CGType -> Ptr InterfaceInfo -> IO ()

type TypePluginCompleteInterfaceInfo = TypePlugin -> GType -> GType -> InterfaceInfo -> IO ()

dynamic_TypePluginCompleteInterfaceInfo

Arguments

:: (HasCallStack, MonadIO m, IsTypePlugin a)

=> FunPtr C_TypePluginCompleteInterfaceInfo

-> a

plugin: the TypePlugin

-> GType

instanceType: the GType of an instantiable type to which the interface is added

-> GType

interfaceType: the GType of the interface whose info is completed

-> InterfaceInfo

info: the InterfaceInfo to fill in

-> m ()

genClosure_TypePluginCompleteInterfaceInfo :: TypePluginCompleteInterfaceInfo -> IO Closure

mk_TypePluginCompleteInterfaceInfo :: C_TypePluginCompleteInterfaceInfo -> IO (FunPtr C_TypePluginCompleteInterfaceInfo)

noTypePluginCompleteInterfaceInfo :: Maybe TypePluginCompleteInterfaceInfo

wrap_TypePluginCompleteInterfaceInfo :: Maybe (Ptr (FunPtr C_TypePluginCompleteInterfaceInfo)) -> TypePluginCompleteInterfaceInfo -> Ptr TypePlugin -> CGType -> CGType -> Ptr InterfaceInfo -> IO ()

TypePluginCompleteTypeInfo

type C_TypePluginCompleteTypeInfo = Ptr TypePlugin -> CGType -> Ptr TypeInfo -> Ptr TypeValueTable -> IO ()

type TypePluginCompleteTypeInfo = TypePlugin -> GType -> TypeInfo -> TypeValueTable -> IO ()

dynamic_TypePluginCompleteTypeInfo

Arguments

:: (HasCallStack, MonadIO m, IsTypePlugin a)

=> FunPtr C_TypePluginCompleteTypeInfo

-> a

plugin: the TypePlugin

-> GType

gType: the GType whose info is completed

-> TypeInfo

info: the TypeInfo struct to fill in

-> TypeValueTable

valueTable: the TypeValueTable to fill in

-> m ()

genClosure_TypePluginCompleteTypeInfo :: TypePluginCompleteTypeInfo -> IO Closure

mk_TypePluginCompleteTypeInfo :: C_TypePluginCompleteTypeInfo -> IO (FunPtr C_TypePluginCompleteTypeInfo)

noTypePluginCompleteTypeInfo :: Maybe TypePluginCompleteTypeInfo

wrap_TypePluginCompleteTypeInfo :: Maybe (Ptr (FunPtr C_TypePluginCompleteTypeInfo)) -> TypePluginCompleteTypeInfo -> Ptr TypePlugin -> CGType -> Ptr TypeInfo -> Ptr TypeValueTable -> IO ()

TypePluginUnuse

type C_TypePluginUnuse = Ptr TypePlugin -> IO ()

type TypePluginUnuse = TypePlugin -> IO ()

dynamic_TypePluginUnuse

Arguments

:: (HasCallStack, MonadIO m, IsTypePlugin a)

=> FunPtr C_TypePluginUnuse

-> a

plugin: the TypePlugin whose use count should be decreased

-> m ()

genClosure_TypePluginUnuse :: TypePluginUnuse -> IO Closure

mk_TypePluginUnuse :: C_TypePluginUnuse -> IO (FunPtr C_TypePluginUnuse)

noTypePluginUnuse :: Maybe TypePluginUnuse

wrap_TypePluginUnuse :: Maybe (Ptr (FunPtr C_TypePluginUnuse)) -> TypePluginUnuse -> Ptr TypePlugin -> IO ()

TypePluginUse

type C_TypePluginUse = Ptr TypePlugin -> IO ()

type TypePluginUse = TypePlugin -> IO ()

dynamic_TypePluginUse

Arguments

:: (HasCallStack, MonadIO m, IsTypePlugin a)

=> FunPtr C_TypePluginUse

-> a

plugin: the TypePlugin whose use count should be increased

-> m ()

genClosure_TypePluginUse :: TypePluginUse -> IO Closure

mk_TypePluginUse :: C_TypePluginUse -> IO (FunPtr C_TypePluginUse)

noTypePluginUse :: Maybe TypePluginUse

wrap_TypePluginUse :: Maybe (Ptr (FunPtr C_TypePluginUse)) -> TypePluginUse -> Ptr TypePlugin -> IO ()

TypeValueTableCollectValueFieldCallback

type C_TypeValueTableCollectValueFieldCallback = Ptr GValue -> Word32 -> Ptr TypeCValue -> Word32 -> IO CString

type TypeValueTableCollectValueFieldCallback = GValue -> Word32 -> TypeCValue -> Word32 -> IO Text

dynamic_TypeValueTableCollectValueFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueTableCollectValueFieldCallback -> GValue -> Word32 -> TypeCValue -> Word32 -> m Text

genClosure_TypeValueTableCollectValueFieldCallback :: TypeValueTableCollectValueFieldCallback -> IO Closure

mk_TypeValueTableCollectValueFieldCallback :: C_TypeValueTableCollectValueFieldCallback -> IO (FunPtr C_TypeValueTableCollectValueFieldCallback)

noTypeValueTableCollectValueFieldCallback :: Maybe TypeValueTableCollectValueFieldCallback

wrap_TypeValueTableCollectValueFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableCollectValueFieldCallback)) -> TypeValueTableCollectValueFieldCallback -> Ptr GValue -> Word32 -> Ptr TypeCValue -> Word32 -> IO CString

TypeValueTableLcopyValueFieldCallback

type C_TypeValueTableLcopyValueFieldCallback = Ptr GValue -> Word32 -> Ptr TypeCValue -> Word32 -> IO CString

type TypeValueTableLcopyValueFieldCallback = GValue -> Word32 -> TypeCValue -> Word32 -> IO Text

dynamic_TypeValueTableLcopyValueFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueTableLcopyValueFieldCallback -> GValue -> Word32 -> TypeCValue -> Word32 -> m Text

genClosure_TypeValueTableLcopyValueFieldCallback :: TypeValueTableLcopyValueFieldCallback -> IO Closure

mk_TypeValueTableLcopyValueFieldCallback :: C_TypeValueTableLcopyValueFieldCallback -> IO (FunPtr C_TypeValueTableLcopyValueFieldCallback)

noTypeValueTableLcopyValueFieldCallback :: Maybe TypeValueTableLcopyValueFieldCallback

wrap_TypeValueTableLcopyValueFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableLcopyValueFieldCallback)) -> TypeValueTableLcopyValueFieldCallback -> Ptr GValue -> Word32 -> Ptr TypeCValue -> Word32 -> IO CString

TypeValueTableValueCopyFieldCallback

type C_TypeValueTableValueCopyFieldCallback = Ptr GValue -> Ptr GValue -> IO ()

type TypeValueTableValueCopyFieldCallback = GValue -> GValue -> IO ()

dynamic_TypeValueTableValueCopyFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueTableValueCopyFieldCallback -> GValue -> GValue -> m ()

genClosure_TypeValueTableValueCopyFieldCallback :: TypeValueTableValueCopyFieldCallback -> IO Closure

mk_TypeValueTableValueCopyFieldCallback :: C_TypeValueTableValueCopyFieldCallback -> IO (FunPtr C_TypeValueTableValueCopyFieldCallback)

noTypeValueTableValueCopyFieldCallback :: Maybe TypeValueTableValueCopyFieldCallback

wrap_TypeValueTableValueCopyFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableValueCopyFieldCallback)) -> TypeValueTableValueCopyFieldCallback -> Ptr GValue -> Ptr GValue -> IO ()

TypeValueTableValueFreeFieldCallback

type C_TypeValueTableValueFreeFieldCallback = Ptr GValue -> IO ()

type TypeValueTableValueFreeFieldCallback = GValue -> IO ()

dynamic_TypeValueTableValueFreeFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueTableValueFreeFieldCallback -> GValue -> m ()

genClosure_TypeValueTableValueFreeFieldCallback :: TypeValueTableValueFreeFieldCallback -> IO Closure

mk_TypeValueTableValueFreeFieldCallback :: C_TypeValueTableValueFreeFieldCallback -> IO (FunPtr C_TypeValueTableValueFreeFieldCallback)

noTypeValueTableValueFreeFieldCallback :: Maybe TypeValueTableValueFreeFieldCallback

wrap_TypeValueTableValueFreeFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableValueFreeFieldCallback)) -> TypeValueTableValueFreeFieldCallback -> Ptr GValue -> IO ()

TypeValueTableValueInitFieldCallback

type C_TypeValueTableValueInitFieldCallback = Ptr GValue -> IO ()

type TypeValueTableValueInitFieldCallback = GValue -> IO ()

dynamic_TypeValueTableValueInitFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueTableValueInitFieldCallback -> GValue -> m ()

genClosure_TypeValueTableValueInitFieldCallback :: TypeValueTableValueInitFieldCallback -> IO Closure

mk_TypeValueTableValueInitFieldCallback :: C_TypeValueTableValueInitFieldCallback -> IO (FunPtr C_TypeValueTableValueInitFieldCallback)

noTypeValueTableValueInitFieldCallback :: Maybe TypeValueTableValueInitFieldCallback

wrap_TypeValueTableValueInitFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableValueInitFieldCallback)) -> TypeValueTableValueInitFieldCallback -> Ptr GValue -> IO ()

TypeValueTableValuePeekPointerFieldCallback

type C_TypeValueTableValuePeekPointerFieldCallback = Ptr GValue -> IO (Ptr ())

type TypeValueTableValuePeekPointerFieldCallback = GValue -> IO (Ptr ())

dynamic_TypeValueTableValuePeekPointerFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueTableValuePeekPointerFieldCallback -> GValue -> m (Ptr ())

genClosure_TypeValueTableValuePeekPointerFieldCallback :: TypeValueTableValuePeekPointerFieldCallback -> IO Closure

mk_TypeValueTableValuePeekPointerFieldCallback :: C_TypeValueTableValuePeekPointerFieldCallback -> IO (FunPtr C_TypeValueTableValuePeekPointerFieldCallback)

noTypeValueTableValuePeekPointerFieldCallback :: Maybe TypeValueTableValuePeekPointerFieldCallback

wrap_TypeValueTableValuePeekPointerFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableValuePeekPointerFieldCallback)) -> TypeValueTableValuePeekPointerFieldCallback -> Ptr GValue -> IO (Ptr ())

ValueTransform

type C_ValueTransform = Ptr GValue -> Ptr GValue -> IO ()

type ValueTransform = GValue -> GValue -> IO ()

dynamic_ValueTransform

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_ValueTransform

-> GValue

srcValue: Source value.

-> GValue

destValue: Target value.

-> m ()

genClosure_ValueTransform :: ValueTransform -> IO Closure

mk_ValueTransform :: C_ValueTransform -> IO (FunPtr C_ValueTransform)

noValueTransform :: Maybe ValueTransform

wrap_ValueTransform :: Maybe (Ptr (FunPtr C_ValueTransform)) -> ValueTransform -> Ptr GValue -> Ptr GValue -> IO ()

WeakNotify

type C_WeakNotify = Ptr () -> Ptr Object -> IO ()

type WeakNotify = Ptr () -> Object -> IO ()

dynamic_WeakNotify

Arguments

:: (HasCallStack, MonadIO m, IsObject a)

=> FunPtr C_WeakNotify

-> Ptr ()

data: data that was provided when the weak reference was established

-> a

whereTheObjectWas: the object being finalized

-> m ()

genClosure_WeakNotify :: WeakNotify -> IO Closure

mk_WeakNotify :: C_WeakNotify -> IO (FunPtr C_WeakNotify)

noWeakNotify :: Maybe WeakNotify

wrap_WeakNotify :: Maybe (Ptr (FunPtr C_WeakNotify)) -> WeakNotify -> Ptr () -> Ptr Object -> IO ()