Closure

A #GClosure represents a callback supplied by the programmer. It will generally comprise a function of some kind and a marshaller used to call it. It is the responsibility of the marshaller to convert the arguments for the invocation from #GValues into a suitable form, perform the callback on the converted arguments, and transform the return value back into a #GValue.

In the case of C programs, a closure usually just holds a pointer to a function and maybe a data argument, and the marshaller converts between #GValue and native C types. The GObject library provides the #GCClosure type for this purpose. Bindings for other languages need marshallers which convert between #GValues and suitable representations in the runtime of the language in order to use functions written in that languages as callbacks.

Within GObject, closures play an important role in the implementation of signals. When a signal is registered, the @c_marshaller argument to g_signal_new() specifies the default C marshaller for any closure which is connected to this signal. GObject provides a number of C marshallers for this purpose, see the g_cclosure_marshal_*() functions. Additional C marshallers can be generated with the [glib-genmarshal][glib-genmarshal] utility. Closures can be explicitly connected to signals with g_signal_connect_closure(), but it usually more convenient to let GObject create a closure automatically by using one of the g_signal_connect_*() functions which take a callback function/user data pair.

Using closures has a number of important advantages over a simple callback function/data pointer combination:

- Closures allow the callee to get the types of the callback parameters, which means that language bindings don't have to write individual glue for each callback type.

- The reference counting of #GClosure makes it easy to handle reentrancy right; if a callback is removed while it is being invoked, the closure and its parameters won't be freed until the invocation finishes.

- g_closure_invalidate() and invalidation notifiers allow callbacks to be automatically removed when the objects they point to go away.

Constructors

this
this(GClosure* gClosure, bool ownedRef)

Sets our main struct and passes it to the parent class.

this
this(uint sizeofClosure, ObjectG object)

A variant of g_closure_new_simple() which stores @object in the @data field of the closure and calls g_object_watch_closure() on @object and the created closure. This function is mainly useful when implementing new types of closures.

this
this(uint sizeofClosure, void* data)

Allocates a struct of the given size and initializes the initial part as a #GClosure. This function is mainly useful when implementing new types of closures.

Destructor

~this
~this()
Undocumented in source.

Members

Functions

addFinalizeNotifier
void addFinalizeNotifier(void* notifyData, GClosureNotify notifyFunc)

Registers a finalization notifier which will be called when the reference count of @closure goes down to 0. Multiple finalization notifiers on a single closure are invoked in unspecified order. If a single call to g_closure_unref() results in the closure being both invalidated and finalized, then the invalidate notifiers will be run before the finalize notifiers.

addInvalidateNotifier
void addInvalidateNotifier(void* notifyData, GClosureNotify notifyFunc)

Registers an invalidation notifier which will be called when the @closure is invalidated with g_closure_invalidate(). Invalidation notifiers are invoked before finalization notifiers, in an unspecified order.

addMarshalGuards
void addMarshalGuards(void* preMarshalData, GClosureNotify preMarshalNotify, void* postMarshalData, GClosureNotify postMarshalNotify)

Adds a pair of notifiers which get invoked before and after the closure callback, respectively. This is typically used to protect the extra arguments for the duration of the callback. See g_object_watch_closure() for an example of marshal guards.

doref
Closure doref()

Increments the reference count on a closure to force it staying alive while the caller holds a pointer to it.

getClosureStruct
GClosure* getClosureStruct(bool transferOwnership)

Get the main Gtk struct

getStruct
void* getStruct()

the main Gtk struct as a void*

invalidate
void invalidate()

Sets a flag on the closure to indicate that its calling environment has become invalid, and thus causes any future invocations of g_closure_invoke() on this @closure to be ignored. Also, invalidation notifiers installed on the closure will be called at this point. Note that unless you are holding a reference to the closure yourself, the invalidation notifiers may unref the closure and cause it to be destroyed, so if you need to access the closure after calling g_closure_invalidate(), make sure that you've previously called g_closure_ref().

invoke
void invoke(Value returnValue, Value[] paramValues, void* invocationHint)

Invokes the closure, i.e. executes the callback represented by the @closure.

removeFinalizeNotifier
void removeFinalizeNotifier(void* notifyData, GClosureNotify notifyFunc)

Removes a finalization notifier.

removeInvalidateNotifier
void removeInvalidateNotifier(void* notifyData, GClosureNotify notifyFunc)

Removes an invalidation notifier.

setMarshal
void setMarshal(GClosureMarshal marshal)

Sets the marshaller of @closure. The marshal_data of @marshal provides a way for a meta marshaller to provide additional information to the marshaller. (See g_closure_set_meta_marshal().) For GObject's C predefined marshallers (the g_cclosure_marshal_*() functions), what it provides is a callback function to use instead of @closure->callback.

setMetaMarshal
void setMetaMarshal(void* marshalData, GClosureMarshal metaMarshal)

Sets the meta marshaller of @closure. A meta marshaller wraps @closure->marshal and modifies the way it is called in some fashion. The most common use of this facility is for C callbacks. The same marshallers (generated by [glib-genmarshal][glib-genmarshal]), are used everywhere, but the way that we get the callback function differs. In most cases we want to use @closure->callback, but in other cases we want to use some different technique to retrieve the callback function.

sink
void sink()

Takes over the initial ownership of a closure. Each closure is initially created in a "floating" state, which means that the initial reference count is not owned by any caller. g_closure_sink() checks to see if the object is still floating, and if so, unsets the floating state and decreases the reference count. If the closure is not floating, g_closure_sink() does nothing. The reason for the existence of the floating state is to prevent cumbersome code sequences like: |[<!-- language="C" --> closure = g_cclosure_new (cb_func, cb_data); g_source_set_closure (source, closure); g_closure_unref (closure); // GObject doesn't really need this ]| Because g_source_set_closure() (and similar functions) take ownership of the initial reference count, if it is unowned, we instead can write: |[<!-- language="C" --> g_source_set_closure (source, g_cclosure_new (cb_func, cb_data)); ]|

unref
void unref()

Decrements the reference count of a closure after it was previously incremented by the same caller. If no other callers are using the closure, then the closure will be destroyed and freed.

Static functions

getType
GType getType()
sourceSetClosure
void sourceSetClosure(Source source, Closure closure)

Set the callback for a source as a #GClosure.

sourceSetDummyCallback
void sourceSetDummyCallback(Source source)

Sets a dummy callback for @source. The callback will do nothing, and if the source expects a #gboolean return value, it will return %TRUE. (If the source expects any other type of return value, it will return a 0/%NULL value; whatever g_value_init() initializes a #GValue to for that type.)

Variables

gClosure
GClosure* gClosure;

the main Gtk struct

ownedRef
bool ownedRef;
Undocumented in source.

Meta