Create a new GObject.Closure

Parameters:

guint32 sizeof_closure Required (not null)

the size of the structure to allocate, must be at least sizeof (GClosure)

GObject.Object object Required (not null)

a GObject pointer to store in the data field of the newly allocated GClosure

Returns:

GObject.Closure a newly allocated GClosure

Create a new GObject.Closure

Parameters:

guint32 sizeof_closure Required (not null)

the size of the structure to allocate, must be at least sizeof (GClosure)

void* data Required (not null)

data to store in the data field of the newly allocated GClosure

Returns:

GObject.Closure a newly allocated GClosure

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().
Note that g_closure_invalidate() will also be called when the
reference count of a closure drops to zero (unless it has already
been invalidated before).

Returns:

none

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

Parameters:

GObject.Value return_value Required (not null)

a GValue to store the return value. May be NULL if the callback of closure doesn't return a value.

guint32 n_param_values Required (not null)

the length of the param_values array

Array param_values Required (not null)

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

void* invocation_hint Required (not null)

a context-dependent invocation hint

Returns:

none

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 existance of the floating state is to
prevent cumbersome code sequences like:
|[
closure = g_cclosure_new (cb_func, cb_data);
g_source_set_closure (source, closure);
g_closure_unref (closure); // XXX 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:
|[
g_source_set_closure (source, g_cclosure_new (cb_func, cb_data));
]|
Generally, this function is used together with g_closure_ref(). Ane example
of storing a closure for later notification looks like:
|[
static GClosure *notify_closure = NULL;
void
foo_notify_set_closure (GClosure *closure)
{
if (notify_closure)
g_closure_unref (notify_closure);
notify_closure = closure;
if (notify_closure)
{
g_closure_ref (notify_closure);
g_closure_sink (notify_closure);
}
}
]|
Because g_closure_sink() may decrement the reference count of a closure
(if it hasn't been called on closure yet) just like g_closure_unref(),
g_closure_ref() should be called prior to this function.

Returns:

none