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

G_CLOSURE_N_NOTIFIERS()

#define             G_CLOSURE_N_NOTIFIERS(cl)

Get the total number of notifiers connected with the closure cl . The count includes the meta marshaller, the finalize and invalidate notifiers and the marshal guards. Note that each guard counts as two notifiers. See g_closure_set_meta_marshal(), g_closure_add_finalize_notifier(), g_closure_add_invalidate_notifier() and g_closure_add_marshal_guards().

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

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.

[skip]

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.

[skip]

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.

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.

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:

1
2
3

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:

1

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:

1
2
3
4
5
6
7
8
9
10
11
12
13

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.

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.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

typedef struct _MyClosure MyClosure;
struct _MyClosure
{
  GClosure closure;
  // extra data goes here
};

static void
my_closure_finalize (gpointer  notify_data,
                     GClosure *closure)
{
  MyClosure *my_closure = (MyClosure *)closure;

  // free extra data here
}

MyClosure *my_closure_new (gpointer data)
{
  GClosure *closure;
  MyClosure *my_closure;

  closure = g_closure_new_simple (sizeof (MyClosure), data);
  my_closure = (MyClosure *) closure;

  // initialize extra data here

  g_closure_add_finalize_notifier (closure, notify_data,
                                   my_closure_finalize);
  return my_closure;
}

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

void
g_cclosure_marshal_VOID__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 a single raw pointer argument type.

If it is possible, it is better to use one of the more specific functions such as g_cclosure_marshal_VOID__OBJECT() or g_cclosure_marshal_VOID__OBJECT().

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 a 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

g_cclosure_marshal_VOID__VOIDv ()

void
g_cclosure_marshal_VOID__VOIDv (GClosure *closure,
                                GValue *return_value,
                                gpointer instance,
                                va_list args,
                                gpointer marshal_data,
                                int n_params,
                                GType *param_types);

The GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__VOID().

g_cclosure_marshal_VOID__BOOLEANv ()

void
g_cclosure_marshal_VOID__BOOLEANv (GClosure *closure,
                                   GValue *return_value,
                                   gpointer instance,
                                   va_list args,
                                   gpointer marshal_data,
                                   int n_params,
                                   GType *param_types);

The GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__BOOLEAN().

g_cclosure_marshal_VOID__CHARv ()

void
g_cclosure_marshal_VOID__CHARv (GClosure *closure,
                                GValue *return_value,
                                gpointer instance,
                                va_list args,
                                gpointer marshal_data,
                                int n_params,
                                GType *param_types);

The GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__CHAR().

g_cclosure_marshal_VOID__UCHARv ()

void
g_cclosure_marshal_VOID__UCHARv (GClosure *closure,
                                 GValue *return_value,
                                 gpointer instance,
                                 va_list args,
                                 gpointer marshal_data,
                                 int n_params,
                                 GType *param_types);

The GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__UCHAR().

g_cclosure_marshal_VOID__INTv ()

void
g_cclosure_marshal_VOID__INTv (GClosure *closure,
                               GValue *return_value,
                               gpointer instance,
                               va_list args,
                               gpointer marshal_data,
                               int n_params,
                               GType *param_types);

The GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__INT().

g_cclosure_marshal_VOID__UINTv ()

void
g_cclosure_marshal_VOID__UINTv (GClosure *closure,
                                GValue *return_value,
                                gpointer instance,
                                va_list args,
                                gpointer marshal_data,
                                int n_params,
                                GType *param_types);

The GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__UINT().

g_cclosure_marshal_VOID__LONGv ()

void
g_cclosure_marshal_VOID__LONGv (GClosure *closure,
                                GValue *return_value,
                                gpointer instance,
                                va_list args,
                                gpointer marshal_data,
                                int n_params,
                                GType *param_types);

The GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__LONG().

g_cclosure_marshal_VOID__ULONGv ()

void
g_cclosure_marshal_VOID__ULONGv (GClosure *closure,
                                 GValue *return_value,
                                 gpointer instance,
                                 va_list args,
                                 gpointer marshal_data,
                                 int n_params,
                                 GType *param_types);

The GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__ULONG().

g_cclosure_marshal_VOID__ENUMv ()

void
g_cclosure_marshal_VOID__ENUMv (GClosure *closure,
                                GValue *return_value,
                                gpointer instance,
                                va_list args,
                                gpointer marshal_data,
                                int n_params,
                                GType *param_types);

The GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__ENUM().

g_cclosure_marshal_VOID__FLAGSv ()

void
g_cclosure_marshal_VOID__FLAGSv (GClosure *closure,
                                 GValue *return_value,
                                 gpointer instance,
                                 va_list args,
                                 gpointer marshal_data,
                                 int n_params,
                                 GType *param_types);

The GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__FLAGS().

g_cclosure_marshal_VOID__FLOATv ()

void
g_cclosure_marshal_VOID__FLOATv (GClosure *closure,
                                 GValue *return_value,
                                 gpointer instance,
                                 va_list args,
                                 gpointer marshal_data,
                                 int n_params,
                                 GType *param_types);

The GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__FLOAT().

g_cclosure_marshal_VOID__DOUBLEv ()

void
g_cclosure_marshal_VOID__DOUBLEv (GClosure *closure,
                                  GValue *return_value,
                                  gpointer instance,
                                  va_list args,
                                  gpointer marshal_data,
                                  int n_params,
                                  GType *param_types);

The GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__DOUBLE().

g_cclosure_marshal_VOID__STRINGv ()

void
g_cclosure_marshal_VOID__STRINGv (GClosure *closure,
                                  GValue *return_value,
                                  gpointer instance,
                                  va_list args,
                                  gpointer marshal_data,
                                  int n_params,
                                  GType *param_types);

The GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__STRING().

g_cclosure_marshal_VOID__PARAMv ()

void
g_cclosure_marshal_VOID__PARAMv (GClosure *closure,
                                 GValue *return_value,
                                 gpointer instance,
                                 va_list args,
                                 gpointer marshal_data,
                                 int n_params,
                                 GType *param_types);

The GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__PARAM().

g_cclosure_marshal_VOID__BOXEDv ()

void
g_cclosure_marshal_VOID__BOXEDv (GClosure *closure,
                                 GValue *return_value,
                                 gpointer instance,
                                 va_list args,
                                 gpointer marshal_data,
                                 int n_params,
                                 GType *param_types);

The GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__BOXED().

g_cclosure_marshal_VOID__POINTERv ()

void
g_cclosure_marshal_VOID__POINTERv (GClosure *closure,
                                   GValue *return_value,
                                   gpointer instance,
                                   va_list args,
                                   gpointer marshal_data,
                                   int n_params,
                                   GType *param_types);

The GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__POINTER().

g_cclosure_marshal_VOID__OBJECTv ()

void
g_cclosure_marshal_VOID__OBJECTv (GClosure *closure,
                                  GValue *return_value,
                                  gpointer instance,
                                  va_list args,
                                  gpointer marshal_data,
                                  int n_params,
                                  GType *param_types);

The GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__OBJECT().

g_cclosure_marshal_VOID__VARIANTv ()

void
g_cclosure_marshal_VOID__VARIANTv (GClosure *closure,
                                   GValue *return_value,
                                   gpointer instance,
                                   va_list args,
                                   gpointer marshal_data,
                                   int n_params,
                                   GType *param_types);

The GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__VARIANT().

g_cclosure_marshal_STRING__OBJECT_POINTERv ()

void
g_cclosure_marshal_STRING__OBJECT_POINTERv
                               (GClosure *closure,
                                GValue *return_value,
                                gpointer instance,
                                va_list args,
                                gpointer marshal_data,
                                int n_params,
                                GType *param_types);

The GVaClosureMarshal equivalent to g_cclosure_marshal_STRING__OBJECT_POINTER().

g_cclosure_marshal_VOID__UINT_POINTERv ()

void
g_cclosure_marshal_VOID__UINT_POINTERv
                               (GClosure *closure,
                                GValue *return_value,
                                gpointer instance,
                                va_list args,
                                gpointer marshal_data,
                                int n_params,
                                GType *param_types);

The GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__UINT_POINTER().

g_cclosure_marshal_BOOLEAN__FLAGSv ()

void
g_cclosure_marshal_BOOLEAN__FLAGSv (GClosure *closure,
                                    GValue *return_value,
                                    gpointer instance,
                                    va_list args,
                                    gpointer marshal_data,
                                    int n_params,
                                    GType *param_types);

The GVaClosureMarshal equivalent to g_cclosure_marshal_BOOLEAN__FLAGS().

g_cclosure_marshal_BOOLEAN__BOXED_BOXEDv ()

void
g_cclosure_marshal_BOOLEAN__BOXED_BOXEDv
                               (GClosure *closure,
                                GValue *return_value,
                                gpointer instance,
                                va_list args,
                                gpointer marshal_data,
                                int n_params,
                                GType *param_types);

The GVaClosureMarshal equivalent to g_cclosure_marshal_BOOLEAN__BOXED_BOXED().

struct GClosure

struct GClosure {
  volatile       	guint	 in_marshal : 1;
  volatile       	guint	 is_invalid : 1;
};

A GClosure represents a callback supplied by the programmer.

G_TYPE_CLOSURE

#define G_TYPE_CLOSURE (g_closure_get_type ())

The GType for GClosure.

struct GCClosure

struct GCClosure {
  GClosure closure;
  gpointer callback;
};

A GCClosure is a specialization of GClosure for C function callbacks.

g_cclosure_marshal_BOOL__FLAGS

#define             g_cclosure_marshal_BOOL__FLAGS

An old alias for g_cclosure_marshal_BOOLEAN__FLAGS().

g_cclosure_marshal_BOOL__BOXED_BOXED

#define             g_cclosure_marshal_BOOL__BOXED_BOXED

An old alias for g_cclosure_marshal_BOOLEAN__BOXED_BOXED().