Signals

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 for the callback on the (unwrapped) C side.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe BaseFinalizeFunc.

Wrap a BaseFinalizeFunc into a C_BaseFinalizeFunc.

A callback function used by the type system to do base initialization of the class structures of derived types.

This function 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 for the callback on the (unwrapped) C side.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe BaseInitFunc.

Wrap a BaseInitFunc into a C_BaseInitFunc.

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

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 for the callback on the (unwrapped) C side.

A simple wrapper that ignores the closure arguments.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe BindingTransformFunc.

A convenience synonym for Nothing :: Maybe BindingTransformFunc_WithClosures.

Wrap a BindingTransformFunc into a C_BindingTransformFunc.

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

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

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe BoxedCopyFunc.

Wrap a BoxedCopyFunc into a C_BoxedCopyFunc.

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

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

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe BoxedFreeFunc.

Wrap a BoxedFreeFunc into a C_BoxedFreeFunc.

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

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.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe Callback.

Wrap a Callback into a C_Callback.

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

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

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ClassFinalizeFunc.

Wrap a ClassFinalizeFunc into a C_ClassFinalizeFunc.

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

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.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ClassInitFunc.

Wrap a ClassInitFunc into a C_ClassInitFunc.

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

The type used for marshaller functions.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ClosureMarshal.

Wrap a ClosureMarshal into a C_ClosureMarshal.

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

No description available in the introspection data.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ClosureMarshalFieldCallback.

Wrap a ClosureMarshalFieldCallback into a C_ClosureMarshalFieldCallback.

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

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

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ClosureNotify.

Wrap a ClosureNotify into a C_ClosureNotify.

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

No description available in the introspection data.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe InitiallyUnownedClassConstructedFieldCallback.

Wrap a InitiallyUnownedClassConstructedFieldCallback into a C_InitiallyUnownedClassConstructedFieldCallback.

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

No description available in the introspection data.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe InitiallyUnownedClassDispatchPropertiesChangedFieldCallback.

Wrap a InitiallyUnownedClassDispatchPropertiesChangedFieldCallback into a C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback.

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

No description available in the introspection data.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe InitiallyUnownedClassDisposeFieldCallback.

Wrap a InitiallyUnownedClassDisposeFieldCallback into a C_InitiallyUnownedClassDisposeFieldCallback.

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

No description available in the introspection data.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe InitiallyUnownedClassFinalizeFieldCallback.

Wrap a InitiallyUnownedClassFinalizeFieldCallback into a C_InitiallyUnownedClassFinalizeFieldCallback.

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

No description available in the introspection data.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe InitiallyUnownedClassGetPropertyFieldCallback.

Wrap a InitiallyUnownedClassGetPropertyFieldCallback into a C_InitiallyUnownedClassGetPropertyFieldCallback.

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

No description available in the introspection data.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe InitiallyUnownedClassNotifyFieldCallback.

Wrap a InitiallyUnownedClassNotifyFieldCallback into a C_InitiallyUnownedClassNotifyFieldCallback.

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

No description available in the introspection data.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe InitiallyUnownedClassSetPropertyFieldCallback.

Wrap a InitiallyUnownedClassSetPropertyFieldCallback into a C_InitiallyUnownedClassSetPropertyFieldCallback.

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

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.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe InstanceInitFunc.

Wrap a InstanceInitFunc into a C_InstanceInitFunc.

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

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.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe InterfaceFinalizeFunc.

Wrap a InterfaceFinalizeFunc into a C_InterfaceFinalizeFunc.

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

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.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe InterfaceInitFunc.

Wrap a InterfaceInitFunc into a C_InterfaceInitFunc.

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

No description available in the introspection data.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ObjectClassConstructedFieldCallback.

Wrap a ObjectClassConstructedFieldCallback into a C_ObjectClassConstructedFieldCallback.

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

No description available in the introspection data.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ObjectClassDispatchPropertiesChangedFieldCallback.

Wrap a ObjectClassDispatchPropertiesChangedFieldCallback into a C_ObjectClassDispatchPropertiesChangedFieldCallback.

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

No description available in the introspection data.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ObjectClassDisposeFieldCallback.

Wrap a ObjectClassDisposeFieldCallback into a C_ObjectClassDisposeFieldCallback.

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

No description available in the introspection data.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ObjectClassFinalizeFieldCallback.

Wrap a ObjectClassFinalizeFieldCallback into a C_ObjectClassFinalizeFieldCallback.

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

No description available in the introspection data.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ObjectClassGetPropertyFieldCallback.

Wrap a ObjectClassGetPropertyFieldCallback into a C_ObjectClassGetPropertyFieldCallback.

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

No description available in the introspection data.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ObjectClassNotifyFieldCallback.

Wrap a ObjectClassNotifyFieldCallback into a C_ObjectClassNotifyFieldCallback.

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

No description available in the introspection data.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ObjectClassSetPropertyFieldCallback.

Wrap a ObjectClassSetPropertyFieldCallback into a C_ObjectClassSetPropertyFieldCallback.

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

The type of the finalize function of ObjectClass.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ObjectFinalizeFunc.

Wrap a ObjectFinalizeFunc into a C_ObjectFinalizeFunc.

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

The type of the getProperty function of ObjectClass.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ObjectGetPropertyFunc.

Wrap a ObjectGetPropertyFunc into a C_ObjectGetPropertyFunc.

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

The type of the setProperty function of ObjectClass.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ObjectSetPropertyFunc.

Wrap a ObjectSetPropertyFunc into a C_ObjectSetPropertyFunc.

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

No description available in the introspection data.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ParamSpecTypeInfoFinalizeFieldCallback.

Wrap a ParamSpecTypeInfoFinalizeFieldCallback into a C_ParamSpecTypeInfoFinalizeFieldCallback.

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

No description available in the introspection data.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ParamSpecTypeInfoInstanceInitFieldCallback.

Wrap a ParamSpecTypeInfoInstanceInitFieldCallback into a C_ParamSpecTypeInfoInstanceInitFieldCallback.

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

No description available in the introspection data.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ParamSpecTypeInfoValueSetDefaultFieldCallback.

Wrap a ParamSpecTypeInfoValueSetDefaultFieldCallback into a C_ParamSpecTypeInfoValueSetDefaultFieldCallback.

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

No description available in the introspection data.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ParamSpecTypeInfoValueValidateFieldCallback.

Wrap a ParamSpecTypeInfoValueValidateFieldCallback into a C_ParamSpecTypeInfoValueValidateFieldCallback.

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

No description available in the introspection data.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ParamSpecTypeInfoValuesCmpFieldCallback.

Wrap a ParamSpecTypeInfoValuesCmpFieldCallback into a C_ParamSpecTypeInfoValuesCmpFieldCallback.

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

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.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe SignalAccumulator.

Wrap a SignalAccumulator into a C_SignalAccumulator.

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

A simple function pointer to get invoked when the signal is emitted.

Emission hooks allow 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 SignalFlagsNoHooks flag.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe SignalEmissionHook.

Wrap a SignalEmissionHook into a C_SignalEmissionHook.

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

A callback function used for notification when the state of a toggle reference changes.

See also: g_object_add_toggle_ref()

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe ToggleNotify.

Wrap a ToggleNotify into a C_ToggleNotify.

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

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.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe TypeClassCacheFunc.

Wrap a TypeClassCacheFunc into a C_TypeClassCacheFunc.

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

A callback called after an interface vtable is initialized.

See g_type_add_interface_check().

Since: 2.4

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe TypeInterfaceCheckFunc.

Wrap a TypeInterfaceCheckFunc into a C_TypeInterfaceCheckFunc.

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

The type of the completeInterfaceInfo function of GTypePluginClass.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe TypePluginCompleteInterfaceInfo.

Wrap a TypePluginCompleteInterfaceInfo into a C_TypePluginCompleteInterfaceInfo.

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

The type of the completeTypeInfo function of GTypePluginClass.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe TypePluginCompleteTypeInfo.

Wrap a TypePluginCompleteTypeInfo into a C_TypePluginCompleteTypeInfo.

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

The type of the unusePlugin function of GTypePluginClass.

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe TypePluginUnuse.

Wrap a TypePluginUnuse into a C_TypePluginUnuse.

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

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

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe TypePluginUse.

Wrap a TypePluginUse into a C_TypePluginUse.

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

This function is responsible for converting the values collected from a variadic argument list into contents suitable for storage in a Value.

This function should setup value similar to TypeValueInitFunc; e.g. for a string value that does not allow NULL pointers, it needs to either emit an error, or do an implicit conversion by storing an empty string.

The value passed in to this function has a zero-filled data array, so just like for TypeValueInitFunc it is guaranteed to not contain any old contents that might need freeing.

The nCollectValues argument is the string length of the collect_format field of TypeValueTable, and collect_values is an array of TypeCValue with length of nCollectValues, containing the collected values according to collect_format.

The collectFlags argument provided as a hint by the caller. It may contain the flag VALUE_NOCOPY_CONTENTS indicating that the collected value contents may be considered ‘static’ for the duration of the value lifetime. Thus an extra copy of the contents stored in collectValues is not required for assignment to value.

For our above string example, we continue with:

C code

if (!collect_values[0].v_pointer)
  value->data[0].v_pointer = g_strdup ("");
else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
  {
    value->data[0].v_pointer = collect_values[0].v_pointer;
    // keep a flag for the value_free() implementation to not free this string
    value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
  }
else
  value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer);
return NULL;

It should be noted, that it is generally a bad idea to follow the VALUE_NOCOPY_CONTENTS hint for reference counted types. Due to reentrancy requirements and reference count assertions performed by the signal emission code, reference counts should always be incremented for reference counted contents stored in the value->data array. To deviate from our string example for a moment, and taking a look at an exemplary implementation for GTypeValueTable.collect_value() of GObject:

C code

GObject *object = G_OBJECT (collect_values[0].v_pointer);
g_return_val_if_fail (object != NULL,
   g_strdup_printf ("Object %p passed as invalid NULL pointer", object));
// never honour G_VALUE_NOCOPY_CONTENTS for ref-counted types
value->data[0].v_pointer = g_object_ref (object);
return NULL;

The reference count for valid objects is always incremented, regardless of collect_flags. For invalid objects, the example returns a newly allocated string without altering value.

Upon success, collect_value() needs to return NULL. If, however, an error condition occurred, collect_value() should return a newly allocated string containing an error diagnostic.

The calling code makes no assumptions about the value contents being valid upon error returns, value is simply thrown away without further freeing. As such, it is a good idea to not allocate GValue contents prior to returning an error; however, collect_values() is not obliged to return a correctly setup value for error returns, simply because any non-NULL return is considered a fatal programming error, and further program behaviour is undefined.

Since: 2.78

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe TypeValueCollectFunc.

Wrap a TypeValueCollectFunc into a C_TypeValueCollectFunc.

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

Copies the content of a Value into another.

The destValue is a Value with zero-filled data section and srcValue is a properly initialized Value of same type, or derived type.

The purpose of this function is to copy the contents of srcValue into destValue in a way, that even after srcValue has been freed, the contents of destValue remain valid. String type example:

C code

dest_value->data[0].v_pointer = g_strdup (src_value->data[0].v_pointer);

Since: 2.78

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe TypeValueCopyFunc.

Wrap a TypeValueCopyFunc into a C_TypeValueCopyFunc.

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

Frees any old contents that might be left in the value->data array of the given value.

No resources may remain allocated through the Value contents after this function returns. E.g. for our above string type:

C code

// only free strings without a specific flag for static storage
if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))
  g_free (value->data[0].v_pointer);

Since: 2.78

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe TypeValueFreeFunc.

Wrap a TypeValueFreeFunc into a C_TypeValueFreeFunc.

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

Initializes the value contents by setting the fields of the value->data array.

The data array of the Value passed into this function was zero-filled with memset(), so no care has to be taken to free any old contents. For example, in the case of a string value that may never be Nothing, the implementation might look like:

C code

value->data[0].v_pointer = g_strdup ("");

Since: 2.78

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

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe TypeValueInitFunc.

Wrap a TypeValueInitFunc into a C_TypeValueInitFunc.

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

This function is responsible for storing the value contents into arguments passed through a variadic argument list which got collected into collect_values according to lcopy_format.

The n_collect_values argument equals the string length of lcopy_format, and collect_flags may contain VALUE_NOCOPY_CONTENTS.

In contrast to TypeValueCollectFunc, this function is obliged to always properly support VALUE_NOCOPY_CONTENTS.

Similar to TypeValueCollectFunc the function may prematurely abort by returning a newly allocated string describing an error condition. To complete the string example:

C code

gchar **string_p = collect_values[0].v_pointer;
g_return_val_if_fail (string_p != NULL,
  g_strdup ("string location passed as NULL"));

if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
  *string_p = value->data[0].v_pointer;
else
  *string_p = g_strdup (value->data[0].v_pointer);

And an illustrative version of this function for reference-counted types:

C code

GObject **object_p = collect_values[0].v_pointer;
g_return_val_if_fail (object_p != NULL,
  g_strdup ("object location passed as NULL"));

if (value->data[0].v_pointer == NULL)
  *object_p = NULL;
else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) // always honour
  *object_p = value->data[0].v_pointer;
else
  *object_p = g_object_ref (value->data[0].v_pointer);

return NULL;

Since: 2.78

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