Создание новых типов источников

Одна из необычных особенностей функциональности основного цикла GTK+ в том, что могут создаваться новые типы источников событий в дополнение к встроенным типам источников событий. Новый тип источника событий используется для обработки GDK событий. Новый тип источника создаётся с помощью наследования из GSource структуры. Наследуемый тип источника представляется структурой которая имеет в качестве первого элемента структуру GSource, а также другие элементы специфичные для нового типа источника. Для создания экземпляра нового типа источника, вызывается g_source_new() помещая размер наследуемой структуры и таблицы функций. Эти GSourceFuncs определяют поведение нового типа источника.

Новые типы источников в основном взаимодействуют с основным контекстом двумя способами. Они подготавливают функцию в GSourceFuncs способную установить тайм аут для определения максимального промежутка времени бездействия основного цикла перед повторной проверкой. Кроме того, или в дополнение, источник может добавить файловый дескриптор для установки проверки основного контекста используя g_source_add_poll().

Настройка основной итерации цикла

Одиночная итерация GMainContext может быть выполнена с помощью g_main_context_iteration(). В некоторых случаях, вместо этого желательно более точное управление деталями работы основного цикла, например объединяя GMainLoop с внешним основным циклом. В этом случае, вы можете вызвать непосредственно составные функции g_main_context_iteration(). Этими функциями являются g_main_context_prepare(), g_main_context_query(), g_main_context_check() и g_main_context_dispatch().

Операции этих функций могут быть лучше рассмотрены в терминах диаграммы состояния, как показано на Рисунке 1, “Состояния основного контекста”.

Рисунок 1. Состояния основного контекста

GMainLoop

typedef struct _GMainLoop GMainLoop;

Структура GMainLoop непрозрачный тип данных представляющий основной цикл события GLib или GTK+ приложений.

g_main_loop_new ()

GMainLoop*  g_main_loop_new                 (GMainContext *context,
                                             gboolean is_running);

Создаёт новую структуру GMainLoop.

g_main_loop_ref ()

GMainLoop*  g_main_loop_ref                 (GMainLoop *loop);

Увеличивает счёт ссылок объекта GMainLoop на одну.

g_main_loop_unref ()

void        g_main_loop_unref               (GMainLoop *loop);

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

g_main_loop_run ()

void        g_main_loop_run                 (GMainLoop *loop);

Выполняет основной цикл до тех пор пока не вызвана g_main_loop_quit(). Если вызвана для потока (thread) GMainContext циклов, то выполняет событие из цикла, или просто ждёт.

g_main_loop_quit ()

void        g_main_loop_quit                (GMainLoop *loop);

Останавливает выполнение GMainLoop. Любые вызовы g_main_loop_run() для цикла будут возвращены.

g_main_loop_is_running ()

gboolean    g_main_loop_is_running          (GMainLoop *loop);

Выясняет выполняется ли в данный момент основной цикл через g_main_loop_run().

g_main_loop_get_context ()

GMainContext* g_main_loop_get_context       (GMainLoop *loop);

Возвращает GMainContext цикла (loop).

g_main_new()

#define     g_main_new(is_running)

Создаёт новый GMainLoop для основного цикла по умолчанию.

g_main_destroy()

#define     g_main_destroy(loop)

Освобождает память распределённую для GMainLoop.

g_main_run()

#define     g_main_run(loop)

Выполняет основной цикл до остановки.

g_main_quit()

#define     g_main_quit(loop)

Останавливает GMainLoop. Если g_main_run() был вызван для выполнения GMainLoop, он будет возвращен.

g_main_is_running()

#define     g_main_is_running(loop)

Проверяет выполняется ли основной цикл.

G_PRIORITY_HIGH

#define G_PRIORITY_HIGH            -100

Используется для повышения приоритета источников событий. Не используется внутри GLib или GTK+.

G_PRIORITY_DEFAULT

#define G_PRIORITY_DEFAULT          0

Используется для приоритета по умолчанию для источника события. В GLib этот приоритет используется когда добавляется функция-таймаут с помощью g_timeout_add(). В GDK этот приоритет используется для событий из X server.

G_PRIORITY_HIGH_IDLE

#define G_PRIORITY_HIGH_IDLE        100

Используется для повышения приоритета idle функций. GTK+ используется G_PRIORITY_HIGH_IDLE + 10 для операций изменения размера, а G_PRIORITY_HIGH_IDLE + 20 операций перерисовки. (Это выполняется для гарантии что любое изменение размера обрабатывается перед любой перерисовкой, чтобы виджеты не перерисовывались лишний раз.)

G_PRIORITY_DEFAULT_IDLE

#define G_PRIORITY_DEFAULT_IDLE     200

Используется для приоритета idle функций по умолчанию. В GLib этот приоритет используется когда добавляются idle функции с помощью g_idle_add().

G_PRIORITY_LOW

#define G_PRIORITY_LOW	            300

Этот очень медленный приоритет используется для фоновых задач. Не используется внутри GLib или GTK+.

GMainContext

typedef struct _GMainContext GMainContext;

Структура GMainContext это непрозрачный тип данных представляющий наборы источников для обработки в основном цикле.

g_main_context_new ()

GMainContext* g_main_context_new            (void);

Создаёт новую GMainContext структуру.

g_main_context_ref ()

GMainContext* g_main_context_ref            (GMainContext *context);

Увеличивает число ссылок на GMainContext объект на одну.

g_main_context_unref ()

void        g_main_context_unref            (GMainContext *context);

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

g_main_context_default ()

GMainContext* g_main_context_default        (void);

Возвращает основной контекст по умолчанию. Основной контекст используется для функции основного цикла, когда основной цикл явно не определён.

g_main_context_iteration ()

gboolean    g_main_context_iteration        (GMainContext *context,
                                             gboolean may_block);

Выполняет единственную итерацию для данного основного цикла. Это включает проверку готовы ли любые источники событий к обработке, если нет готовых источников событий и may_block равен TRUE, ждёт подготовки источника, затем отсылает самый высокий приоритет источнику событий который уже готов. Помните, что даже когда may_block равен TRUE, фукция g_main_context_iteration() всё же может вернуть FALSE, так как ожидание может быть прервано не только когда будет готов источник событий, но и по другим причинам.

g_main_iteration()

#define     g_main_iteration(may_block)

Выполняет единственную итерацию для GMainContext по умолчанию.

g_main_context_pending ()

gboolean    g_main_context_pending          (GMainContext *context);

Проверяет имеют ли источники ожидающие обработки события для данного контекста.

g_main_pending()

#define     g_main_pending()

Проверяет есть ли события ожидающие обработки для GMainContext по умолчанию.

g_main_context_find_source_by_id ()

GSource*    g_main_context_find_source_by_id
                                            (GMainContext *context,
                                             guint source_id);

Находит GSource данной пары контекста и ID.

g_main_context_find_source_by_user_data ()

GSource*    g_main_context_find_source_by_user_data
                                            (GMainContext *context,
                                             gpointer user_data);

Находит источник с полученными пользовательскими данными для callback-функции. Если существует множество источников с такими пользовательскими данными, будет возвращён первый найденный.

g_main_context_find_source_by_funcs_user_data ()

GSource*    g_main_context_find_source_by_funcs_user_data
                                            (GMainContext *context,
                                             GSourceFuncs *funcs,
                                             gpointer user_data);

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

g_main_context_wakeup ()

void        g_main_context_wakeup           (GMainContext *context);

Если context в настоящее время ожидает в poll(), прерывает poll(), и продолжает интерактивный процесс.

g_main_context_acquire ()

gboolean    g_main_context_acquire          (GMainContext *context);

Попытается стать владельцем указанного контекста. Если кто то другой владеет контекстом, немедленно возвращает FALSE. Владение является правильной рекурсией: владелец может запросить владение снова и отменить владение когда g_main_context_release() вызывается столько же раз сколько g_main_context_acquire().

Вы должны быть владельцем контекста прежде чем вы сможете вызвать g_main_context_prepare(), g_main_context_query(), g_main_context_check(), g_main_context_dispatch().

g_main_context_release ()

void        g_main_context_release          (GMainContext *context);

Отменяет владение контекстом предварительно полученное потоком с помощью g_main_context_acquire(). Если контекст был получен множество раз, отменяет владение только когда g_main_context_release() вызван соответствующее количество раз.

g_main_context_is_owner ()

gboolean    g_main_context_is_owner         (GMainContext *context);

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

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

g_main_context_wait ()

gboolean    g_main_context_wait             (GMainContext *context,
                                             GCond *cond,
                                             GMutex *mutex);

Пытается получить владение определенным контекстом, так же как с помощью g_main_context_acquire(). Но если другой поток владеет контекстом, автоматически сбрасывается в mutex и ждёт в cond пока этот владелец освободит владение или пока cond просигнализирует попытаться снова стать владельцем.

g_main_context_prepare ()

gboolean    g_main_context_prepare          (GMainContext *context,
                                             gint *priority);

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

g_main_context_query ()

gint        g_main_context_query            (GMainContext *context,
                                             gint max_priority,
                                             gint *timeout_,
                                             GPollFD *fds,
                                             gint n_fds);

Определяет информацию необходимую для опроса этого основного цикла.

g_main_context_check ()

gint        g_main_context_check            (GMainContext *context,
                                             gint max_priority,
                                             GPollFD *fds,
                                             gint n_fds);

Помещает результат опроса обратно в основной цикл.

g_main_context_dispatch ()

void        g_main_context_dispatch         (GMainContext *context);

Отправляет все ожидающие обработки источники.

g_main_context_set_poll_func ()

void        g_main_context_set_poll_func    (GMainContext *context,
                                             GPollFunc func);

Устанавливает функцию используемую для обработки опроса дескриптора файла. Используется вместо poll() системой вызовов (или функцией замены GLib's, которая используется когда poll() не доступен).

Эта функция может использоваться для интеграции GLib цикла события с внешним циклом события.

g_main_context_get_poll_func ()

GPollFunc   g_main_context_get_poll_func    (GMainContext *context);

Получает функцию опроса установленную с помощью g_main_context_set_poll_func().

GPollFunc ()

gint        (*GPollFunc)                    (GPollFD *ufds,
                                             guint nfsd,
                                             gint timeout_);

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

g_main_context_add_poll ()

void        g_main_context_add_poll         (GMainContext *context,
                                             GPollFD *fd,
                                             gint priority);

Добавляет дескриптор файла в набор дескрипторов файлов опрашиваемых для данного контекста. Это очень редко используется непосредственно. Вместо этого обычно источник события использует g_source_add_poll().

g_main_context_remove_poll ()

void        g_main_context_remove_poll      (GMainContext *context,
                                             GPollFD *fd);

Удаляет дескриптор файла из набора дескрипторов файла опрашиваемых для определенного контекста.

g_main_depth ()

gint        g_main_depth                    (void);

Возвращает значение основного цикла рекурсии в текущем потоке

static GList *free_list;

gpointer
allocate_memory (gsize size)
{ 
  gpointer result = g_malloc (size);
  free_list = g_list_prepend (free_list, result);
  return result;
}

void
free_allocated_memory (void)
{
  GList *l;
  for (l = free_list; l; l = l->next);
    g_free (l->data);
  g_list_free (free_list);
  free_list = NULL;
 }

[...]

while (TRUE); 
 {
   g_main_context_iteration (NULL, TRUE);
   free_allocated_memory();
  }

gpointer
allocate_memory (gsize size)
{ 
  FreeListBlock *block = g_new (FreeListBlock, 1);\
  block->mem = g_malloc (size);
  block->depth = g_main_depth();   
  free_list = g_list_prepend (free_list, block);
  return block->mem;
}

void
free_allocated_memory (void)
{
  GList *l;

  int depth = g_main_depth();
  for (l = free_list; l; );
    {
      GList *next = l->next;
      FreeListBlock *block = l->data;
      if (block->depth > depth)
        {
          g_free (block->mem);
          g_free (block);
          free_list = g_list_delete_link (free_list, l);
        }
          
      l = next;
    }
  }

g_main_current_source ()

GSource*    g_main_current_source           (void);

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

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

g_main_set_poll_func()

#define     g_main_set_poll_func(func)

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

g_timeout_source_new ()

GSource*    g_timeout_source_new            (guint interval);

Создаёт новый источник пауз.

Источник первоначально не связан ни с каким GMainContext и должен быть добавлен с помощью g_source_attach() перед выполнением этой функции.

g_timeout_source_new_seconds ()

GSource*    g_timeout_source_new_seconds    (guint interval);

Создаёт новый источник времени ожидания.

Первоначально не связан ни с каким GMainContext и должен быть добавлен с помощью g_source_attach() перед выполнением. Точность данного источника времени ожидания измеряется в секундах.

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

g_timeout_add ()

guint       g_timeout_add                   (guint interval,
                                             GSourceFunc function,
                                             gpointer data);

Заставляет вызывать функцию с равномерными интервалами, с приоритетом по умолчанию G_PRIORITY_DEFAULT. Функция вызывается до тех пор пока не возвращено FALSE, в этой точке время ожидания автоматически уничтожается и функция больше не вызывается. Первый вызов функции выполняется в конце первого interval.

Помните что функции паузы могут быть отсрочены, из-за обработки других событий источника. Таким образом нельзя рассчитывать на точную синхронизацию. После каждого вызова функции паузы, время следующей паузы пересчитывается исходя из текущего времени и данного интервала (это не учитывает время потерянное во время задержек).

Если вы хотите иметь таймер в "секундах" и не беспокоиться о точном времени первого вызова таймера, используйте функцию g_timeout_add_seconds(); она позволяет большую оптимизацию и более эффективное использование мощностей системы.

g_timeout_add_full ()

guint       g_timeout_add_full              (gint priority,
                                             guint interval,
                                             GSourceFunc function,
                                             gpointer data,
                                             GDestroyNotify notify);

Заставляет вызывать функцию с регулярными интервалами, с данным приоритетом. Функция вызывается до тех пор пока возвращено значение FALSE, в этой точке время ожидания автоматически уничтожается и функция больше не вызывается. Функция notify вызывается когда пауза уничтожена. Первый вызов функции происходит в конце первого interval.

Помните что функции паузы могут быть отсрочены, из-за обработки других событий источника. Таким образом нельзя рассчитывать на точную синхронизацию. После каждого вызова функции паузы, время следующей паузы пересчитывается исходя из текущего времени и данного интервала (это не учитывает время потерянное во время задержек).

g_timeout_add_seconds ()

guint       g_timeout_add_seconds           (guint interval,
                                             GSourceFunc function,
                                             gpointer data);

Вызывает функцию через равномерные интервалы, с приоритетом по умолчанию, G_PRIORITY_DEFAULT. Функция вызывается до тех пор пока не возвращено значение FALSE, в этой точке интервал автоматически уничтожается и функция больше не вызывается.

В отличии от g_timeout_add(), эта функция оперирует секундной точностью. Начальная точка таймера определяется реализацией и реализация как ожидается соберёт множество таймеров в группу, чтобы они все запускались в одно время. Чтобы позволить эту группировку, interval для первого таймера округляется и может отклониться на одну секунду от указанного интервала. Последующие итерации таймера будут в общем выполняться в указанном интервале.

Помните что тайм аут функции могут быть отсрочены, из-за обработки других источников событий. Таким образом на них нельзя рассчитывать при точной синхронизации. После каждого вызова тайм аут функции, время следующей паузы пересчитывается исходя из текущего времени и полученного интервала interval

Если вам нужны более точные расчеты нежели секунды, используйте вместо этой функции g_timeout_add().

Группирование таймеров для старта в одно и тоже время приводит к более эффективному использованию CPU, поэтому если ваш таймер в секундах и находится в множестве однотипных и вам не требуется запуск первого таймера с точностью до 1 секунды, использование g_timeout_add_second() предпочтительней чем g_timeout_add().

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

g_idle_source_new ()

GSource*    g_idle_source_new               (void);

Создаёт новый пустой (idle) источник.

Источник первоначально не связан ни с каким GMainContext и должен быть добавлен в него с помощью g_source_attach() перед выполнением. Помните что приоритетом по умолчанию idle источника является G_PRIORITY_DEFAULT_IDLE, тогда как другие источники по умолчанию имеют приоритет G_PRIORITY_DEFAULT.

g_idle_add ()

guint       g_idle_add                      (GSourceFunc function,
                                             gpointer data);

Добавляет функцию которая вызывается каждый раз когда нет обрабатываемого события с более высоким приоритетом в основном цикле по умолчанию. Функция получает по умолчанию idle приоритет, G_PRIORITY_DEFAULT_IDLE. Если функция возвращает FALSE она автоматически удаляется из списка источника событий и больше не вызывается.

g_idle_add_full ()

guint       g_idle_add_full                 (gint priority,
                                             GSourceFunc function,
                                             gpointer data,
                                             GDestroyNotify notify);

Добавляет функцию для вызова когда нет события с более высоким приоритетом на рассмотрении. Если функция возвращает FALSE, то автоматически удаляется из списка источника событий и больше не вызывается.

g_idle_remove_by_data ()

gboolean    g_idle_remove_by_data           (gpointer data);

Удаляет idle функцию с полученными данными.

GPid

typedef int GPid;

Тип содержащий идентификатор процесса. В Unix, процессы идентифицируются с помощью process id (целочисленное), в то время как в Windows используются маркеры процесса (которые являются указателями).

GChildWatchFunc ()

void        (*GChildWatchFunc)              (GPid pid,
                                             gint status,
                                             gpointer data);

Тип функций для вызова при существовании дочерних процессов.

g_child_watch_source_new ()

GSource*    g_child_watch_source_new        (GPid pid);

Создаёт новый child_watch источник.

Первоначально источник не связан ни с каким GMainContext и должен быть добавлен в него с помощью g_source_attach() перед использованием.

Помните, что дочерний процесс наблюдения может использоваться только совместно с g_spawn... когда используется флаг G_SPAWN_DO_NOT_REAP_CHILD.

Помните, что на платформах где GPid должен быть явно закрыт (смотрите g_spawn_close_pid()) pid не должен закрываться пока источник активен. Обычно, вам нужно вызывать g_spawn_close_pid() в callback-функции для источника.

Помните также что использование g_child_watch_source_new() не совместимо с вызовом waitpid(-1) в приложении. Вызов waitpid() для индивидуального pids будет прекрасно работать.

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

g_child_watch_add ()

guint       g_child_watch_add               (GPid pid,
                                             GChildWatchFunc function,
                                             gpointer data);

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

Помните что на платформах где GPid должен быть явно закрыт (смотрите g_spawn_close_pid()) pid не должен закрываться пока источник активен. Обычно, вам потребуется вызвать g_spawn_close_pid() в callback-функции для источника.

GLib поддерживает только один вызов callback-функции через process id.

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

g_child_watch_add_full ()

guint       g_child_watch_add_full          (gint priority,
                                             GPid pid,
                                             GChildWatchFunc function,
                                             gpointer data,
                                             GDestroyNotify notify);

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

Помните что на платформах где GPid должен быть закрыт явно (смотрите g_spawn_close_pid()) pid не должен закрываться пока источник активен. Обычно, вам необходимо вызвать g_spawn_close_pid() в callback-функции для источника.

GLib поддерживает только единственный вызов callback-функции через process id.

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

GPollFD

typedef struct {
  gint		fd;
  gushort 	events;
  gushort 	revents;
} GPollFD;

GSource

typedef struct {
} GSource;

Структура GSource непрозрачного типа данных представляющих источник события.

GSourceDummyMarshal ()

void        (*GSourceDummyMarshal)          (void);

Это просто метка для GClosureMarshal, которая не используется по причине зависимостей.

GSourceFuncs

typedef struct {
  gboolean (*prepare)  (GSource    *source,
			gint       *timeout_);
  gboolean (*check)    (GSource    *source);
  gboolean (*dispatch) (GSource    *source,
			GSourceFunc callback,
			gpointer    user_data);
  void     (*finalize) (GSource    *source); /* Может быть NULL */

  /* Для использования g_source_set_closure */
  GSourceFunc     closure_callback;	   
  GSourceDummyMarshal closure_marshal; /* Фактически тип GClosureMarshal */
} GSourceFuncs;

Структура GSourceFuncs содержит таблицу функций используемых для обработки источника события основным способом.

Для idle источников, функции prepare и check всегда возвращают TRUE указывая что источник всегда готов к обработке. Функция prepare также возвращает значение тайм аута равное 0, чтобы гарантировать что вызов poll() не заблокируется (так как это было бы впустую потраченным временем которое можно потратить на idle функцию).

Для источников, обе функции prepare и check возвращают TRUE если интервал тайм аута истек. Функция prepare также возвращает значение таймаута, чтобы гарантировать что вызов poll() не блокируется слишком долго и не пропустит следующий таймаут.

Для источников дескриптора файлов, функция prepare обычно возвращает FALSE, так как нужно ждать пока poll() будет вызвана перед определением нужно ли обрабатывать какое нибудь событие. Это установит возвращённый тайм аут в значение -1 указывая что не знает как долго блокирован вызов poll(). В функции check, проверяет результат вызова poll() чтобы видеть встречалось ли необходимое условие, и возвращает TRUE.

GSourceCallbackFuncs

typedef struct {
  void (*ref)   (gpointer     cb_data);
  void (*unref) (gpointer     cb_data);
  void (*get)   (gpointer     cb_data,
		 GSource     *source, 
		 GSourceFunc *func,
		 gpointer    *data);
} GSourceCallbackFuncs;

Структура GSourceCallbackFuncs содержит функции для управления callback-объектами.

g_source_new ()

GSource*    g_source_new                    (GSourceFuncs *source_funcs,
                                             guint struct_size);

Содаёт новую структуру GSource. Размер определяется для создания структур полученных из GSource который содержит дополнительные данные. Помещаемый размер должен быть как минимум sizeof (GSource).

Первоначально источник не связан ни с каким GMainContext и должен быть добавлен в него с помощью g_source_attach() перед использованием.

g_source_ref ()

GSource*    g_source_ref                    (GSource *source);

Увеличивает количество ссылок источника на одну.

g_source_unref ()

void        g_source_unref                  (GSource *source);

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

g_source_set_funcs ()

void        g_source_set_funcs              (GSource *source,
                                             GSourceFuncs *funcs);

Отсоединяет функции от источника (может использоваться для отмены выполнения по умолчанию).

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

g_source_attach ()

guint       g_source_attach                 (GSource *source,
                                             GMainContext *context);

Добавляет GSource в context так чтобы он выполнялся внутри контекста.

g_source_destroy ()

void        g_source_destroy                (GSource *source);

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

g_source_is_destroyed ()

gboolean    g_source_is_destroyed           (GSource *source);

Определяет уничтожен ли source.

Это важно когда вы оперируете с вашими объектами внутри idle обработчиков, но при этом возможно освободили объект перед отправкой вашего idle обработчика.

static gboolean 
idle_callback (gpointer data)
{
  SomeWidget *self = data;
   
  GDK_THREADS_ENTER ();
  /* заполняется самостоятельно */
  self->idle_id = 0;
  GDK_THREADS_LEAVE ();
   
  return FALSE;
}
 
static void 
some_widget_do_stuff_later (SomeWidget *self)
{
  self->idle_id = g_idle_add (idle_callback, self);
}
 
static void 
some_widget_finalize (GObject *object)
{
  SomeWidget *self = SOME_WIDGET (object);
   
  if (self->idle_id)
    g_source_remove (self->idle_id);
   
  G_OBJECT_CLASS (parent_class)->finalize (object);
}

Этот пример завершится неудачей в много-потоковом приложении если виджет уничтожен перед запуском idle обработчика из-за использования после освобождения в обратном вызове. Решение этой специфической проблемы в том, чтобы проверить уничтожен ли уже источник в обратном вызове.

static gboolean 
idle_callback (gpointer data)
{
  SomeWidget *self = data;
  
  GDK_THREADS_ENTER();
  if (!g_source_is_destroyed (g_main_current_source()))
    {
      /* заполняется самостоятельно */
    }
  GDK_THREADS_LEAVE();
  
  return FALSE;
}

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

g_source_set_priority ()

void        g_source_set_priority           (GSource *source,
                                             gint priority);

Устанавливает приоритет источника. Во время выполнения основного цикла, источник отправляется если готов и нет готовых источников с более высоким приоритетом (с меньшим номером).

g_source_get_priority ()

gint        g_source_get_priority           (GSource *source);

Определяет приоритет источника.

g_source_set_can_recurse ()

void        g_source_set_can_recurse        (GSource *source,
                                             gboolean can_recurse);

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

g_source_get_can_recurse ()

gboolean    g_source_get_can_recurse        (GSource *source);

Проверяет разрешено ли источнику вызываться рекурсивно. (смотрите g_source_set_can_recurse()).

g_source_get_id ()

guint       g_source_get_id                 (GSource *source);

Возвращает число ID для специального источника. ID источника это положительное целое которое является уникальным внутри определённого контекста основного цикла. Обратное преобразование из ID в источник выполняется с помощью g_main_context_find_source_by_id().

g_source_get_context ()

GMainContext* g_source_get_context          (GSource *source);

Определяет GMainContext с которым связан источник. Вызов этой функции для уничтоженного источника недопустим.

g_source_set_callback ()

void        g_source_set_callback           (GSource *source,
                                             GSourceFunc func,
                                             gpointer data,
                                             GDestroyNotify notify);

Устанавливает callback-функцию для источника. callback-функция для источника вызывается из dispatch функции источников.

Точный тип func зависит от типа источника; то есть вы не должны рассчитывать на func вызванную с data как её первый параметр.

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

GSourceFunc ()

gboolean    (*GSourceFunc)                  (gpointer data);

Конкретизирует тип функции помещаемой в g_timeout_add(), g_timeout_add_full(), g_idle_add() и g_idle_add_full().

g_source_set_callback_indirect ()

void        g_source_set_callback_indirect  (GSource *source,
                                             gpointer callback_data,
                                             GSourceCallbackFuncs *callback_funcs);

Устанавливает callback-функцию хранения данных как refcounted callback "object". Это используется внутренне. Помните что вызов g_source_set_callback_indirect() предполагает, что начат подсчёт ссылок на callback_data, и поэтому callback_funcs->unref будет в конечном счёте вызван больше чем callback_funcs->ref.

g_source_add_poll ()

void        g_source_add_poll               (GSource *source,
                                             GPollFD *fd);

Добавляет дескриптор в набор опрашиваемых дескрипторов файла для данного источника. Это полезно комбинировать с g_source_new() для добавления источника события. Функция проверки источников события обычно проверяет поле revents в GPollFD структуре и возвращает TRUE если события должны быть обработаны.

g_source_remove_poll ()

void        g_source_remove_poll            (GSource *source,
                                             GPollFD *fd);

Удаляет дескриптор файла из набора опрашиваемых дескрипторов файла для данного источника.

g_source_get_current_time ()

void        g_source_get_current_time       (GSource *source,
                                             GTimeVal *timeval);

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

g_source_remove ()

gboolean    g_source_remove                 (guint tag);

Удаляет источник с полученным id из основного контекста по умолчанию. Идентификатор (id) GSource получается при помощи g_source_get_id(), или возвращается функциями g_source_attach(), g_idle_add(), g_idle_add_full(), g_timeout_add(), g_timeout_add_full(), g_child_watch_add(), g_child_watch_add_full(), g_io_add_watch() и g_io_add_watch_full().

Смотрите также g_source_destroy().

g_source_remove_by_funcs_user_data ()

gboolean    g_source_remove_by_funcs_user_data
                                            (GSourceFuncs *funcs,
                                             gpointer user_data);

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

g_source_remove_by_user_data ()

gboolean    g_source_remove_by_user_data    (gpointer user_data);

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