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

GI.GObject.Callbacks

Contents

Signals

Description

Synopsis

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