Functions
G_CLOSURE_NEEDS_MARSHAL()
#define G_CLOSURE_NEEDS_MARSHAL(closure) (((GClosure*) (closure))->marshal == NULL)
Check if the closure still needs a marshaller. See g_closure_set_marshal().
Returns
TRUE if a GClosureMarshal marshaller has not yet been set on
closure
.
G_CCLOSURE_SWAP_DATA()
#define G_CCLOSURE_SWAP_DATA(cclosure) (((GClosure*) (cclosure))->derivative_flag)
Checks whether the user data of the GCClosure should be passed as the
first parameter to the callback. See g_cclosure_new_swap().
Returns
TRUE if data has to be swapped.
G_CALLBACK()
#define G_CALLBACK(f) ((GCallback) (f))
Cast a function pointer to a GCallback.
GCallback ()
void
(*GCallback) (void);
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 GCallback.
GClosureMarshal ()
void
(*GClosureMarshal) (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
The type used for marshaller functions.
GVaClosureMarshal ()
void
(*GVaClosureMarshal) (GClosure *closure,
GValue *return_value,
gpointer instance,
va_list args,
gpointer marshal_data,
int n_params,
GType *param_types);
This is the signature of va_list marshaller functions, an optional
marshaller that can be used in some situations to avoid
marshalling the signal argument into GValues.
GClosureNotify ()
void
(*GClosureNotify) (gpointer data,
GClosure *closure);
The type used for the various notification callbacks which can be registered
on closures.
g_cclosure_new ()
GClosure *
g_cclosure_new (GCallback callback_func,
gpointer user_data,
GClosureNotify destroy_data);
Creates a new closure which invokes callback_func
with user_data
as
the last parameter.
destroy_data
will be called as a finalize notifier on the GClosure.
[skip]
Returns
a floating reference to a new GCClosure.
[transfer none]
g_cclosure_new_swap ()
GClosure *
g_cclosure_new_swap (GCallback callback_func,
gpointer user_data,
GClosureNotify destroy_data);
Creates a new closure which invokes callback_func
with user_data
as
the first parameter.
destroy_data
will be called as a finalize notifier on the GClosure.
[skip]
Returns
a floating reference to a new GCClosure.
[transfer none]
g_cclosure_new_object ()
GClosure *
g_cclosure_new_object (GCallback callback_func,
GObject *object);
A variant of g_cclosure_new() which uses object
as user_data
and
calls g_object_watch_closure() on object
and the created
closure. This function is useful when you have a callback closely
associated with a GObject, and want the callback to no longer run
after the object is is freed.
[skip]
g_cclosure_new_object_swap ()
GClosure *
g_cclosure_new_object_swap (GCallback callback_func,
GObject *object);
A variant of g_cclosure_new_swap() which uses object
as user_data
and calls g_object_watch_closure() on object
and the created
closure. This function is useful when you have a callback closely
associated with a GObject, and want the callback to no longer run
after the object is is freed.
[skip]
g_cclosure_marshal_generic ()
void
g_cclosure_marshal_generic (GClosure *closure,
GValue *return_gvalue,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
A generic marshaller function implemented via
libffi.
Normally this function is not passed explicitly to g_signal_new(),
but used automatically by GLib when specifying a NULL marshaller.
Since: 2.30
g_closure_new_object ()
GClosure *
g_closure_new_object (guint sizeof_closure,
GObject *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.
Returns
a newly allocated GClosure.
[transfer full]
g_closure_ref ()
GClosure *
g_closure_ref (GClosure *closure);
Increments the reference count on a closure to force it staying
alive while the caller holds a pointer to it.
Returns
The closure
passed in, for convenience.
[transfer none]
g_closure_sink ()
void
g_closure_sink (GClosure *closure);
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:
Because g_source_set_closure() (and similar functions) take ownership of the
initial reference count, if it is unowned, we instead can write:
Generally, this function is used together with g_closure_ref(). Ane example
of storing a closure for later notification looks like:
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.
g_closure_unref ()
void
g_closure_unref (GClosure *closure);
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.
g_closure_invoke ()
void
g_closure_invoke (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint);
Invokes the closure, i.e. executes the callback represented by the closure
.
g_closure_invalidate ()
void
g_closure_invalidate (GClosure *closure);
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).
g_closure_add_finalize_notifier ()
void
g_closure_add_finalize_notifier (GClosure *closure,
gpointer notify_data,
GClosureNotify notify_func);
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.
[skip]
g_closure_add_invalidate_notifier ()
void
g_closure_add_invalidate_notifier (GClosure *closure,
gpointer notify_data,
GClosureNotify notify_func);
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.
[skip]
g_closure_remove_finalize_notifier ()
void
g_closure_remove_finalize_notifier (GClosure *closure,
gpointer notify_data,
GClosureNotify notify_func);
Removes a finalization notifier.
Notice that notifiers are automatically removed after they are run.
[skip]
g_closure_remove_invalidate_notifier ()
void
g_closure_remove_invalidate_notifier (GClosure *closure,
gpointer notify_data,
GClosureNotify notify_func);
Removes an invalidation notifier.
Notice that notifiers are automatically removed after they are run.
[skip]
g_closure_new_simple ()
GClosure *
g_closure_new_simple (guint sizeof_closure,
gpointer 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.
Returns
a floating reference to a new GClosure.
[transfer none]
g_closure_set_marshal ()
void
g_closure_set_marshal (GClosure *closure,
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
.
[skip]
g_closure_add_marshal_guards ()
void
g_closure_add_marshal_guards (GClosure *closure,
gpointer pre_marshal_data,
GClosureNotify pre_marshal_notify,
gpointer post_marshal_data,
GClosureNotify post_marshal_notify);
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.
[skip]
g_closure_set_meta_marshal ()
void
g_closure_set_meta_marshal (GClosure *closure,
gpointer marshal_data,
GClosureMarshal meta_marshal);
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),
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.
For example, class closures for signals (see
g_signal_type_cclosure_new()) retrieve the callback function from a
fixed offset in the class structure. The meta marshaller retrieves
the right callback and passes it to the marshaller as the
marshal_data
argument.
[skip]
g_source_set_closure ()
void
g_source_set_closure (GSource *source,
GClosure *closure);
Set the callback for a source as a GClosure.
If the source is not one of the standard GLib types, the closure_callback
and closure_marshal
fields of the GSourceFuncs structure must have been
filled in with pointers to appropriate functions.
g_source_set_dummy_callback ()
void
g_source_set_dummy_callback (GSource *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.)
If the source is not one of the standard GLib types, the
closure_callback
and closure_marshal
fields of the GSourceFuncs
structure must have been filled in with pointers to appropriate
functions.
g_cclosure_marshal_VOID__VOID ()
void
g_cclosure_marshal_VOID__VOID (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
A GClosureMarshal function for use with signals with no arguments.
g_cclosure_marshal_VOID__BOOLEAN ()
void
g_cclosure_marshal_VOID__BOOLEAN (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
A GClosureMarshal function for use with signals with a single
boolean argument.
g_cclosure_marshal_VOID__CHAR ()
void
g_cclosure_marshal_VOID__CHAR (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
A GClosureMarshal function for use with signals with a single
character argument.
g_cclosure_marshal_VOID__UCHAR ()
void
g_cclosure_marshal_VOID__UCHAR (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
A GClosureMarshal function for use with signals with a single
unsigned character argument.
g_cclosure_marshal_VOID__INT ()
void
g_cclosure_marshal_VOID__INT (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
A GClosureMarshal function for use with signals with a single
integer argument.
g_cclosure_marshal_VOID__UINT ()
void
g_cclosure_marshal_VOID__UINT (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
A GClosureMarshal function for use with signals with with a single
unsigned integer argument.
g_cclosure_marshal_VOID__LONG ()
void
g_cclosure_marshal_VOID__LONG (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
A GClosureMarshal function for use with signals with with a single
long integer argument.
g_cclosure_marshal_VOID__ULONG ()
void
g_cclosure_marshal_VOID__ULONG (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
A GClosureMarshal function for use with signals with a single
unsigned long integer argument.
g_cclosure_marshal_VOID__ENUM ()
void
g_cclosure_marshal_VOID__ENUM (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
A GClosureMarshal function for use with signals with a single
argument with an enumerated type.
g_cclosure_marshal_VOID__FLAGS ()
void
g_cclosure_marshal_VOID__FLAGS (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
A GClosureMarshal function for use with signals with a single
argument with a flags types.
g_cclosure_marshal_VOID__FLOAT ()
void
g_cclosure_marshal_VOID__FLOAT (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
A GClosureMarshal function for use with signals with one
single-precision floating point argument.
g_cclosure_marshal_VOID__DOUBLE ()
void
g_cclosure_marshal_VOID__DOUBLE (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
A GClosureMarshal function for use with signals with one
double-precision floating point argument.
g_cclosure_marshal_VOID__STRING ()
void
g_cclosure_marshal_VOID__STRING (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
A GClosureMarshal function for use with signals with a single string
argument.
g_cclosure_marshal_VOID__PARAM ()
void
g_cclosure_marshal_VOID__PARAM (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
A GClosureMarshal function for use with signals with a single
argument of type GParamSpec.
g_cclosure_marshal_VOID__BOXED ()
void
g_cclosure_marshal_VOID__BOXED (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
A GClosureMarshal function for use with signals with a single
argument which is any boxed pointer type.
g_cclosure_marshal_VOID__OBJECT ()
void
g_cclosure_marshal_VOID__OBJECT (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
A GClosureMarshal function for use with signals with a single
GObject argument.
g_cclosure_marshal_VOID__VARIANT ()
void
g_cclosure_marshal_VOID__VARIANT (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
A GClosureMarshal function for use with signals with a single
GVariant argument.
Since: 2.26
g_cclosure_marshal_STRING__OBJECT_POINTER ()
void
g_cclosure_marshal_STRING__OBJECT_POINTER
(GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
A GClosureMarshal function for use with signals with handlers that
take a GObject and a pointer and produce a string. It is highly
unlikely that your signal handler fits this description.
g_cclosure_marshal_VOID__UINT_POINTER ()
void
g_cclosure_marshal_VOID__UINT_POINTER (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
A GClosureMarshal function for use with signals with an unsigned int
and a pointer as arguments.
g_cclosure_marshal_BOOLEAN__FLAGS ()
void
g_cclosure_marshal_BOOLEAN__FLAGS (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
A GClosureMarshal function for use with signals with handlers that
take a flags type as an argument and return a boolean. If you have
such a signal, you will probably also need to use an accumulator,
such as g_signal_accumulator_true_handled().
g_cclosure_marshal_BOOLEAN__BOXED_BOXED ()
void
g_cclosure_marshal_BOOLEAN__BOXED_BOXED
(GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
A GClosureMarshal function for use with signals with handlers that
take two boxed pointers as arguments and return a boolean. If you
have such a signal, you will probably also need to use an
accumulator, such as g_signal_accumulator_true_handled().
g_cclosure_marshal_generic_va ()
void
g_cclosure_marshal_generic_va (GClosure *closure,
GValue *return_value,
gpointer instance,
va_list args_list,
gpointer marshal_data,
int n_params,
GType *param_types);
A generic GVaClosureMarshal function implemented via
libffi.
Since: 2.30