GI.GObject.Callbacks

Signals

BaseFinalizeFunc

type BaseFinalizeFunc

Arguments

 = TypeClass

gClass: The TypeClass structure to finalize

-> IO ()

A callback function used by the type system to finalize those portions of a derived types class structure that were setup from the corresponding GBaseInitFunc() function. Class finalization basically works the inverse way in which class initialization is performed. See GClassInitFunc() for a discussion of the class initialization process.

type C_BaseFinalizeFunc = Ptr TypeClass -> IO ()

Type for the callback on the (unwrapped) C side.

dynamic_BaseFinalizeFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_BaseFinalizeFunc

-> TypeClass

gClass: The TypeClass structure to finalize

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_BaseFinalizeFunc :: MonadIO m => BaseFinalizeFunc -> m (GClosure C_BaseFinalizeFunc)

Wrap the callback into a GClosure.

mk_BaseFinalizeFunc :: C_BaseFinalizeFunc -> IO (FunPtr C_BaseFinalizeFunc)

Generate a function pointer callable from C code, from a C_BaseFinalizeFunc.

noBaseFinalizeFunc :: Maybe BaseFinalizeFunc

A convenience synonym for Nothing :: Maybe BaseFinalizeFunc.

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

Wrap a BaseFinalizeFunc into a C_BaseFinalizeFunc.

BaseInitFunc

type BaseInitFunc

Arguments

 = TypeClass

gClass: The TypeClass structure to initialize

-> IO ()

A callback function used by the type system to do base initialization of the class structures of derived types. It is called as part of the initialization process of all derived classes and should reallocate or reset all dynamic class members copied over from the parent class. For example, class members (such as strings) that are not sufficiently handled by a plain memory copy of the parent class into the derived class have to be altered. See GClassInitFunc() for a discussion of the class initialization process.

type C_BaseInitFunc = Ptr TypeClass -> IO ()

Type for the callback on the (unwrapped) C side.

dynamic_BaseInitFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_BaseInitFunc

-> TypeClass

gClass: The TypeClass structure to initialize

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_BaseInitFunc :: MonadIO m => BaseInitFunc -> m (GClosure C_BaseInitFunc)

Wrap the callback into a GClosure.

mk_BaseInitFunc :: C_BaseInitFunc -> IO (FunPtr C_BaseInitFunc)

Generate a function pointer callable from C code, from a C_BaseInitFunc.

noBaseInitFunc :: Maybe BaseInitFunc

A convenience synonym for Nothing :: Maybe BaseInitFunc.

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

Wrap a BaseInitFunc into a C_BaseInitFunc.

BindingTransformFunc

type BindingTransformFunc

Arguments

 = Binding

binding: a Binding

-> GValue

fromValue: the Value containing the value to transform

-> GValue

toValue: the Value in which to store the transformed value

-> IO Bool

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

A function to be called to transform fromValue to toValue. If this is the transformTo function of a binding, then fromValue is the sourceProperty on the source object, and toValue is the targetProperty on the target object. If this is the transformFrom function of a BindingFlagsBidirectional binding, then those roles are reversed.

Since: 2.26

type BindingTransformFunc_WithClosures

Arguments

 = Binding

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

-> IO Bool

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

A function to be called to transform fromValue to toValue. If this is the transformTo function of a binding, then fromValue is the sourceProperty on the source object, and toValue is the targetProperty on the target object. If this is the transformFrom function of a BindingFlagsBidirectional binding, then those roles are reversed.

Since: 2.26

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

Type for the callback on the (unwrapped) C side.

drop_closures_BindingTransformFunc :: BindingTransformFunc -> BindingTransformFunc_WithClosures

A simple wrapper that ignores the closure arguments.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_BindingTransformFunc :: MonadIO m => BindingTransformFunc -> m (GClosure C_BindingTransformFunc)

Wrap the callback into a GClosure.

mk_BindingTransformFunc :: C_BindingTransformFunc -> IO (FunPtr C_BindingTransformFunc)

Generate a function pointer callable from C code, from a C_BindingTransformFunc.

noBindingTransformFunc :: Maybe BindingTransformFunc

A convenience synonym for Nothing :: Maybe BindingTransformFunc.

noBindingTransformFunc_WithClosures :: Maybe BindingTransformFunc_WithClosures

A convenience synonym for Nothing :: Maybe BindingTransformFunc_WithClosures.

wrap_BindingTransformFunc :: Maybe (Ptr (FunPtr C_BindingTransformFunc)) -> BindingTransformFunc_WithClosures -> C_BindingTransformFunc

Wrap a BindingTransformFunc into a C_BindingTransformFunc.

BoxedCopyFunc

type BoxedCopyFunc

Arguments

 = Ptr ()

boxed: The boxed structure to be copied.

-> IO (Ptr ())

Returns: The newly created copy of the boxed structure.

This function is provided by the user and should produce a copy of the passed in boxed structure.

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

Type for the callback on the (unwrapped) C side.

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.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_BoxedCopyFunc :: MonadIO m => BoxedCopyFunc -> m (GClosure C_BoxedCopyFunc)

Wrap the callback into a GClosure.

mk_BoxedCopyFunc :: C_BoxedCopyFunc -> IO (FunPtr C_BoxedCopyFunc)

Generate a function pointer callable from C code, from a C_BoxedCopyFunc.

noBoxedCopyFunc :: Maybe BoxedCopyFunc

A convenience synonym for Nothing :: Maybe BoxedCopyFunc.

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

Wrap a BoxedCopyFunc into a C_BoxedCopyFunc.

BoxedFreeFunc

type BoxedFreeFunc

Arguments

 = Ptr ()

boxed: The boxed structure to be freed.

-> IO ()

This function is provided by the user and should free the boxed structure passed.

type C_BoxedFreeFunc = Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

dynamic_BoxedFreeFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_BoxedFreeFunc

-> Ptr ()

boxed: The boxed structure to be freed.

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_BoxedFreeFunc :: MonadIO m => BoxedFreeFunc -> m (GClosure C_BoxedFreeFunc)

Wrap the callback into a GClosure.

mk_BoxedFreeFunc :: C_BoxedFreeFunc -> IO (FunPtr C_BoxedFreeFunc)

Generate a function pointer callable from C code, from a C_BoxedFreeFunc.

noBoxedFreeFunc :: Maybe BoxedFreeFunc

A convenience synonym for Nothing :: Maybe BoxedFreeFunc.

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

Wrap a BoxedFreeFunc into a C_BoxedFreeFunc.

Callback

type C_Callback = IO ()

Type for the callback on the (unwrapped) C side.

type Callback = IO ()

The type used for callback functions in structure definitions and function signatures. This doesn't mean that all callback functions must take no parameters and return void. The required signature of a callback function is determined by the context in which is used (e.g. the signal to which it is connected). Use G_CALLBACK() to cast the callback function to a Callback.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_Callback :: MonadIO m => Callback -> m (GClosure C_Callback)

Wrap the callback into a GClosure.

mk_Callback :: C_Callback -> IO (FunPtr C_Callback)

Generate a function pointer callable from C code, from a C_Callback.

noCallback :: Maybe Callback

A convenience synonym for Nothing :: Maybe Callback.

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

Wrap a Callback into a C_Callback.

ClassFinalizeFunc

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

Type for the callback on the (unwrapped) C side.

type ClassFinalizeFunc

Arguments

 = TypeClass

gClass: The TypeClass structure to finalize

-> Ptr ()

classData: The classData member supplied via the TypeInfo structure

-> IO ()

A callback function used by the type system to finalize a class. This function is rarely needed, as dynamically allocated class resources should be handled by GBaseInitFunc() and GBaseFinalizeFunc(). Also, specification of a GClassFinalizeFunc() in the TypeInfo structure of a static type is invalid, because classes of static types will never be finalized (they are artificially kept alive when their reference count drops to zero).

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ClassFinalizeFunc :: MonadIO m => ClassFinalizeFunc -> m (GClosure C_ClassFinalizeFunc)

Wrap the callback into a GClosure.

mk_ClassFinalizeFunc :: C_ClassFinalizeFunc -> IO (FunPtr C_ClassFinalizeFunc)

Generate a function pointer callable from C code, from a C_ClassFinalizeFunc.

noClassFinalizeFunc :: Maybe ClassFinalizeFunc

A convenience synonym for Nothing :: Maybe ClassFinalizeFunc.

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

Wrap a ClassFinalizeFunc into a C_ClassFinalizeFunc.

ClassInitFunc

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

Type for the callback on the (unwrapped) C side.

type ClassInitFunc

Arguments

 = TypeClass

gClass: The TypeClass structure to initialize.

-> Ptr ()

classData: The classData member supplied via the TypeInfo structure.

-> IO ()

A callback function used by the type system to initialize the class of a specific type. This function should initialize all static class members.

The initialization process of a class involves:

• Copying common members from the parent class over to the derived class structure.
• Zero initialization of the remaining members not copied over from the parent class.
• Invocation of the GBaseInitFunc() initializers of all parent types and the class' type.
• Invocation of the class' GClassInitFunc() initializer.

Since derived classes are partially initialized through a memory copy of the parent class, the general rule is that GBaseInitFunc() and GBaseFinalizeFunc() should take care of necessary reinitialization and release of those class members that were introduced by the type that specified these GBaseInitFunc()/GBaseFinalizeFunc(). GClassInitFunc() should only care about initializing static class members, while dynamic class members (such as allocated strings or reference counted resources) are better handled by a GBaseInitFunc() for this type, so proper initialization of the dynamic class members is performed for class initialization of derived types as well.

An example may help to correspond the intend of the different class initializers:

C code

typedef struct {
  GObjectClass parent_class;
  gint         static_integer;
  gchar       *dynamic_string;
} TypeAClass;
static void
type_a_base_class_init (TypeAClass *class)
{
  class->dynamic_string = g_strdup ("some string");
}
static void
type_a_base_class_finalize (TypeAClass *class)
{
  g_free (class->dynamic_string);
}
static void
type_a_class_init (TypeAClass *class)
{
  class->static_integer = 42;
}

typedef struct {
  TypeAClass   parent_class;
  gfloat       static_float;
  GString     *dynamic_gstring;
} TypeBClass;
static void
type_b_base_class_init (TypeBClass *class)
{
  class->dynamic_gstring = g_string_new ("some other string");
}
static void
type_b_base_class_finalize (TypeBClass *class)
{
  g_string_free (class->dynamic_gstring);
}
static void
type_b_class_init (TypeBClass *class)
{
  class->static_float = 3.14159265358979323846;
}

Initialization of TypeBClass will first cause initialization of TypeAClass (derived classes reference their parent classes, see typeClassRef on this).

Initialization of TypeAClass roughly involves zero-initializing its fields, then calling its GBaseInitFunc() type_a_base_class_init() to allocate its dynamic members (dynamic_string), and finally calling its GClassInitFunc() type_a_class_init() to initialize its static members (static_integer). The first step in the initialization process of TypeBClass is then a plain memory copy of the contents of TypeAClass into TypeBClass and zero-initialization of the remaining fields in TypeBClass. The dynamic members of TypeAClass within TypeBClass now need reinitialization which is performed by calling type_a_base_class_init() with an argument of TypeBClass.

After that, the GBaseInitFunc() of TypeBClass, type_b_base_class_init() is called to allocate the dynamic members of TypeBClass (dynamic_gstring), and finally the GClassInitFunc() of TypeBClass, type_b_class_init(), is called to complete the initialization process with the static members (static_float).

Corresponding finalization counter parts to the GBaseInitFunc() functions have to be provided to release allocated resources at class finalization time.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ClassInitFunc :: MonadIO m => ClassInitFunc -> m (GClosure C_ClassInitFunc)

Wrap the callback into a GClosure.

mk_ClassInitFunc :: C_ClassInitFunc -> IO (FunPtr C_ClassInitFunc)

Generate a function pointer callable from C code, from a C_ClassInitFunc.

noClassInitFunc :: Maybe ClassInitFunc

A convenience synonym for Nothing :: Maybe ClassInitFunc.

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

Wrap a ClassInitFunc into a C_ClassInitFunc.

ClosureMarshal

type C_ClosureMarshal = Ptr (GClosure ()) -> Ptr GValue -> Word32 -> Ptr GValue -> Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type ClosureMarshal

Arguments

 = GClosure ()

closure: the Closure to which the marshaller belongs

-> Maybe GValue

returnValue: a Value to store the return value. May be Nothing if the callback of closure doesn't return a value.

-> [GValue]

paramValues: an array of GValues holding the arguments on which to invoke the callback of closure

-> Ptr ()

invocationHint: the invocation hint given as the last argument to closureInvoke

-> Ptr ()

marshalData: additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal()

-> IO ()

The type used for marshaller functions.

dynamic_ClosureMarshal

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_ClosureMarshal

-> GClosure a

closure: the Closure to which the marshaller belongs

-> Maybe GValue

returnValue: a Value to store the return value. May be Nothing if the callback of closure doesn't return a value.

-> [GValue]

paramValues: an array of GValues holding the arguments on which to invoke the callback of closure

-> Ptr ()

invocationHint: the invocation hint given as the last argument to closureInvoke

-> Ptr ()

marshalData: additional data specified when registering the marshaller, see g_closure_set_marshal() and g_closure_set_meta_marshal()

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ClosureMarshal :: MonadIO m => ClosureMarshal -> m (GClosure C_ClosureMarshal)

Wrap the callback into a GClosure.

mk_ClosureMarshal :: C_ClosureMarshal -> IO (FunPtr C_ClosureMarshal)

Generate a function pointer callable from C code, from a C_ClosureMarshal.

noClosureMarshal :: Maybe ClosureMarshal

A convenience synonym for Nothing :: Maybe ClosureMarshal.

wrap_ClosureMarshal :: Maybe (Ptr (FunPtr C_ClosureMarshal)) -> ClosureMarshal -> C_ClosureMarshal

Wrap a ClosureMarshal into a C_ClosureMarshal.

ClosureMarshalFieldCallback

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

Type for the callback on the (unwrapped) C side.

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

No description available in the introspection data.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ClosureMarshalFieldCallback :: MonadIO m => ClosureMarshalFieldCallback -> m (GClosure C_ClosureMarshalFieldCallback)

Wrap the callback into a GClosure.

mk_ClosureMarshalFieldCallback :: C_ClosureMarshalFieldCallback -> IO (FunPtr C_ClosureMarshalFieldCallback)

Generate a function pointer callable from C code, from a C_ClosureMarshalFieldCallback.

noClosureMarshalFieldCallback :: Maybe ClosureMarshalFieldCallback

A convenience synonym for Nothing :: Maybe ClosureMarshalFieldCallback.

wrap_ClosureMarshalFieldCallback :: Maybe (Ptr (FunPtr C_ClosureMarshalFieldCallback)) -> ClosureMarshalFieldCallback -> C_ClosureMarshalFieldCallback

Wrap a ClosureMarshalFieldCallback into a C_ClosureMarshalFieldCallback.

ClosureNotify

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

Type for the callback on the (unwrapped) C side.

type ClosureNotify

Arguments

 = Ptr ()

data: data specified when registering the notification callback

-> GClosure ()

closure: the Closure on which the notification is emitted

-> IO ()

The type used for the various notification callbacks which can be registered on closures.

dynamic_ClosureNotify

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_ClosureNotify

-> Ptr ()

data: data specified when registering the notification callback

-> GClosure a

closure: the Closure on which the notification is emitted

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ClosureNotify :: MonadIO m => ClosureNotify -> m (GClosure C_ClosureNotify)

Wrap the callback into a GClosure.

mk_ClosureNotify :: C_ClosureNotify -> IO (FunPtr C_ClosureNotify)

Generate a function pointer callable from C code, from a C_ClosureNotify.

noClosureNotify :: Maybe ClosureNotify

A convenience synonym for Nothing :: Maybe ClosureNotify.

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

Wrap a ClosureNotify into a C_ClosureNotify.

InitiallyUnownedClassConstructedFieldCallback

type C_InitiallyUnownedClassConstructedFieldCallback = Ptr Object -> IO ()

Type for the callback on the (unwrapped) C side.

type InitiallyUnownedClassConstructedFieldCallback = Object -> IO ()

No description available in the introspection data.

dynamic_InitiallyUnownedClassConstructedFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassConstructedFieldCallback -> a -> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_InitiallyUnownedClassConstructedFieldCallback :: MonadIO m => InitiallyUnownedClassConstructedFieldCallback -> m (GClosure C_InitiallyUnownedClassConstructedFieldCallback)

Wrap the callback into a GClosure.

mk_InitiallyUnownedClassConstructedFieldCallback :: C_InitiallyUnownedClassConstructedFieldCallback -> IO (FunPtr C_InitiallyUnownedClassConstructedFieldCallback)

Generate a function pointer callable from C code, from a C_InitiallyUnownedClassConstructedFieldCallback.

noInitiallyUnownedClassConstructedFieldCallback :: Maybe InitiallyUnownedClassConstructedFieldCallback

A convenience synonym for Nothing :: Maybe InitiallyUnownedClassConstructedFieldCallback.

wrap_InitiallyUnownedClassConstructedFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassConstructedFieldCallback)) -> InitiallyUnownedClassConstructedFieldCallback -> C_InitiallyUnownedClassConstructedFieldCallback

Wrap a InitiallyUnownedClassConstructedFieldCallback into a C_InitiallyUnownedClassConstructedFieldCallback.

InitiallyUnownedClassDispatchPropertiesChangedFieldCallback

type C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback = Ptr Object -> Word32 -> Ptr GParamSpec -> IO ()

Type for the callback on the (unwrapped) C side.

type InitiallyUnownedClassDispatchPropertiesChangedFieldCallback = Object -> Word32 -> GParamSpec -> IO ()

No description available in the introspection data.

dynamic_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback -> a -> Word32 -> GParamSpec -> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback :: MonadIO m => InitiallyUnownedClassDispatchPropertiesChangedFieldCallback -> m (GClosure C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)

Wrap the callback into a GClosure.

mk_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback :: C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback -> IO (FunPtr C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)

Generate a function pointer callable from C code, from a C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback.

noInitiallyUnownedClassDispatchPropertiesChangedFieldCallback :: Maybe InitiallyUnownedClassDispatchPropertiesChangedFieldCallback

A convenience synonym for Nothing :: Maybe InitiallyUnownedClassDispatchPropertiesChangedFieldCallback.

wrap_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)) -> InitiallyUnownedClassDispatchPropertiesChangedFieldCallback -> C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback

Wrap a InitiallyUnownedClassDispatchPropertiesChangedFieldCallback into a C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback.

InitiallyUnownedClassDisposeFieldCallback

type C_InitiallyUnownedClassDisposeFieldCallback = Ptr Object -> IO ()

Type for the callback on the (unwrapped) C side.

type InitiallyUnownedClassDisposeFieldCallback = Object -> IO ()

No description available in the introspection data.

dynamic_InitiallyUnownedClassDisposeFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> a -> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_InitiallyUnownedClassDisposeFieldCallback :: MonadIO m => InitiallyUnownedClassDisposeFieldCallback -> m (GClosure C_InitiallyUnownedClassDisposeFieldCallback)

Wrap the callback into a GClosure.

mk_InitiallyUnownedClassDisposeFieldCallback :: C_InitiallyUnownedClassDisposeFieldCallback -> IO (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)

Generate a function pointer callable from C code, from a C_InitiallyUnownedClassDisposeFieldCallback.

noInitiallyUnownedClassDisposeFieldCallback :: Maybe InitiallyUnownedClassDisposeFieldCallback

A convenience synonym for Nothing :: Maybe InitiallyUnownedClassDisposeFieldCallback.

wrap_InitiallyUnownedClassDisposeFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)) -> InitiallyUnownedClassDisposeFieldCallback -> C_InitiallyUnownedClassDisposeFieldCallback

Wrap a InitiallyUnownedClassDisposeFieldCallback into a C_InitiallyUnownedClassDisposeFieldCallback.

InitiallyUnownedClassFinalizeFieldCallback

type C_InitiallyUnownedClassFinalizeFieldCallback = Ptr Object -> IO ()

Type for the callback on the (unwrapped) C side.

type InitiallyUnownedClassFinalizeFieldCallback = Object -> IO ()

No description available in the introspection data.

dynamic_InitiallyUnownedClassFinalizeFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassFinalizeFieldCallback -> a -> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_InitiallyUnownedClassFinalizeFieldCallback :: MonadIO m => InitiallyUnownedClassFinalizeFieldCallback -> m (GClosure C_InitiallyUnownedClassFinalizeFieldCallback)

Wrap the callback into a GClosure.

mk_InitiallyUnownedClassFinalizeFieldCallback :: C_InitiallyUnownedClassFinalizeFieldCallback -> IO (FunPtr C_InitiallyUnownedClassFinalizeFieldCallback)

Generate a function pointer callable from C code, from a C_InitiallyUnownedClassFinalizeFieldCallback.

noInitiallyUnownedClassFinalizeFieldCallback :: Maybe InitiallyUnownedClassFinalizeFieldCallback

A convenience synonym for Nothing :: Maybe InitiallyUnownedClassFinalizeFieldCallback.

wrap_InitiallyUnownedClassFinalizeFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassFinalizeFieldCallback)) -> InitiallyUnownedClassFinalizeFieldCallback -> C_InitiallyUnownedClassFinalizeFieldCallback

Wrap a InitiallyUnownedClassFinalizeFieldCallback into a C_InitiallyUnownedClassFinalizeFieldCallback.

InitiallyUnownedClassGetPropertyFieldCallback

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

Type for the callback on the (unwrapped) C side.

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

No description available in the introspection data.

dynamic_InitiallyUnownedClassGetPropertyFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassGetPropertyFieldCallback -> a -> Word32 -> GValue -> GParamSpec -> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_InitiallyUnownedClassGetPropertyFieldCallback :: MonadIO m => InitiallyUnownedClassGetPropertyFieldCallback -> m (GClosure C_InitiallyUnownedClassGetPropertyFieldCallback)

Wrap the callback into a GClosure.

mk_InitiallyUnownedClassGetPropertyFieldCallback :: C_InitiallyUnownedClassGetPropertyFieldCallback -> IO (FunPtr C_InitiallyUnownedClassGetPropertyFieldCallback)

Generate a function pointer callable from C code, from a C_InitiallyUnownedClassGetPropertyFieldCallback.

noInitiallyUnownedClassGetPropertyFieldCallback :: Maybe InitiallyUnownedClassGetPropertyFieldCallback

A convenience synonym for Nothing :: Maybe InitiallyUnownedClassGetPropertyFieldCallback.

wrap_InitiallyUnownedClassGetPropertyFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassGetPropertyFieldCallback)) -> InitiallyUnownedClassGetPropertyFieldCallback -> C_InitiallyUnownedClassGetPropertyFieldCallback

Wrap a InitiallyUnownedClassGetPropertyFieldCallback into a C_InitiallyUnownedClassGetPropertyFieldCallback.

InitiallyUnownedClassNotifyFieldCallback

type C_InitiallyUnownedClassNotifyFieldCallback = Ptr Object -> Ptr GParamSpec -> IO ()

Type for the callback on the (unwrapped) C side.

type InitiallyUnownedClassNotifyFieldCallback

Arguments

 = Object

object: a Object

-> GParamSpec

-> IO ()

No description available in the introspection data.

dynamic_InitiallyUnownedClassNotifyFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsObject a)

=> FunPtr C_InitiallyUnownedClassNotifyFieldCallback

-> a

object: a Object

-> GParamSpec

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_InitiallyUnownedClassNotifyFieldCallback :: MonadIO m => InitiallyUnownedClassNotifyFieldCallback -> m (GClosure C_InitiallyUnownedClassNotifyFieldCallback)

Wrap the callback into a GClosure.

mk_InitiallyUnownedClassNotifyFieldCallback :: C_InitiallyUnownedClassNotifyFieldCallback -> IO (FunPtr C_InitiallyUnownedClassNotifyFieldCallback)

Generate a function pointer callable from C code, from a C_InitiallyUnownedClassNotifyFieldCallback.

noInitiallyUnownedClassNotifyFieldCallback :: Maybe InitiallyUnownedClassNotifyFieldCallback

A convenience synonym for Nothing :: Maybe InitiallyUnownedClassNotifyFieldCallback.

wrap_InitiallyUnownedClassNotifyFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassNotifyFieldCallback)) -> InitiallyUnownedClassNotifyFieldCallback -> C_InitiallyUnownedClassNotifyFieldCallback

Wrap a InitiallyUnownedClassNotifyFieldCallback into a C_InitiallyUnownedClassNotifyFieldCallback.

InitiallyUnownedClassSetPropertyFieldCallback

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

Type for the callback on the (unwrapped) C side.

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

No description available in the introspection data.

dynamic_InitiallyUnownedClassSetPropertyFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback -> a -> Word32 -> GValue -> GParamSpec -> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_InitiallyUnownedClassSetPropertyFieldCallback :: MonadIO m => InitiallyUnownedClassSetPropertyFieldCallback -> m (GClosure C_InitiallyUnownedClassSetPropertyFieldCallback)

Wrap the callback into a GClosure.

mk_InitiallyUnownedClassSetPropertyFieldCallback :: C_InitiallyUnownedClassSetPropertyFieldCallback -> IO (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback)

Generate a function pointer callable from C code, from a C_InitiallyUnownedClassSetPropertyFieldCallback.

noInitiallyUnownedClassSetPropertyFieldCallback :: Maybe InitiallyUnownedClassSetPropertyFieldCallback

A convenience synonym for Nothing :: Maybe InitiallyUnownedClassSetPropertyFieldCallback.

wrap_InitiallyUnownedClassSetPropertyFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback)) -> InitiallyUnownedClassSetPropertyFieldCallback -> C_InitiallyUnownedClassSetPropertyFieldCallback

Wrap a InitiallyUnownedClassSetPropertyFieldCallback into a C_InitiallyUnownedClassSetPropertyFieldCallback.

InstanceInitFunc

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

Type for the callback on the (unwrapped) C side.

type InstanceInitFunc

Arguments

 = TypeInstance

instance: The instance to initialize

-> TypeClass

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

-> IO ()

A callback function used by the type system to initialize a new instance of a type. This function initializes all instance members and allocates any resources required by it.

Initialization of a derived instance involves calling all its parent types instance initializers, so the class member of the instance is altered during its initialization to always point to the class that belongs to the type the current initializer was introduced for.

The extended members of instance are guaranteed to have been filled with zeros before this function is called.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_InstanceInitFunc :: MonadIO m => InstanceInitFunc -> m (GClosure C_InstanceInitFunc)

Wrap the callback into a GClosure.

mk_InstanceInitFunc :: C_InstanceInitFunc -> IO (FunPtr C_InstanceInitFunc)

Generate a function pointer callable from C code, from a C_InstanceInitFunc.

noInstanceInitFunc :: Maybe InstanceInitFunc

A convenience synonym for Nothing :: Maybe InstanceInitFunc.

wrap_InstanceInitFunc :: Maybe (Ptr (FunPtr C_InstanceInitFunc)) -> InstanceInitFunc -> C_InstanceInitFunc

Wrap a InstanceInitFunc into a C_InstanceInitFunc.

InterfaceFinalizeFunc

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

Type for the callback on the (unwrapped) C side.

type InterfaceFinalizeFunc

Arguments

 = TypeInterface

gIface: The interface structure to finalize

-> Ptr ()

ifaceData: The interfaceData supplied via the InterfaceInfo structure

-> IO ()

A callback function used by the type system to finalize an interface. This function should destroy any internal data and release any resources allocated by the corresponding GInterfaceInitFunc() function.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_InterfaceFinalizeFunc :: MonadIO m => InterfaceFinalizeFunc -> m (GClosure C_InterfaceFinalizeFunc)

Wrap the callback into a GClosure.

mk_InterfaceFinalizeFunc :: C_InterfaceFinalizeFunc -> IO (FunPtr C_InterfaceFinalizeFunc)

Generate a function pointer callable from C code, from a C_InterfaceFinalizeFunc.

noInterfaceFinalizeFunc :: Maybe InterfaceFinalizeFunc

A convenience synonym for Nothing :: Maybe InterfaceFinalizeFunc.

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

Wrap a InterfaceFinalizeFunc into a C_InterfaceFinalizeFunc.

InterfaceInitFunc

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

Type for the callback on the (unwrapped) C side.

type InterfaceInitFunc

Arguments

 = TypeInterface

gIface: The interface structure to initialize

-> Ptr ()

ifaceData: The interfaceData supplied via the InterfaceInfo structure

-> IO ()

A callback function used by the type system to initialize a new interface. This function should initialize all internal data and allocate any resources required by the interface.

The members of ifaceData are guaranteed to have been filled with zeros before this function is called.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_InterfaceInitFunc :: MonadIO m => InterfaceInitFunc -> m (GClosure C_InterfaceInitFunc)

Wrap the callback into a GClosure.

mk_InterfaceInitFunc :: C_InterfaceInitFunc -> IO (FunPtr C_InterfaceInitFunc)

Generate a function pointer callable from C code, from a C_InterfaceInitFunc.

noInterfaceInitFunc :: Maybe InterfaceInitFunc

A convenience synonym for Nothing :: Maybe InterfaceInitFunc.

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

Wrap a InterfaceInitFunc into a C_InterfaceInitFunc.

ObjectClassConstructedFieldCallback

type C_ObjectClassConstructedFieldCallback = Ptr Object -> IO ()

Type for the callback on the (unwrapped) C side.

type ObjectClassConstructedFieldCallback = Object -> IO ()

No description available in the introspection data.

dynamic_ObjectClassConstructedFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassConstructedFieldCallback -> a -> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ObjectClassConstructedFieldCallback :: MonadIO m => ObjectClassConstructedFieldCallback -> m (GClosure C_ObjectClassConstructedFieldCallback)

Wrap the callback into a GClosure.

mk_ObjectClassConstructedFieldCallback :: C_ObjectClassConstructedFieldCallback -> IO (FunPtr C_ObjectClassConstructedFieldCallback)

Generate a function pointer callable from C code, from a C_ObjectClassConstructedFieldCallback.

noObjectClassConstructedFieldCallback :: Maybe ObjectClassConstructedFieldCallback

A convenience synonym for Nothing :: Maybe ObjectClassConstructedFieldCallback.

wrap_ObjectClassConstructedFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassConstructedFieldCallback)) -> ObjectClassConstructedFieldCallback -> C_ObjectClassConstructedFieldCallback

Wrap a ObjectClassConstructedFieldCallback into a C_ObjectClassConstructedFieldCallback.

ObjectClassDispatchPropertiesChangedFieldCallback

type C_ObjectClassDispatchPropertiesChangedFieldCallback = Ptr Object -> Word32 -> Ptr GParamSpec -> IO ()

Type for the callback on the (unwrapped) C side.

type ObjectClassDispatchPropertiesChangedFieldCallback = Object -> Word32 -> GParamSpec -> IO ()

No description available in the introspection data.

dynamic_ObjectClassDispatchPropertiesChangedFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback -> a -> Word32 -> GParamSpec -> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ObjectClassDispatchPropertiesChangedFieldCallback :: MonadIO m => ObjectClassDispatchPropertiesChangedFieldCallback -> m (GClosure C_ObjectClassDispatchPropertiesChangedFieldCallback)

Wrap the callback into a GClosure.

mk_ObjectClassDispatchPropertiesChangedFieldCallback :: C_ObjectClassDispatchPropertiesChangedFieldCallback -> IO (FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback)

Generate a function pointer callable from C code, from a C_ObjectClassDispatchPropertiesChangedFieldCallback.

noObjectClassDispatchPropertiesChangedFieldCallback :: Maybe ObjectClassDispatchPropertiesChangedFieldCallback

A convenience synonym for Nothing :: Maybe ObjectClassDispatchPropertiesChangedFieldCallback.

wrap_ObjectClassDispatchPropertiesChangedFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback)) -> ObjectClassDispatchPropertiesChangedFieldCallback -> C_ObjectClassDispatchPropertiesChangedFieldCallback

Wrap a ObjectClassDispatchPropertiesChangedFieldCallback into a C_ObjectClassDispatchPropertiesChangedFieldCallback.

ObjectClassDisposeFieldCallback

type C_ObjectClassDisposeFieldCallback = Ptr Object -> IO ()

Type for the callback on the (unwrapped) C side.

type ObjectClassDisposeFieldCallback = Object -> IO ()

No description available in the introspection data.

dynamic_ObjectClassDisposeFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassDisposeFieldCallback -> a -> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ObjectClassDisposeFieldCallback :: MonadIO m => ObjectClassDisposeFieldCallback -> m (GClosure C_ObjectClassDisposeFieldCallback)

Wrap the callback into a GClosure.

mk_ObjectClassDisposeFieldCallback :: C_ObjectClassDisposeFieldCallback -> IO (FunPtr C_ObjectClassDisposeFieldCallback)

Generate a function pointer callable from C code, from a C_ObjectClassDisposeFieldCallback.

noObjectClassDisposeFieldCallback :: Maybe ObjectClassDisposeFieldCallback

A convenience synonym for Nothing :: Maybe ObjectClassDisposeFieldCallback.

wrap_ObjectClassDisposeFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassDisposeFieldCallback)) -> ObjectClassDisposeFieldCallback -> C_ObjectClassDisposeFieldCallback

Wrap a ObjectClassDisposeFieldCallback into a C_ObjectClassDisposeFieldCallback.

ObjectClassFinalizeFieldCallback

type C_ObjectClassFinalizeFieldCallback = Ptr Object -> IO ()

Type for the callback on the (unwrapped) C side.

type ObjectClassFinalizeFieldCallback = Object -> IO ()

No description available in the introspection data.

dynamic_ObjectClassFinalizeFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassFinalizeFieldCallback -> a -> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ObjectClassFinalizeFieldCallback :: MonadIO m => ObjectClassFinalizeFieldCallback -> m (GClosure C_ObjectClassFinalizeFieldCallback)

Wrap the callback into a GClosure.

mk_ObjectClassFinalizeFieldCallback :: C_ObjectClassFinalizeFieldCallback -> IO (FunPtr C_ObjectClassFinalizeFieldCallback)

Generate a function pointer callable from C code, from a C_ObjectClassFinalizeFieldCallback.

noObjectClassFinalizeFieldCallback :: Maybe ObjectClassFinalizeFieldCallback

A convenience synonym for Nothing :: Maybe ObjectClassFinalizeFieldCallback.

wrap_ObjectClassFinalizeFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassFinalizeFieldCallback)) -> ObjectClassFinalizeFieldCallback -> C_ObjectClassFinalizeFieldCallback

Wrap a ObjectClassFinalizeFieldCallback into a C_ObjectClassFinalizeFieldCallback.

ObjectClassGetPropertyFieldCallback

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

Type for the callback on the (unwrapped) C side.

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

No description available in the introspection data.

dynamic_ObjectClassGetPropertyFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassGetPropertyFieldCallback -> a -> Word32 -> GValue -> GParamSpec -> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ObjectClassGetPropertyFieldCallback :: MonadIO m => ObjectClassGetPropertyFieldCallback -> m (GClosure C_ObjectClassGetPropertyFieldCallback)

Wrap the callback into a GClosure.

mk_ObjectClassGetPropertyFieldCallback :: C_ObjectClassGetPropertyFieldCallback -> IO (FunPtr C_ObjectClassGetPropertyFieldCallback)

Generate a function pointer callable from C code, from a C_ObjectClassGetPropertyFieldCallback.

noObjectClassGetPropertyFieldCallback :: Maybe ObjectClassGetPropertyFieldCallback

A convenience synonym for Nothing :: Maybe ObjectClassGetPropertyFieldCallback.

wrap_ObjectClassGetPropertyFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassGetPropertyFieldCallback)) -> ObjectClassGetPropertyFieldCallback -> C_ObjectClassGetPropertyFieldCallback

Wrap a ObjectClassGetPropertyFieldCallback into a C_ObjectClassGetPropertyFieldCallback.

ObjectClassNotifyFieldCallback

type C_ObjectClassNotifyFieldCallback = Ptr Object -> Ptr GParamSpec -> IO ()

Type for the callback on the (unwrapped) C side.

type ObjectClassNotifyFieldCallback

Arguments

 = Object

object: a Object

-> GParamSpec

-> IO ()

No description available in the introspection data.

dynamic_ObjectClassNotifyFieldCallback

Arguments

:: (HasCallStack, MonadIO m, IsObject a)

=> FunPtr C_ObjectClassNotifyFieldCallback

-> a

object: a Object

-> GParamSpec

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ObjectClassNotifyFieldCallback :: MonadIO m => ObjectClassNotifyFieldCallback -> m (GClosure C_ObjectClassNotifyFieldCallback)

Wrap the callback into a GClosure.

mk_ObjectClassNotifyFieldCallback :: C_ObjectClassNotifyFieldCallback -> IO (FunPtr C_ObjectClassNotifyFieldCallback)

Generate a function pointer callable from C code, from a C_ObjectClassNotifyFieldCallback.

noObjectClassNotifyFieldCallback :: Maybe ObjectClassNotifyFieldCallback

A convenience synonym for Nothing :: Maybe ObjectClassNotifyFieldCallback.

wrap_ObjectClassNotifyFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassNotifyFieldCallback)) -> ObjectClassNotifyFieldCallback -> C_ObjectClassNotifyFieldCallback

Wrap a ObjectClassNotifyFieldCallback into a C_ObjectClassNotifyFieldCallback.

ObjectClassSetPropertyFieldCallback

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

Type for the callback on the (unwrapped) C side.

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

No description available in the introspection data.

dynamic_ObjectClassSetPropertyFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassSetPropertyFieldCallback -> a -> Word32 -> GValue -> GParamSpec -> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ObjectClassSetPropertyFieldCallback :: MonadIO m => ObjectClassSetPropertyFieldCallback -> m (GClosure C_ObjectClassSetPropertyFieldCallback)

Wrap the callback into a GClosure.

mk_ObjectClassSetPropertyFieldCallback :: C_ObjectClassSetPropertyFieldCallback -> IO (FunPtr C_ObjectClassSetPropertyFieldCallback)

Generate a function pointer callable from C code, from a C_ObjectClassSetPropertyFieldCallback.

noObjectClassSetPropertyFieldCallback :: Maybe ObjectClassSetPropertyFieldCallback

A convenience synonym for Nothing :: Maybe ObjectClassSetPropertyFieldCallback.

wrap_ObjectClassSetPropertyFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassSetPropertyFieldCallback)) -> ObjectClassSetPropertyFieldCallback -> C_ObjectClassSetPropertyFieldCallback

Wrap a ObjectClassSetPropertyFieldCallback into a C_ObjectClassSetPropertyFieldCallback.

ObjectFinalizeFunc

type C_ObjectFinalizeFunc = Ptr Object -> IO ()

Type for the callback on the (unwrapped) C side.

type ObjectFinalizeFunc

Arguments

 = Object

object: the Object being finalized

-> IO ()

The type of the finalize function of ObjectClass.

dynamic_ObjectFinalizeFunc

Arguments

:: (HasCallStack, MonadIO m, IsObject a)

=> FunPtr C_ObjectFinalizeFunc

-> a

object: the Object being finalized

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ObjectFinalizeFunc :: MonadIO m => ObjectFinalizeFunc -> m (GClosure C_ObjectFinalizeFunc)

Wrap the callback into a GClosure.

mk_ObjectFinalizeFunc :: C_ObjectFinalizeFunc -> IO (FunPtr C_ObjectFinalizeFunc)

Generate a function pointer callable from C code, from a C_ObjectFinalizeFunc.

noObjectFinalizeFunc :: Maybe ObjectFinalizeFunc

A convenience synonym for Nothing :: Maybe ObjectFinalizeFunc.

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

Wrap a ObjectFinalizeFunc into a C_ObjectFinalizeFunc.

ObjectGetPropertyFunc

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

Type for the callback on the (unwrapped) C side.

type ObjectGetPropertyFunc

Arguments

 = Object

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

-> IO ()

The type of the getProperty function of ObjectClass.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ObjectGetPropertyFunc :: MonadIO m => ObjectGetPropertyFunc -> m (GClosure C_ObjectGetPropertyFunc)

Wrap the callback into a GClosure.

mk_ObjectGetPropertyFunc :: C_ObjectGetPropertyFunc -> IO (FunPtr C_ObjectGetPropertyFunc)

Generate a function pointer callable from C code, from a C_ObjectGetPropertyFunc.

noObjectGetPropertyFunc :: Maybe ObjectGetPropertyFunc

A convenience synonym for Nothing :: Maybe ObjectGetPropertyFunc.

wrap_ObjectGetPropertyFunc :: Maybe (Ptr (FunPtr C_ObjectGetPropertyFunc)) -> ObjectGetPropertyFunc -> C_ObjectGetPropertyFunc

Wrap a ObjectGetPropertyFunc into a C_ObjectGetPropertyFunc.

ObjectSetPropertyFunc

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

Type for the callback on the (unwrapped) C side.

type ObjectSetPropertyFunc

Arguments

 = Object

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

-> IO ()

The type of the setProperty function of ObjectClass.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ObjectSetPropertyFunc :: MonadIO m => ObjectSetPropertyFunc -> m (GClosure C_ObjectSetPropertyFunc)

Wrap the callback into a GClosure.

mk_ObjectSetPropertyFunc :: C_ObjectSetPropertyFunc -> IO (FunPtr C_ObjectSetPropertyFunc)

Generate a function pointer callable from C code, from a C_ObjectSetPropertyFunc.

noObjectSetPropertyFunc :: Maybe ObjectSetPropertyFunc

A convenience synonym for Nothing :: Maybe ObjectSetPropertyFunc.

wrap_ObjectSetPropertyFunc :: Maybe (Ptr (FunPtr C_ObjectSetPropertyFunc)) -> ObjectSetPropertyFunc -> C_ObjectSetPropertyFunc

Wrap a ObjectSetPropertyFunc into a C_ObjectSetPropertyFunc.

ParamSpecTypeInfoFinalizeFieldCallback

type C_ParamSpecTypeInfoFinalizeFieldCallback = Ptr GParamSpec -> IO ()

Type for the callback on the (unwrapped) C side.

type ParamSpecTypeInfoFinalizeFieldCallback = GParamSpec -> IO ()

No description available in the introspection data.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ParamSpecTypeInfoFinalizeFieldCallback :: MonadIO m => ParamSpecTypeInfoFinalizeFieldCallback -> m (GClosure C_ParamSpecTypeInfoFinalizeFieldCallback)

Wrap the callback into a GClosure.

mk_ParamSpecTypeInfoFinalizeFieldCallback :: C_ParamSpecTypeInfoFinalizeFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback)

Generate a function pointer callable from C code, from a C_ParamSpecTypeInfoFinalizeFieldCallback.

noParamSpecTypeInfoFinalizeFieldCallback :: Maybe ParamSpecTypeInfoFinalizeFieldCallback

A convenience synonym for Nothing :: Maybe ParamSpecTypeInfoFinalizeFieldCallback.

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

Wrap a ParamSpecTypeInfoFinalizeFieldCallback into a C_ParamSpecTypeInfoFinalizeFieldCallback.

ParamSpecTypeInfoInstanceInitFieldCallback

type C_ParamSpecTypeInfoInstanceInitFieldCallback = Ptr GParamSpec -> IO ()

Type for the callback on the (unwrapped) C side.

type ParamSpecTypeInfoInstanceInitFieldCallback = GParamSpec -> IO ()

No description available in the introspection data.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ParamSpecTypeInfoInstanceInitFieldCallback :: MonadIO m => ParamSpecTypeInfoInstanceInitFieldCallback -> m (GClosure C_ParamSpecTypeInfoInstanceInitFieldCallback)

Wrap the callback into a GClosure.

mk_ParamSpecTypeInfoInstanceInitFieldCallback :: C_ParamSpecTypeInfoInstanceInitFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback)

Generate a function pointer callable from C code, from a C_ParamSpecTypeInfoInstanceInitFieldCallback.

noParamSpecTypeInfoInstanceInitFieldCallback :: Maybe ParamSpecTypeInfoInstanceInitFieldCallback

A convenience synonym for Nothing :: Maybe ParamSpecTypeInfoInstanceInitFieldCallback.

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

Wrap a ParamSpecTypeInfoInstanceInitFieldCallback into a C_ParamSpecTypeInfoInstanceInitFieldCallback.

ParamSpecTypeInfoValueSetDefaultFieldCallback

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

Type for the callback on the (unwrapped) C side.

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

No description available in the introspection data.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ParamSpecTypeInfoValueSetDefaultFieldCallback :: MonadIO m => ParamSpecTypeInfoValueSetDefaultFieldCallback -> m (GClosure C_ParamSpecTypeInfoValueSetDefaultFieldCallback)

Wrap the callback into a GClosure.

mk_ParamSpecTypeInfoValueSetDefaultFieldCallback :: C_ParamSpecTypeInfoValueSetDefaultFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback)

Generate a function pointer callable from C code, from a C_ParamSpecTypeInfoValueSetDefaultFieldCallback.

noParamSpecTypeInfoValueSetDefaultFieldCallback :: Maybe ParamSpecTypeInfoValueSetDefaultFieldCallback

A convenience synonym for Nothing :: Maybe ParamSpecTypeInfoValueSetDefaultFieldCallback.

wrap_ParamSpecTypeInfoValueSetDefaultFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback)) -> ParamSpecTypeInfoValueSetDefaultFieldCallback -> C_ParamSpecTypeInfoValueSetDefaultFieldCallback

Wrap a ParamSpecTypeInfoValueSetDefaultFieldCallback into a C_ParamSpecTypeInfoValueSetDefaultFieldCallback.

ParamSpecTypeInfoValueValidateFieldCallback

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

Type for the callback on the (unwrapped) C side.

type ParamSpecTypeInfoValueValidateFieldCallback = GParamSpec -> GValue -> IO Bool

No description available in the introspection data.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ParamSpecTypeInfoValueValidateFieldCallback :: MonadIO m => ParamSpecTypeInfoValueValidateFieldCallback -> m (GClosure C_ParamSpecTypeInfoValueValidateFieldCallback)

Wrap the callback into a GClosure.

mk_ParamSpecTypeInfoValueValidateFieldCallback :: C_ParamSpecTypeInfoValueValidateFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback)

Generate a function pointer callable from C code, from a C_ParamSpecTypeInfoValueValidateFieldCallback.

noParamSpecTypeInfoValueValidateFieldCallback :: Maybe ParamSpecTypeInfoValueValidateFieldCallback

A convenience synonym for Nothing :: Maybe ParamSpecTypeInfoValueValidateFieldCallback.

wrap_ParamSpecTypeInfoValueValidateFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback)) -> ParamSpecTypeInfoValueValidateFieldCallback -> C_ParamSpecTypeInfoValueValidateFieldCallback

Wrap a ParamSpecTypeInfoValueValidateFieldCallback into a C_ParamSpecTypeInfoValueValidateFieldCallback.

ParamSpecTypeInfoValuesCmpFieldCallback

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

Type for the callback on the (unwrapped) C side.

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

No description available in the introspection data.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ParamSpecTypeInfoValuesCmpFieldCallback :: MonadIO m => ParamSpecTypeInfoValuesCmpFieldCallback -> m (GClosure C_ParamSpecTypeInfoValuesCmpFieldCallback)

Wrap the callback into a GClosure.

mk_ParamSpecTypeInfoValuesCmpFieldCallback :: C_ParamSpecTypeInfoValuesCmpFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback)

Generate a function pointer callable from C code, from a C_ParamSpecTypeInfoValuesCmpFieldCallback.

noParamSpecTypeInfoValuesCmpFieldCallback :: Maybe ParamSpecTypeInfoValuesCmpFieldCallback

A convenience synonym for Nothing :: Maybe ParamSpecTypeInfoValuesCmpFieldCallback.

wrap_ParamSpecTypeInfoValuesCmpFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback)) -> ParamSpecTypeInfoValuesCmpFieldCallback -> C_ParamSpecTypeInfoValuesCmpFieldCallback

Wrap a ParamSpecTypeInfoValuesCmpFieldCallback into a C_ParamSpecTypeInfoValuesCmpFieldCallback.

SignalAccumulator

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

Type for the callback on the (unwrapped) C side.

type SignalAccumulator

Arguments

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

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

The signal accumulator is a special callback function that can be used to collect return values of the various callbacks that are called during a signal emission. The signal accumulator is specified at signal creation time, if it is left Nothing, no accumulation of callback return values is performed. The return value of signal emissions is then the value returned by the last callback.

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.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_SignalAccumulator :: MonadIO m => SignalAccumulator -> m (GClosure C_SignalAccumulator)

Wrap the callback into a GClosure.

mk_SignalAccumulator :: C_SignalAccumulator -> IO (FunPtr C_SignalAccumulator)

Generate a function pointer callable from C code, from a C_SignalAccumulator.

noSignalAccumulator :: Maybe SignalAccumulator

A convenience synonym for Nothing :: Maybe SignalAccumulator.

wrap_SignalAccumulator :: Maybe (Ptr (FunPtr C_SignalAccumulator)) -> SignalAccumulator -> C_SignalAccumulator

Wrap a SignalAccumulator into a C_SignalAccumulator.

SignalEmissionHook

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

Type for the callback on the (unwrapped) C side.

type SignalEmissionHook

Arguments

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

-> IO Bool

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

A simple function pointer to get invoked when the signal is emitted. This allows you to tie a hook to the signal type, so that it will trap all emissions of that signal, from any object.

You may not attach these to signals created with the G_SIGNAL_NO_HOOKS flag.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_SignalEmissionHook :: MonadIO m => SignalEmissionHook -> m (GClosure C_SignalEmissionHook)

Wrap the callback into a GClosure.

mk_SignalEmissionHook :: C_SignalEmissionHook -> IO (FunPtr C_SignalEmissionHook)

Generate a function pointer callable from C code, from a C_SignalEmissionHook.

noSignalEmissionHook :: Maybe SignalEmissionHook

A convenience synonym for Nothing :: Maybe SignalEmissionHook.

wrap_SignalEmissionHook :: Maybe (Ptr (FunPtr C_SignalEmissionHook)) -> SignalEmissionHook -> C_SignalEmissionHook

Wrap a SignalEmissionHook into a C_SignalEmissionHook.

ToggleNotify

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

Type for the callback on the (unwrapped) C side.

type ToggleNotify

Arguments

 = Ptr ()

data: Callback data passed to g_object_add_toggle_ref()

-> Object

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.

-> IO ()

A callback function used for notification when the state of a toggle reference changes. See g_object_add_toggle_ref().

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ToggleNotify :: MonadIO m => ToggleNotify -> m (GClosure C_ToggleNotify)

Wrap the callback into a GClosure.

mk_ToggleNotify :: C_ToggleNotify -> IO (FunPtr C_ToggleNotify)

Generate a function pointer callable from C code, from a C_ToggleNotify.

noToggleNotify :: Maybe ToggleNotify

A convenience synonym for Nothing :: Maybe ToggleNotify.

wrap_ToggleNotify :: Maybe (Ptr (FunPtr C_ToggleNotify)) -> ToggleNotify -> C_ToggleNotify

Wrap a ToggleNotify into a C_ToggleNotify.

TypeClassCacheFunc

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

Type for the callback on the (unwrapped) C side.

type TypeClassCacheFunc

Arguments

 = Ptr ()

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

-> TypeClass

gClass: The TypeClass structure which is unreferenced

-> IO Bool

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

A callback function which is called when the reference count of a class drops to zero. It may use typeClassRef to prevent the class from being freed. You should not call typeClassUnref from a TypeClassCacheFunc function to prevent infinite recursion, use g_type_class_unref_uncached() instead.

The functions have to check the class id passed in to figure whether they actually want to cache the class of this type, since all classes are routed through the same TypeClassCacheFunc chain.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypeClassCacheFunc :: MonadIO m => TypeClassCacheFunc -> m (GClosure C_TypeClassCacheFunc)

Wrap the callback into a GClosure.

mk_TypeClassCacheFunc :: C_TypeClassCacheFunc -> IO (FunPtr C_TypeClassCacheFunc)

Generate a function pointer callable from C code, from a C_TypeClassCacheFunc.

noTypeClassCacheFunc :: Maybe TypeClassCacheFunc

A convenience synonym for Nothing :: Maybe TypeClassCacheFunc.

wrap_TypeClassCacheFunc :: Maybe (Ptr (FunPtr C_TypeClassCacheFunc)) -> TypeClassCacheFunc -> C_TypeClassCacheFunc

Wrap a TypeClassCacheFunc into a C_TypeClassCacheFunc.

TypeInterfaceCheckFunc

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

Type for the callback on the (unwrapped) C side.

type TypeInterfaceCheckFunc

Arguments

 = Ptr ()

checkData: data passed to g_type_add_interface_check()

-> TypeInterface

gIface: the interface that has been initialized

-> IO ()

A callback called after an interface vtable is initialized. See g_type_add_interface_check().

Since: 2.4

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypeInterfaceCheckFunc :: MonadIO m => TypeInterfaceCheckFunc -> m (GClosure C_TypeInterfaceCheckFunc)

Wrap the callback into a GClosure.

mk_TypeInterfaceCheckFunc :: C_TypeInterfaceCheckFunc -> IO (FunPtr C_TypeInterfaceCheckFunc)

Generate a function pointer callable from C code, from a C_TypeInterfaceCheckFunc.

noTypeInterfaceCheckFunc :: Maybe TypeInterfaceCheckFunc

A convenience synonym for Nothing :: Maybe TypeInterfaceCheckFunc.

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

Wrap a TypeInterfaceCheckFunc into a C_TypeInterfaceCheckFunc.

TypePluginCompleteInterfaceInfo

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

Type for the callback on the (unwrapped) C side.

type TypePluginCompleteInterfaceInfo

Arguments

 = TypePlugin

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

-> IO ()

The type of the completeInterfaceInfo function of GTypePluginClass.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypePluginCompleteInterfaceInfo :: MonadIO m => TypePluginCompleteInterfaceInfo -> m (GClosure C_TypePluginCompleteInterfaceInfo)

Wrap the callback into a GClosure.

mk_TypePluginCompleteInterfaceInfo :: C_TypePluginCompleteInterfaceInfo -> IO (FunPtr C_TypePluginCompleteInterfaceInfo)

Generate a function pointer callable from C code, from a C_TypePluginCompleteInterfaceInfo.

noTypePluginCompleteInterfaceInfo :: Maybe TypePluginCompleteInterfaceInfo

A convenience synonym for Nothing :: Maybe TypePluginCompleteInterfaceInfo.

wrap_TypePluginCompleteInterfaceInfo :: Maybe (Ptr (FunPtr C_TypePluginCompleteInterfaceInfo)) -> TypePluginCompleteInterfaceInfo -> C_TypePluginCompleteInterfaceInfo

Wrap a TypePluginCompleteInterfaceInfo into a C_TypePluginCompleteInterfaceInfo.

TypePluginCompleteTypeInfo

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

Type for the callback on the (unwrapped) C side.

type TypePluginCompleteTypeInfo

Arguments

 = TypePlugin

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

-> IO ()

The type of the completeTypeInfo function of GTypePluginClass.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypePluginCompleteTypeInfo :: MonadIO m => TypePluginCompleteTypeInfo -> m (GClosure C_TypePluginCompleteTypeInfo)

Wrap the callback into a GClosure.

mk_TypePluginCompleteTypeInfo :: C_TypePluginCompleteTypeInfo -> IO (FunPtr C_TypePluginCompleteTypeInfo)

Generate a function pointer callable from C code, from a C_TypePluginCompleteTypeInfo.

noTypePluginCompleteTypeInfo :: Maybe TypePluginCompleteTypeInfo

A convenience synonym for Nothing :: Maybe TypePluginCompleteTypeInfo.

wrap_TypePluginCompleteTypeInfo :: Maybe (Ptr (FunPtr C_TypePluginCompleteTypeInfo)) -> TypePluginCompleteTypeInfo -> C_TypePluginCompleteTypeInfo

Wrap a TypePluginCompleteTypeInfo into a C_TypePluginCompleteTypeInfo.

TypePluginUnuse

type C_TypePluginUnuse = Ptr TypePlugin -> IO ()

Type for the callback on the (unwrapped) C side.

type TypePluginUnuse

Arguments

 = TypePlugin

plugin: the TypePlugin whose use count should be decreased

-> IO ()

The type of the unusePlugin function of GTypePluginClass.

dynamic_TypePluginUnuse

Arguments

:: (HasCallStack, MonadIO m, IsTypePlugin a)

=> FunPtr C_TypePluginUnuse

-> a

plugin: the TypePlugin whose use count should be decreased

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypePluginUnuse :: MonadIO m => TypePluginUnuse -> m (GClosure C_TypePluginUnuse)

Wrap the callback into a GClosure.

mk_TypePluginUnuse :: C_TypePluginUnuse -> IO (FunPtr C_TypePluginUnuse)

Generate a function pointer callable from C code, from a C_TypePluginUnuse.

noTypePluginUnuse :: Maybe TypePluginUnuse

A convenience synonym for Nothing :: Maybe TypePluginUnuse.

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

Wrap a TypePluginUnuse into a C_TypePluginUnuse.

TypePluginUse

type C_TypePluginUse = Ptr TypePlugin -> IO ()

Type for the callback on the (unwrapped) C side.

type TypePluginUse

Arguments

 = TypePlugin

plugin: the TypePlugin whose use count should be increased

-> IO ()

The type of the usePlugin function of GTypePluginClass, which gets called to increase the use count of plugin.

dynamic_TypePluginUse

Arguments

:: (HasCallStack, MonadIO m, IsTypePlugin a)

=> FunPtr C_TypePluginUse

-> a

plugin: the TypePlugin whose use count should be increased

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypePluginUse :: MonadIO m => TypePluginUse -> m (GClosure C_TypePluginUse)

Wrap the callback into a GClosure.

mk_TypePluginUse :: C_TypePluginUse -> IO (FunPtr C_TypePluginUse)

Generate a function pointer callable from C code, from a C_TypePluginUse.

noTypePluginUse :: Maybe TypePluginUse

A convenience synonym for Nothing :: Maybe TypePluginUse.

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

Wrap a TypePluginUse into a C_TypePluginUse.

TypeValueTableCollectValueFieldCallback

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

Type for the callback on the (unwrapped) C side.

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

No description available in the introspection data.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypeValueTableCollectValueFieldCallback :: MonadIO m => TypeValueTableCollectValueFieldCallback -> m (GClosure C_TypeValueTableCollectValueFieldCallback)

Wrap the callback into a GClosure.

mk_TypeValueTableCollectValueFieldCallback :: C_TypeValueTableCollectValueFieldCallback -> IO (FunPtr C_TypeValueTableCollectValueFieldCallback)

Generate a function pointer callable from C code, from a C_TypeValueTableCollectValueFieldCallback.

noTypeValueTableCollectValueFieldCallback :: Maybe TypeValueTableCollectValueFieldCallback

A convenience synonym for Nothing :: Maybe TypeValueTableCollectValueFieldCallback.

wrap_TypeValueTableCollectValueFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableCollectValueFieldCallback)) -> TypeValueTableCollectValueFieldCallback -> C_TypeValueTableCollectValueFieldCallback

Wrap a TypeValueTableCollectValueFieldCallback into a C_TypeValueTableCollectValueFieldCallback.

TypeValueTableLcopyValueFieldCallback

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

Type for the callback on the (unwrapped) C side.

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

No description available in the introspection data.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypeValueTableLcopyValueFieldCallback :: MonadIO m => TypeValueTableLcopyValueFieldCallback -> m (GClosure C_TypeValueTableLcopyValueFieldCallback)

Wrap the callback into a GClosure.

mk_TypeValueTableLcopyValueFieldCallback :: C_TypeValueTableLcopyValueFieldCallback -> IO (FunPtr C_TypeValueTableLcopyValueFieldCallback)

Generate a function pointer callable from C code, from a C_TypeValueTableLcopyValueFieldCallback.

noTypeValueTableLcopyValueFieldCallback :: Maybe TypeValueTableLcopyValueFieldCallback

A convenience synonym for Nothing :: Maybe TypeValueTableLcopyValueFieldCallback.

wrap_TypeValueTableLcopyValueFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableLcopyValueFieldCallback)) -> TypeValueTableLcopyValueFieldCallback -> C_TypeValueTableLcopyValueFieldCallback

Wrap a TypeValueTableLcopyValueFieldCallback into a C_TypeValueTableLcopyValueFieldCallback.

TypeValueTableValueCopyFieldCallback

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

Type for the callback on the (unwrapped) C side.

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

No description available in the introspection data.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypeValueTableValueCopyFieldCallback :: MonadIO m => TypeValueTableValueCopyFieldCallback -> m (GClosure C_TypeValueTableValueCopyFieldCallback)

Wrap the callback into a GClosure.

mk_TypeValueTableValueCopyFieldCallback :: C_TypeValueTableValueCopyFieldCallback -> IO (FunPtr C_TypeValueTableValueCopyFieldCallback)

Generate a function pointer callable from C code, from a C_TypeValueTableValueCopyFieldCallback.

noTypeValueTableValueCopyFieldCallback :: Maybe TypeValueTableValueCopyFieldCallback

A convenience synonym for Nothing :: Maybe TypeValueTableValueCopyFieldCallback.

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

Wrap a TypeValueTableValueCopyFieldCallback into a C_TypeValueTableValueCopyFieldCallback.

TypeValueTableValueFreeFieldCallback

type C_TypeValueTableValueFreeFieldCallback = Ptr GValue -> IO ()

Type for the callback on the (unwrapped) C side.

type TypeValueTableValueFreeFieldCallback = GValue -> IO ()

No description available in the introspection data.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypeValueTableValueFreeFieldCallback :: MonadIO m => TypeValueTableValueFreeFieldCallback -> m (GClosure C_TypeValueTableValueFreeFieldCallback)

Wrap the callback into a GClosure.

mk_TypeValueTableValueFreeFieldCallback :: C_TypeValueTableValueFreeFieldCallback -> IO (FunPtr C_TypeValueTableValueFreeFieldCallback)

Generate a function pointer callable from C code, from a C_TypeValueTableValueFreeFieldCallback.

noTypeValueTableValueFreeFieldCallback :: Maybe TypeValueTableValueFreeFieldCallback

A convenience synonym for Nothing :: Maybe TypeValueTableValueFreeFieldCallback.

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

Wrap a TypeValueTableValueFreeFieldCallback into a C_TypeValueTableValueFreeFieldCallback.

TypeValueTableValueInitFieldCallback

type C_TypeValueTableValueInitFieldCallback = Ptr GValue -> IO ()

Type for the callback on the (unwrapped) C side.

type TypeValueTableValueInitFieldCallback = GValue -> IO ()

No description available in the introspection data.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypeValueTableValueInitFieldCallback :: MonadIO m => TypeValueTableValueInitFieldCallback -> m (GClosure C_TypeValueTableValueInitFieldCallback)

Wrap the callback into a GClosure.

mk_TypeValueTableValueInitFieldCallback :: C_TypeValueTableValueInitFieldCallback -> IO (FunPtr C_TypeValueTableValueInitFieldCallback)

Generate a function pointer callable from C code, from a C_TypeValueTableValueInitFieldCallback.

noTypeValueTableValueInitFieldCallback :: Maybe TypeValueTableValueInitFieldCallback

A convenience synonym for Nothing :: Maybe TypeValueTableValueInitFieldCallback.

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

Wrap a TypeValueTableValueInitFieldCallback into a C_TypeValueTableValueInitFieldCallback.

TypeValueTableValuePeekPointerFieldCallback

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

Type for the callback on the (unwrapped) C side.

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

No description available in the introspection data.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_TypeValueTableValuePeekPointerFieldCallback :: MonadIO m => TypeValueTableValuePeekPointerFieldCallback -> m (GClosure C_TypeValueTableValuePeekPointerFieldCallback)

Wrap the callback into a GClosure.

mk_TypeValueTableValuePeekPointerFieldCallback :: C_TypeValueTableValuePeekPointerFieldCallback -> IO (FunPtr C_TypeValueTableValuePeekPointerFieldCallback)

Generate a function pointer callable from C code, from a C_TypeValueTableValuePeekPointerFieldCallback.

noTypeValueTableValuePeekPointerFieldCallback :: Maybe TypeValueTableValuePeekPointerFieldCallback

A convenience synonym for Nothing :: Maybe TypeValueTableValuePeekPointerFieldCallback.

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

Wrap a TypeValueTableValuePeekPointerFieldCallback into a C_TypeValueTableValuePeekPointerFieldCallback.

ValueTransform

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

Type for the callback on the (unwrapped) C side.

type ValueTransform

Arguments

 = GValue

srcValue: Source value.

-> GValue

destValue: Target value.

-> IO ()

The type of value transformation functions which can be registered with g_value_register_transform_func().

destValue will be initialized to the correct destination type.

dynamic_ValueTransform

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_ValueTransform

-> GValue

srcValue: Source value.

-> GValue

destValue: Target value.

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_ValueTransform :: MonadIO m => ValueTransform -> m (GClosure C_ValueTransform)

Wrap the callback into a GClosure.

mk_ValueTransform :: C_ValueTransform -> IO (FunPtr C_ValueTransform)

Generate a function pointer callable from C code, from a C_ValueTransform.

noValueTransform :: Maybe ValueTransform

A convenience synonym for Nothing :: Maybe ValueTransform.

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

Wrap a ValueTransform into a C_ValueTransform.

WeakNotify

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

Type for the callback on the (unwrapped) C side.

type WeakNotify

Arguments

 = Ptr ()

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

-> Object

whereTheObjectWas: the object being finalized

-> IO ()

A WeakNotify function can be added to an object as a callback that gets triggered when the object is finalized. Since the object is already being finalized when the WeakNotify is called, there's not much you could do with the object, apart from e.g. using its address as hash-index or the like.

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

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_WeakNotify :: MonadIO m => WeakNotify -> m (GClosure C_WeakNotify)

Wrap the callback into a GClosure.

mk_WeakNotify :: C_WeakNotify -> IO (FunPtr C_WeakNotify)

Generate a function pointer callable from C code, from a C_WeakNotify.

noWeakNotify :: Maybe WeakNotify

A convenience synonym for Nothing :: Maybe WeakNotify.

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

Wrap a WeakNotify into a C_WeakNotify.