G_CLOSURE_NEEDS_MARSHAL()

#define	G_CLOSURE_NEEDS_MARSHAL(closure) (((GClosure*) (closure))->marshal == NULL)

Возвращает TRUE если маршаллер GClosureMarshal ещё не установлен в closure. Смотрите g_closure_set_marshal().

G_CLOSURE_N_NOTIFIERS()

#define             G_CLOSURE_N_NOTIFIERS(cl)

Возвращает 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*) (closure))->derivative_flag)

Определяет должны ли пользовательские данные GCClosure помещаться как первый параметр в callback-функцию. Смотрите g_cclosure_new_swap().

G_CALLBACK()

#define	G_CALLBACK(f)			 ((GCallback) (f))

Приводит указатель функции к типу GCallback.

GCallback ()

void                (*GCallback)                        (void);

Тип используемый для callback-функций в определениях структур и сигнатурах функций. Это не означает что все callback-функции не должны принимать параметры и возвращать void. Необходимая сигнатура callback-функции определяется контекстом в котором используется (например сигнал к которому подключена). Используйте G_CALLBACK() для приведения callback-функции к типу GCallback.

GClosure

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

GClosure представляет callback-функцию подходящую для программиста.

G_TYPE_CLOSURE

#define	G_TYPE_CLOSURE		(g_closure_get_type ())

GType для GClosure.

GCClosure

typedef struct {
  GClosure	closure;
  gpointer	callback;
} GCClosure;

GCClosure это специализированная GClosure для C callback-функций.

GClosureMarshal ()

void                (*GClosureMarshal)                  (GClosure *closure,
                                                         GValue *return_value,
                                                         guint n_param_values,
                                                         const GValue *param_values,
                                                         gpointer invocation_hint,
                                                         gpointer marshal_data);

Тип используемый для функций маршаллеров.

GClosureNotify ()

void                (*GClosureNotify)                   (gpointer data,
                                                         GClosure *closure);

Тип используемый для разных callback-уведомлений которые могут быть зарегистрированы в замыкании.

g_cclosure_new ()

GClosure*           g_cclosure_new                      (GCallback callback_func,
                                                         gpointer user_data,
                                                         GClosureNotify destroy_data);

Создаёт новое замыкание которое вызывает callback_func с user_data в качестве последнего параметра.

g_cclosure_new_swap ()

GClosure*           g_cclosure_new_swap                 (GCallback callback_func,
                                                         gpointer user_data,
                                                         GClosureNotify destroy_data);

Создаёт новое замыкание которое вызывает callback_func с user_data в качестве первого параметра.

g_cclosure_new_object ()

GClosure*           g_cclosure_new_object               (GCallback callback_func,
                                                         GObject *object);

Вариант g_cclosure_new() который использует object как user_data вызывает g_object_watch_closure() для object создавая замыкание. Эта функция полезна когда вам нужна callback-функция тесно связанная с GObject, и нужно чтобы callback-функция не запускалась после освобождения объекта.

g_cclosure_new_object_swap ()

GClosure*           g_cclosure_new_object_swap          (GCallback callback_func,
                                                         GObject *object);

Вариант g_cclosure_new_swap() который использует object как user_data и вызывает g_object_watch_closure() для object создавая замыкание. Эта функция полезна когда вам нужна callback-функция тесно связанная с GObject, и не нужно чтобы callback-функция вызывалась после освобождения объекта.

g_closure_new_object ()

GClosure*           g_closure_new_object                (guint sizeof_closure,
                                                         GObject *object);

Вариант g_closure_new_simple() которая сохраняет object в поле data замыкания и вызывает g_object_watch_closure() для object при создании замыкания. Эта функция полезна главным образом при создании новых типов замыканий.

g_closure_ref ()

GClosure*           g_closure_ref                       (GClosure *closure);

Увеличивает количество ссылок замыкания заставляя оставаться существующим в течение вызова содержащего указатель на неё.

g_closure_sink ()

void                g_closure_sink                      (GClosure *closure);

Принимает владение замыканием. Каждое замыкание инициализируется при создании в плавающее состояние, это значит что инициализированным счётчиком ссылок никто не владеет. g_closure_sink() проверяет находится ли объект в плавающем состоянии, и если это так, отменяет плавающее состояние и уменьшает количество ссылок. Если замыкание не плавающее, g_closure_sink() ничего не делает. Причина существования плавающих состояний заключается в предотвращении громоздких последовательностей кода, например:

closure = g_cclosure_new (cb_func, cb_data); 
g_source_set_closure (source, closure); 
g_closure_unref (closure); /* XXX GObject на самом деле не нуждается в этом */

Поскольку g_source_set_closure() (и подобные функции) будут владеть начальным счётчиком ссылок (если он не имеет владельца), мы можем написать следующее:

g_source_set_closure (source, g_cclosure_new (cb_func, cb_data));

Обычно эта функция используется вместе с g_closure_ref(). Например сохранение замыкания для более позднего уведомления выглядит так:

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);
    }
}

Поскольку g_closure_sink() может уменьшить количество ссылок замыкания (если она была вызвана для closure) так же как g_closure_unref(), функция g_closure_ref() должна быть вызвана перед этой функцией.

g_closure_unref ()

void                g_closure_unref                     (GClosure *closure);

Уменьшает количество ссылок замыкания после того как оно было увеличено подобным вызовом. Если нет других вызовов использующих замыкание, то замыкание будет уничтожено и освобождено.

g_closure_invoke ()

void                g_closure_invoke                    (GClosure *closure,
                                                         GValue *return_value,
                                                         guint n_param_values,
                                                         const GValue *param_values,
                                                         gpointer invocation_hint);

Вызывает замыкание, то есть выполняет вызов предоставляемый замыканием closure.

g_closure_invalidate ()

void                g_closure_invalidate                (GClosure *closure);

Устанавливает флаг в замыкание указывая что вызов невозможен, таким образом заставляет игнорировать любые последующие вызовы g_closure_invoke() в этом closure. Кроме того, аннулирующее уведомление установленное в этом замыкании будет вызвано в этой точке. Помните, если вы не удерживаете ссылку на замыкание самостоятельно, аннулирующее уведомление может отменить ссылку на замыкание и таким образом уничтожить его, поэтому если вам нужен доступ к замыканию после вызова g_closure_invalidate(), убедитесь что вы предварительно вызвали g_closure_ref().

Заметьте, g_closure_invalidate() будет также вызвана когда количество ссылок замыкания сброшено в ноль (если оно не было аннулировано раньше).

g_closure_add_finalize_notifier ()

void                g_closure_add_finalize_notifier     (GClosure *closure,
                                                         gpointer notify_data,
                                                         GClosureNotify notify_func);

Регистрирует финализирующее уведомление которое вызывается когда количество ссылок closure достигает 0. Множество финализирующих уведомлений в единственном замыкании вызываются в неопределённом порядке. Если единственный вызов g_closure_unref() приводит замыкание и к аннулированию и к финализации, то уведомление аннулирования выполняется перед уведомлением финализации.

g_closure_add_invalidate_notifier ()

void                g_closure_add_invalidate_notifier   (GClosure *closure,
                                                         gpointer notify_data,
                                                         GClosureNotify notify_func);

Регистрирует уведомление аннулирования которое вызывается когда closure аннулируется с помощью g_closure_invalidate(). Уведомления аннулирования вызываются перед уведомлениями финализации, в неопределённом порядке.

g_closure_remove_finalize_notifier ()

void                g_closure_remove_finalize_notifier  (GClosure *closure,
                                                         gpointer notify_data,
                                                         GClosureNotify notify_func);

Удаляет уведомление финализации.

Помните что уведомление удаляется автоматически после выполнения.

g_closure_remove_invalidate_notifier ()

void                g_closure_remove_invalidate_notifier
                                                        (GClosure *closure,
                                                         gpointer notify_data,
                                                         GClosureNotify notify_func);

Удаляет аннулирующее уведомление.

Помните что уведомления автоматически удаляются после выполнения.

g_closure_new_simple ()

GClosure*           g_closure_new_simple                (guint sizeof_closure,
                                                         gpointer data);

Распределяет структуру с полученным размером и инициализирует начальную часть как GClosure. Эта функция в основном полезна при реализации новых типов замыканий.

typedef struct _MyClosure MyClosure;
struct _MyClosure 
{
  GClosure closure;
  /* дополнительные данные расположены здесь */
};
    

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

  /* здесь освобождаем дополнительные данные */
}

MyClosure *my_closure_new (gpointer data)
{
  GClosure *closure;
  MyClosure *my_closure;
  
  closure = g_closure_new_simple (sizeof (MyClosure), data);
  my_closure = (MyClosure *) closure;

  /* здесь инициализируем дополнительные данные */

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

Устанавливает маршаллер closure. marshal_data для marshal обеспечивает способ для мета-маршаллера обеспечивающего дополнительную информацию для маршаллера. (Смотрите g_closure_set_meta_marshal()). Для С маршаллеров предопределённых в GObject (функциями g_cclosure_marshal_*()), обеспечивается callback-функция для использования вместо closure->callback.

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

Добавляет пары уведомлений которые получают вызов перед и после callback-функции замыкания, соответственно. Это обычно используется для защиты дополнительных аргументов для продолжения callback-вызова. Смотрите пример защиты маршаллера в g_object_watch_closure().

g_closure_set_meta_marshal ()

void                g_closure_set_meta_marshal          (GClosure *closure,
                                                         gpointer marshal_data,
                                                         GClosureMarshal meta_marshal);

Устанавливает мета-маршаллер для closure. Мета-маршаллер является оболочкой для closure->marshal и изменяет способ вызова в той же манере. В основном это используется для C callback-функций. Такие же маршаллеры (сгенирированные с помощью glib-genmarshal) используются повсюду, но способ которыми вы получаете callback-функции отличаются. В большинстве случаев вы используете closure->callback, но в некоторых случаях мы используем несколько другую методику поиска callback-функций.

Например, классовое замыкание для сигналов (смотрите g_signal_type_cclosure_new()) находит callback-функцию из фиксированного смещения в классовой структуре. Мета-маршаллер отыскивает правильную callback-функцию и помещает её в маршаллер как аргумент marshal_data.

g_source_set_closure ()

void                g_source_set_closure                (GSource *source,
                                                         GClosure *closure);

Устанавливает callback-функцию для источника подобного GClosure.

Если источник не относится к стандартным типам GLib, поля closure_callback и closure_marshal сструктуры GSourceFuncs должны быть заполнены указателями подходящих функций.

G_TYPE_IO_CHANNEL

#define G_TYPE_IO_CHANNEL (g_io_channel_get_type ())

GType для GIOChannel.

G_TYPE_IO_CONDITION

#define G_TYPE_IO_CONDITION (g_io_condition_get_type ())

GType для GIOCondition.

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

Маршаллер для GCClosure с callback-функцией типа void (*callback) (gpointer instance, gpointer user_data).

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

Маршаллер для GCClosure с callback-функцией типа void (*callback) (gpointer instance, gboolean arg1, gpointer user_data).

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

Маршаллер для GCClosure с callback-функцией типа void (*callback) (gpointer instance, gchar arg1, gpointer user_data).

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

Маршаллер для GCClosure с callback-функцией типа void (*callback) (gpointer instance, guchar arg1, gpointer user_data).

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

Маршаллер для GCClosure с callback-функцией типа void (*callback) (gpointer instance, gint arg1, gpointer user_data).

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

Маршаллер для GCClosure с callback-функцией типа void (*callback) (gpointer instance, guint arg1, gpointer user_data).

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

Маршаллер для GCClosure с callback-функцией типа void (*callback) (gpointer instance, glong arg1, gpointer user_data).

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

Маршаллер для GCClosure с callback-функцией типа void (*callback) (gpointer instance, gulong arg1, gpointer user_data).

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

Маршаллер для GCClosure с callback-функцией типа void (*callback) (gpointer instance, gint arg1, gpointer user_data) где gint параметр указывает тип перечисления..

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

Маршаллер для GCClosure с callback-функцией типа void (*callback) (gpointer instance, gint arg1, gpointer user_data) где gint параметр указывает тип флагов.

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

Маршаллер для GCClosure с callback-функцией типа void (*callback) (gpointer instance, gfloat arg1, gpointer user_data).

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

Маршаллер для GCClosure с callback-функцией типа void (*callback) (gpointer instance, gdouble arg1, gpointer user_data).

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

Маршаллер для GCClosure с callback-функцией типа void (*callback) (gpointer instance, const gchar *arg1, gpointer user_data).

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

Маршаллер для GCClosure с callback-функцией типа void (*callback) (gpointer instance, GParamSpec *arg1, gpointer user_data).

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

Маршаллер для GCClosure с callback-функцией типа void (*callback) (gpointer instance, GBoxed *arg1, gpointer user_data).

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

Маршаллер для GCClosure с callback-функцией типа void (*callback) (gpointer instance, gpointer arg1, gpointer user_data).

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

Маршаллер для GCClosure с callback-функцией типа void (*callback) (gpointer instance, GOBject *arg1, gpointer user_data).

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

Маршаллер для GCClosure с callback-функцией типа void (*callback) (gpointer instance, GObject *arg1, gpointer arg2, gpointer user_data).

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

Маршаллер для GCClosure с callback-функцией типа void (*callback) (gpointer instance, guint arg1, gpointer arg2, gpointer user_data).

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

Маршаллер для GCClosure с callback-функцией типа gboolean (*callback) (gpointer instance, gint arg1, gpointer user_data) где gint параметр указывает тип флагов.

g_cclosure_marshal_BOOL__FLAGS

#define             g_cclosure_marshal_BOOL__FLAGS

Другое имя для g_cclosure_marshal_BOOLEAN__FLAGS().