GSignalInvocationHint

typedef struct {
  guint		signal_id;
  GQuark	detail;
  GSignalFlags	run_type;
} GSignalInvocationHint;

Структура GSignalInvocationHint используется для помещения дополнительной информации в callback-функцию в течение эмиссии сигнала.

GSignalAccumulator ()

gboolean            (*GSignalAccumulator)               (GSignalInvocationHint *ihint,
                                                         GValue *return_accu,
                                                         const GValue *handler_return,
                                                         gpointer data);

Сумматор сигнала - специальная callback-функция которая может использоваться для накопления возвращаемых переменных разными callback-функциями которые вызываются в течение эмиссии сигнала. Сумматор сигнала определяется во время создания сигнала, если он сброшен в NULL, накопление возвращаемых значений не выполняется. Возвращает значение возвращённое последней callback-функцией в эмиссии сигнала.

GSignalCMarshaller

typedef GClosureMarshal			 GSignalCMarshaller;

Это сигнатура функций маршаллеров, требуемая для маршаллерных массивов значений параметра в эмиссиях сигнала внутри вызовов callback-функций языка С. Это просто псевдоним для GClosureMarshal так как механизм GClosure несёт ответственность за фактический вызов функции для системы сигналов.

GSignalEmissionHook ()

gboolean            (*GSignalEmissionHook)              (GSignalInvocationHint *ihint,
                                                         guint n_param_values,
                                                         const GValue *param_values,
                                                         gpointer data);

Простой указатель функции которая вызывается когда издаётся сигнал. Это позволяет вам привязать обработчик прерываний к типовому сигналу, чтобы он стал прерыванием для всех эмиссий этого сигнала в любом объекте.

Вы не сможете привязать это к сигналу созданному с флагом G_SIGNAL_NO_HOOKS.

enum GSignalFlags

typedef enum
{
  G_SIGNAL_RUN_FIRST	= 1 << 0,
  G_SIGNAL_RUN_LAST	= 1 << 1,
  G_SIGNAL_RUN_CLEANUP	= 1 << 2,
  G_SIGNAL_NO_RECURSE	= 1 << 3,
  G_SIGNAL_DETAILED	= 1 << 4,
  G_SIGNAL_ACTION	= 1 << 5,
  G_SIGNAL_NO_HOOKS	= 1 << 6
} GSignalFlags;

Флаги используемые для определения поведения сигнала, полное описание как специальные флаги RUN управляют стадиями эмиссии сигнала.

enum GSignalMatchType

typedef enum
{
  G_SIGNAL_MATCH_ID	   = 1 << 0,
  G_SIGNAL_MATCH_DETAIL	   = 1 << 1,
  G_SIGNAL_MATCH_CLOSURE   = 1 << 2,
  G_SIGNAL_MATCH_FUNC	   = 1 << 3,
  G_SIGNAL_MATCH_DATA	   = 1 << 4,
  G_SIGNAL_MATCH_UNBLOCKED = 1 << 5
} GSignalMatchType;

Соответствующие типы определяющие соответствие сигналов с помощью g_signal_handlers_block_matched(), g_signal_handlers_unblock_matched() и g_signal_handlers_disconnect_matched().

GSignalQuery

typedef struct {
  guint		signal_id;
  const gchar  *signal_name;
  GType		itype;
  GSignalFlags	signal_flags;
  GType		return_type; /* mangled with G_SIGNAL_TYPE_STATIC_SCOPE flag */
  guint		n_params;
  const GType  *param_types; /* mangled with G_SIGNAL_TYPE_STATIC_SCOPE flag */
} GSignalQuery;

Структура содержащая подробную информацию для определённого сигнала. Она заполняется функцией g_signal_query().

@return_type callback (gpointer     data1,
                      [param_types param_names,]
                       gpointer     data2);

G_SIGNAL_TYPE_STATIC_SCOPE

#define	G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT)

Этот макрос помечает типовой параметр сигнала для которого система может предположить что экземпляр остаётся постоянным во всех эмиссиях сигнала в которых он используется. Это полезно только для беcсылочного подсчёта, копий типовых значений.

Чтобы пометить параметр таким способом, добавьте | G_SIGNAL_TYPE_STATIC_SCOPE к соответствующему параметру функции g_signal_new().

    g_signal_new ("size_request",
		  G_TYPE_FROM_CLASS (gobject_class),
		  G_SIGNAL_RUN_FIRST,
		  G_STRUCT_OFFSET (GtkWidgetClass, size_request),
		  NULL, NULL,
		  _gtk_marshal_VOID__BOXED,
		  G_TYPE_NONE, 1,
		  GTK_TYPE_REQUISITION | G_SIGNAL_TYPE_STATIC_SCOPE);

G_SIGNAL_MATCH_MASK

#define G_SIGNAL_MATCH_MASK  0x3f

Маска для всех бит GSignalMatchType.

G_SIGNAL_FLAGS_MASK

#define G_SIGNAL_FLAGS_MASK  0x7f

Маска для всех бит GSignalFlags.

g_signal_new ()

guint               g_signal_new                        (const gchar *signal_name,
                                                         GType itype,
                                                         GSignalFlags signal_flags,
                                                         guint class_offset,
                                                         GSignalAccumulator accumulator,
                                                         gpointer accu_data,
                                                         GSignalCMarshaller c_marshaller,
                                                         GType return_type,
                                                         guint n_params,
                                                         ...);

Создаёт новый сигнал. (Это обычно выполняется в инициализаторе класса.)

Имя сигнала состоит из сегментов содержащих ASCII буквы и цифры, разделённые символом '-' или '_'. Первый символ имени сигнала должен быть буквой. Имена которые нарушают это правило приводят к непредсказуемому поведению системы GSignal.

Для регистрации и поиска сигнала, может быть использован любой разделитель, но они не должны перемешиваться.

g_signal_newv ()

guint               g_signal_newv                       (const gchar *signal_name,
                                                         GType itype,
                                                         GSignalFlags signal_flags,
                                                         GClosure *class_closure,
                                                         GSignalAccumulator accumulator,
                                                         gpointer accu_data,
                                                         GSignalCMarshaller c_marshaller,
                                                         GType return_type,
                                                         guint n_params,
                                                         GType *param_types);

Создаёт новый сигнал. (Это обычно выполняется в инициализаторе класса.)

Смотрите детали относительно имени сигнала в g_signal_new().

g_signal_new_valist ()

guint               g_signal_new_valist                 (const gchar *signal_name,
                                                         GType itype,
                                                         GSignalFlags signal_flags,
                                                         GClosure *class_closure,
                                                         GSignalAccumulator accumulator,
                                                         gpointer accu_data,
                                                         GSignalCMarshaller c_marshaller,
                                                         GType return_type,
                                                         guint n_params,
                                                         va_list args);

Создаёт новый сигнал. (Это обычно выполняется в инициализаторе класса.)

Смотрите подробности относительно имени сигнала в g_signal_new().

g_signal_query ()

void                g_signal_query                      (guint signal_id,
                                                         GSignalQuery *query);

Запрашивает у системы сигналов подробную информацию для определённого сигнала. Эта функция заполняет определённую пользователем структуру информацией для определённого сигнала. Если помещён несуществующий идентификатор сигнала, signal_id член GSignalQuery равен 0. Все заполненные члены сструктуры GSignalQuery должны рассматриваться как константы и должны оставаться нетронутыми.

g_signal_lookup ()

guint               g_signal_lookup                     (const gchar *name,
                                                         GType itype);

Учитывая имя сигнала и тип подключенного к нему объекта, получает целочисленный идентификатор сигнала. Издание сигнала с помощью номера несколько быстрее чем каждый раз использовать имя.

Также проверяет предков полученного типа.

Смотрите подробности относительно имён сигналов в g_signal_new().

g_signal_name ()

const gchar*        g_signal_name                       (guint signal_id);

Находит идентификатор сигнала по его имени.

Два разных сигнала могут иметь одинаковое имя если они разных типов.

g_signal_list_ids ()

guint*              g_signal_list_ids                   (GType itype,
                                                         guint *n_ids);

Создаёт список идентификаторов сигнала для определённого типового экземпляра или интерфейса. Дальнейшая информация о сигналах может быть запрошена через g_signal_query().

g_signal_emit ()

void                g_signal_emit                       (gpointer instance,
                                                         guint signal_id,
                                                         GQuark detail,
                                                         ...);

Издаёт сигнал.

Помните что g_signal_emit() сбрасывает возвращаемое значение в значение по умолчанию если нет подключенного обработчика, в отличие от g_signal_emitv().

g_signal_emit_by_name ()

void                g_signal_emit_by_name               (gpointer instance,
                                                         const gchar *detailed_signal,
                                                         ...);

Издаёт сигнал.

Помните что g_signal_emit_by_name() сбрасывает возвращаемое значение в значение по умолчанию если нет подключенных обработчиков, в отличие от g_signal_emitv().

g_signal_emitv ()

void                g_signal_emitv                      (const GValue *instance_and_params,
                                                         guint signal_id,
                                                         GQuark detail,
                                                         GValue *return_value);

Издаёт сигнал.

Помните что g_signal_emitv() не изменяет return_value если нет подключенных обработчиков, в отличие от g_signal_emit() и g_signal_emit_valist().

g_signal_emit_valist ()

void                g_signal_emit_valist                (gpointer instance,
                                                         guint signal_id,
                                                         GQuark detail,
                                                         va_list var_args);

Издаёт сигнал.

Помните что g_signal_emit_valist() сбрасывает возвращаемое значение в значение по умолчанию если нет подключенных обработчиков, в отличие от g_signal_emitv().

g_signal_connect()

#define             g_signal_connect(instance, detailed_signal, c_handler, data)

Подключает GCallback функцию к сигналу определённого объекта.

Обработчик будет вызван перед вызовом обработчика по умолчанию для этого сигнала.

g_signal_connect_after()

#define             g_signal_connect_after(instance, detailed_signal, c_handler, data)

Подключает GCallback функцию к сигналу определённого объекта.

Обработчик будет вызван после вызова обработчика по умолчанию для этого сигнала.

g_signal_connect_swapped()

#define             g_signal_connect_swapped(instance, detailed_signal, c_handler, data)

Подключает функцию GCallback к сигналу определённого объекта.

Экземпляр в котором издаётся сигнал и data будут меняться местами когда вызывается обработчик.

g_signal_connect_object ()

gulong              g_signal_connect_object             (gpointer instance,
                                                         const gchar *detailed_signal,
                                                         GCallback c_handler,
                                                         gpointer gobject,
                                                         GConnectFlags connect_flags);

Подобна g_signal_connect_data(), использует замыкание которое гарантирует что gobject будет существовать в течение вызова c_handler с помощью создания временной ссылки на gobject.

Помните что есть ошибка в GObject которая делает эту функцию менее удобной чем может показаться. Как только gobject расположен, callback-функция больше не вызывается, но обработчик сигнала в текущий момент не отключен. Если instance самостоятельно освободится в тоже самое время то это не имеет значения, так как сигнал будет автоматически удалён, но если instance сохранится, то обработчик сигнала приведёт к утечке памяти. Вы не должны удалять сигнал самостоятельно потому что в будущих версиях GObject, обработчик будет отключаться автоматически.

Возможное решение этой проблемы, способ который будет работать в будущих версиях GObject, проверять что обработчик сигнала остаётся подключённым перед его отключением:

 if (g_signal_handler_is_connected (instance, id))
   g_signal_handler_disconnect (instance, id);

enum GConnectFlags

typedef enum
{
  G_CONNECT_AFTER	= 1 << 0,
  G_CONNECT_SWAPPED	= 1 << 1
} GConnectFlags;

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

g_signal_connect_data ()

gulong              g_signal_connect_data               (gpointer instance,
                                                         const gchar *detailed_signal,
                                                         GCallback c_handler,
                                                         gpointer data,
                                                         GClosureNotify destroy_data,
                                                         GConnectFlags connect_flags);

Подключает функцию GCallback к сигналу определённого объекта. Подобна g_signal_connect(), но позволяет обеспечить GClosureNotify для данных которая вызывается когда обработчик сигнала отключен и больше не используется. Определяет connect_flags если вам нужны ..._after() или ..._swapped() варианты этой функции.

g_signal_connect_closure ()

gulong              g_signal_connect_closure            (gpointer instance,
                                                         const gchar *detailed_signal,
                                                         GClosure *closure,
                                                         gboolean after);

Подключает замыкание к сигналу для определённого объекта.

g_signal_connect_closure_by_id ()

gulong              g_signal_connect_closure_by_id      (gpointer instance,
                                                         guint signal_id,
                                                         GQuark detail,
                                                         GClosure *closure,
                                                         gboolean after);

Подключает замыкание к сигналу для определённого объекта.

g_signal_handler_block ()

void                g_signal_handler_block              (gpointer instance,
                                                         gulong handler_id);

Блокирует обработчик в экземпляре поэтому он не будет вызываться в течение эмиссии сигнала пока его не разблокируют снова. Таким образом "блокирование" означает временную деактивацию обработчика сигнала, обработчик сигнала должен разблокироваться тоже количество раз сколько был заблокирован до этого чтобы активизироваться снова.

handler_id должен быть допустимым идентификатором обработчика сигнала, подключаемого к сигналу экземпляра.

g_signal_handler_unblock ()

void                g_signal_handler_unblock            (gpointer instance,
                                                         gulong handler_id);

Отменяет эффект вызова g_signal_handler_block(). Блокированный сигнал пропускается в течение эмиссии сигнала и не вызывается, разблокирование (столько же раз сколько он был заблокирован перед этим) переключает состояние "блокирован", поэтому обработчик распознаётся системой сигналов и вызывается в будущей или в текущей эмиссии сигнала (так как порядок в котором обработчики вызываются в течение эмиссии сигнала детерминирован, будет ли запрашиваемый разблокированный обработчик вызван как часть текущей продолжающейся эмиссии сигнала зависит от того как долго эмиссия будет продолжаться).

handler_id должен быть допустимым идентификатором обработчика сигнала который подключается к сигналу экземпляра и в текущий момент заблокирован.

g_signal_handler_disconnect ()

void                g_signal_handler_disconnect         (gpointer instance,
                                                         gulong handler_id);

Отключаемт обработчик из экземпляра поэтому он не будет вызываться в течение любых будущих или текущих эмиссий сигнала к которым был подключен. handler_id становится недопустимым и может быть переиспользован.

handler_id должен быть допустимым идентификатором обработчика сигнала, подключённым к сигналу экземпляра.

g_signal_handler_find ()

gulong              g_signal_handler_find               (gpointer instance,
                                                         GSignalMatchType mask,
                                                         guint signal_id,
                                                         GQuark detail,
                                                         GClosure *closure,
                                                         gpointer func,
                                                         gpointer data);

Находит первый обработчик сигнала который соответствует определённым критериям выбора. Маска критерия помещается как OR-ed комбинация GSignalMatchType флагов, а значения критерия помещаются как параметры. Маска соответствия должна быть не-0 для успешного соответствия. Если обработчик не найден, возвращается 0.

g_signal_handlers_block_matched ()

guint               g_signal_handlers_block_matched     (gpointer instance,
                                                         GSignalMatchType mask,
                                                         guint signal_id,
                                                         GQuark detail,
                                                         GClosure *closure,
                                                         gpointer func,
                                                         gpointer data);

Блокирует все обработчики в экземпляре которые соответствуют определённому критерию выбора. Маска критерия помещается как комбинация OR-ed флагов GSignalMatchType, а значения критерия помещаются как параметры. Помещение по крайней мере одного из флагов соответствия G_SIGNAL_MATCH_CLOSURE, G_SIGNAL_MATCH_FUNC или G_SIGNAL_MATCH_DATA требуется для успешного сравнения. Если нет найденных обработчиков, возвращается 0, иначе количество найденных обработчиков.

g_signal_handlers_unblock_matched ()

guint               g_signal_handlers_unblock_matched   (gpointer instance,
                                                         GSignalMatchType mask,
                                                         guint signal_id,
                                                         GQuark detail,
                                                         GClosure *closure,
                                                         gpointer func,
                                                         gpointer data);

Разблокирует все обработчики в экземпляре которые соответствуют определённому критерию выбора. Маска критерия помещается как комбинация OR-ed флагов GSignalMatchType, а значения критерия помещаются как параметры. Для успешного сравнения помещается по крайней мере один из флагов соответствия G_SIGNAL_MATCH_CLOSURE, G_SIGNAL_MATCH_FUNC или G_SIGNAL_MATCH_DATA. Если нет найденных обработчиков, возвращается 0, иначе количество найденных обработчиков. Критерии соответствия не применяются к обработчикам которые в настоящий момент не заблокированы.

g_signal_handlers_disconnect_matched ()

guint               g_signal_handlers_disconnect_matched
                                                        (gpointer instance,
                                                         GSignalMatchType mask,
                                                         guint signal_id,
                                                         GQuark detail,
                                                         GClosure *closure,
                                                         gpointer func,
                                                         gpointer data);

Отключаем все сигналы в экземпляре которые соответствуют критерию отбора. Маска критерия помещается как комбинация OR-ed флагов GSignalMatchType, а значения критерия как параметры. Для успешного сравнения необходимо поместить по крайней мере один из флагов G_SIGNAL_MATCH_CLOSURE, G_SIGNAL_MATCH_FUNC или G_SIGNAL_MATCH_DATA. Если обработчики не найдены, возвращается 0, иначе количество отключаемых обработчиков.

g_signal_handler_is_connected ()

gboolean            g_signal_handler_is_connected       (gpointer instance,
                                                         gulong handler_id);

Определяет подключен ли обработчик с идентификатором handler_id в instance.

g_signal_handlers_block_by_func()

#define             g_signal_handlers_block_by_func(instance, func, data)

Блокирует все обработчики в экземпляре которые соответствуют func и data.

g_signal_handlers_unblock_by_func()

#define             g_signal_handlers_unblock_by_func(instance, func, data)

Разблокирует все обработчики в экземпляре которые соответствуют func и data.

g_signal_handlers_disconnect_by_func()

#define             g_signal_handlers_disconnect_by_func(instance, func, data)

Отключаемт все обработчики в экземпляре которые соответствуют func и data.

g_signal_has_handler_pending ()

gboolean            g_signal_has_handler_pending        (gpointer instance,
                                                         guint signal_id,
                                                         GQuark detail,
                                                         gboolean may_be_blocked);

Определяет есть ли обработчики подключенные в instance к сигналу с полученным идентификатором и детальным параметром.

Это может быть использовано когда сложно вычислить параметры сигнала. Конструктор класса может не издавать сигнал если к нему всё равно ничего не подключено, таким образом не расходуются ресурсы на формирование параметров.

g_signal_stop_emission ()

void                g_signal_stop_emission              (gpointer instance,
                                                         guint signal_id,
                                                         GQuark detail);

Останавливает текущую эмиссию сигнала.

Это предотвратит выполнение метода по умолчанию, если сигнал был G_SIGNAL_RUN_LAST и вы подключились нормально (то есть без флага "after").

Напечатает предупреждение если используется в сигнале который не издаётся.

g_signal_stop_emission_by_name ()

void                g_signal_stop_emission_by_name      (gpointer instance,
                                                         const gchar *detailed_signal);

Останавливает текущую эмиссию сигнала.

Похожа на g_signal_stop_emission() но самостоятельно определит идентификатор сигнала для вас.

g_signal_override_class_closure ()

void                g_signal_override_class_closure     (guint signal_id,
                                                         GType instance_type,
                                                         GClosure *class_closure);

Отменяет классовое замыкание (то есть обработчик по умолчанию) для данного сигнала в эмиссиях для экземпляров instance_type. instance_type должен происходить из типа к которому принадлежит сигнал.

g_signal_chain_from_overridden ()

void                g_signal_chain_from_overridden      (const GValue *instance_and_params,
                                                         GValue *return_value);

Вызывает оригинальное классовое замыкание сигнала. Эту функцию нужно вызывать только при отменённом классовом замыкании; смотрите g_signal_override_class_closure().

g_signal_add_emission_hook ()

gulong              g_signal_add_emission_hook          (guint signal_id,
                                                         GQuark detail,
                                                         GSignalEmissionHook hook_func,
                                                         gpointer hook_data,
                                                         GDestroyNotify data_destroy);

Добавляет обработчик прерывания эмиссии сигнала, который будет вызываться для любой эмиссии этого сигнала, независимо от экземпляра. Это возможно только для сигналов которые не имеют установленного флага G_SIGNAL_NO_HOOKS.

g_signal_remove_emission_hook ()

void                g_signal_remove_emission_hook       (guint signal_id,
                                                         gulong hook_id);

Удаляет обработчик прерывания эмиссии.

g_signal_parse_name ()

gboolean            g_signal_parse_name                 (const gchar *detailed_signal,
                                                         GType itype,
                                                         guint *signal_id_p,
                                                         GQuark *detail_p,
                                                         gboolean force_detail_quark);

Внутренняя функция для анализа имени сигнала содержащего его signal_id и кварк detail.

g_signal_get_invocation_hint ()

GSignalInvocationHint* g_signal_get_invocation_hint     (gpointer instance);

Возвращает подсказку вызова самой внутренней эмиссии сигнала для экземпляра.

g_signal_type_cclosure_new ()

GClosure*           g_signal_type_cclosure_new          (GType itype,
                                                         guint struct_offset);

Создаёт новое замыкание которое вызывает функцию найденную смещением struct_offset в структуре класса интерфейса или классифицированного типа идентифицируемого itype.

g_signal_accumulator_true_handled ()

gboolean            g_signal_accumulator_true_handled   (GSignalInvocationHint *ihint,
                                                         GValue *return_accu,
                                                         const GValue *handler_return,
                                                         gpointer dummy);

Предопределённый GSignalAccumulator для сигналов которые возвращают логические значения. Назначение этого сумматора состоит в том что возвращаемые TRUE останавливают эмиссию сигнала: никакие последующие callback-функции не вызываются, в то время как возвращённое FALSE позволяет продолжать эмиссию. Идея в том что возвращаемое TRUE указывает что callback-функция обработала сигнал, и дальнейшая обработка не нужна.

Начиная с версии 2.4