Main loop and Events

Каталог документации / Раздел "Программирование, языки" / Оглавление документа

			GTK+ Reference Manual
Top \| Description

Основной цикл и События

Main loop and Events Инициализация библиотеки, основной цикл и события

Краткий обзор

#include <gtk/gtk.h>


gchar*      gtk_set_locale                  (void);
void        gtk_disable_setlocale           (void);
PangoLanguage* gtk_get_default_language     (void);
gboolean    gtk_parse_args                  (int *argc,
                                             char ***argv);
void        gtk_init                        (int *argc,
                                             char ***argv);
gboolean    gtk_init_check                  (int *argc,
                                             char ***argv);
gboolean    gtk_init_with_args              (int *argc,
                                             char ***argv,
                                             char *parameter_string,
                                             GOptionEntry *entries,
                                             char *translation_domain,
                                             GError **error);
GOptionGroup* gtk_get_option_group          (gboolean open_default_display);
void        gtk_exit                        (gint error_code);
gboolean    gtk_events_pending              (void);
void        gtk_main                        (void);
guint       gtk_main_level                  (void);
void        gtk_main_quit                   (void);
gboolean    gtk_main_iteration              (void);
gboolean    gtk_main_iteration_do           (gboolean blocking);
void        gtk_main_do_event               (GdkEvent *event);
void        (*GtkModuleInitFunc)            (gint *argc,
                                             gchar ***argv);
void        (*GtkModuleDisplayInitFunc)     (GdkDisplay *display);

gboolean    gtk_true                        (void);
gboolean    gtk_false                       (void);

void        gtk_grab_add                    (GtkWidget *widget);
GtkWidget*  gtk_grab_get_current            (void);
void        gtk_grab_remove                 (GtkWidget *widget);

void        gtk_init_add                    (GtkFunction function,
                                             gpointer data);
void        gtk_quit_add_destroy            (guint main_level,
                                             GtkObject *object);
guint       gtk_quit_add                    (guint main_level,
                                             GtkFunction function,
                                             gpointer data);
guint       gtk_quit_add_full               (guint main_level,
                                             GtkFunction function,
                                             GtkCallbackMarshal marshal,
                                             gpointer data,
                                             GtkDestroyNotify destroy);
void        gtk_quit_remove                 (guint quit_handler_id);
void        gtk_quit_remove_by_data         (gpointer data);

guint       gtk_timeout_add_full            (guint32 interval,
                                             GtkFunction function,
                                             GtkCallbackMarshal marshal,
                                             gpointer data,
                                             GtkDestroyNotify destroy);
guint       gtk_timeout_add                 (guint32 interval,
                                             GtkFunction function,
                                             gpointer data);
void        gtk_timeout_remove              (guint timeout_handler_id);

guint       gtk_idle_add                    (GtkFunction function,
                                             gpointer data);
guint       gtk_idle_add_priority           (gint priority,
                                             GtkFunction function,
                                             gpointer data);
guint       gtk_idle_add_full               (gint priority,
                                             GtkFunction function,
                                             GtkCallbackMarshal marshal,
                                             gpointer data,
                                             GtkDestroyNotify destroy);
void        gtk_idle_remove                 (guint idle_handler_id);
void        gtk_idle_remove_by_data         (gpointer data);

guint       gtk_input_add_full              (gint source,
                                             GdkInputCondition condition,
                                             GdkInputFunction function,
                                             GtkCallbackMarshal marshal,
                                             gpointer data,
                                             GtkDestroyNotify destroy);
void        gtk_input_remove                (guint input_handler_id);

#define     GTK_PRIORITY_REDRAW
#define     GTK_PRIORITY_RESIZE
#define     GTK_PRIORITY_HIGH
#define     GTK_PRIORITY_INTERNAL
#define     GTK_PRIORITY_DEFAULT
#define     GTK_PRIORITY_LOW

guint       gtk_key_snooper_install         (GtkKeySnoopFunc snooper,
                                             gpointer func_data);
gint        (*GtkKeySnoopFunc)              (GtkWidget *grab_widget,
                                             GdkEventKey *event,
                                             gpointer func_data);
void        gtk_key_snooper_remove          (guint snooper_handler_id);

GdkEvent*   gtk_get_current_event           (void);
guint32     gtk_get_current_event_time      (void);
gboolean    gtk_get_current_event_state     (GdkModifierType *state);
GtkWidget*  gtk_get_event_widget            (GdkEvent *event);
void        gtk_propagate_event             (GtkWidget *widget,
                                             GdkEvent *event);

Описание

Перед использованием GTK+, вам нужно её инициализировать; инициализация подключает оконную систему отображения и анализирует некоторые стандартные аргументы командной строки. Инициализацию GTK+ выполняет функция gtk_init(). gtk_init() прекращает работу если поступило сообщение об ошибке; чтобы это избежать, используйте gtk_init_check(). gtk_init_check() позволяет восстановить неудавшуюся инициализацию GTK+ - вместо этого вы можете запустить ваше приложение в текстовом режиме.

Как и все наборы инструментов GUI, GTK+ использует управляемую событиями модель программирования. Когда пользователь ничего не делает, GTK+ находится в основном цикле (main loop) и ждет ввода. Если пользователь произвёл некоторое действие скажем, нажал кнопку мыши то в основной цикл GTK+ поступает событие и он просыпается "wakes up". GTK+ пересылает событие к одному или нескольким виджетам.

Когда виджеты получают событие, они часто производят один или несколько сигналов (signals), сигналы сообщают вашей программе что "случилось нечто интересное", вызывая функции подключенные вами к сигналам с помощью g_signal_connect(). Функции подключенные к сигналам часто называются callback-функция или функция обратного вызова (callbacks).

Когда ваши callback-функции вызваны, вы обычно предпринимаете некоторое действие - например, когда нажата кнопка Open вы могли бы отобразить GtkFileSelectionDialog. После завершения обратного вызова, GTK+ возвращается в основной цикл для ожидания дальнейших действий пользователя.

Пример 1. Типичная main функция для GTK+ приложения

int 
main (int argc, char **argv)
{
  /* Инициализируем поддержку i18n */
  gtk_set_locale ();

  /* Инициализируем установки виджета */
  gtk_init (&argc, &argv);

  /* Создаём основное окно */
  mainwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);

  /* Устанавливаем наши элементы GUI */
  ...

  /* Показываем окно приложения */
  gtk_widget_show_all (mainwin);

  /* Входим в основной цикл и ждем действий пользователя */
  gtk_main ();

  /* Пользователь утратил интерес */
  return 0;
}

Можно использовать непосредственно основной цикл GLib вместо gtk_main(), хотя это требует немного большего ввода. Смотрите GMainLoop в документации по GLib.

Детали

gtk_set_locale ()

gchar*      gtk_set_locale                  (void);

Инициализирует поддержку интернационализации для GTK+. gtk_init() автоматически выполняет это, поэтому обычно нет смысла в вызове этой функции.

Если вы вызвали эту функцию для изменения языковой среды после инициализации GTK+, то она вам немного поможет. (Однако отметьте, что изменения языковой среды после инициализации GTK+ может привести к непредсказуемым результатам и реально не поддерживается.)

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

Возвращает:

Строку соответствующую установленной языковой среде, обычная форма lang_COUNTRY, где lang это код языка в системе ISO-639, а COUNTRY это код страны ISO-3166. В Unix, эта форма соответствует результату setlocale(); которая также используется в других системах, таких как Windows, где библиотека C возвращает другой результат. Строка принадлежит GTK+ и не должна модифицироваться или освобождаться.

gtk_disable_setlocale ()

void        gtk_disable_setlocale           (void);

Предотвращает gtk_init(), gtk_init_check(), gtk_init_with_args() и gtk_parse_args() от автоматического вызова setlocale (LC_ALL, ""). Вы могли бы использовать эту функцию для установки языковой среды вашей программы отличающейся от пользовательской, или если вы хотите установить различные значения для различных категорий локалей.

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

gtk_get_default_language ()

PangoLanguage* gtk_get_default_language     (void);

Возвращает PangoLanguage, действительный на данное время по умолчанию язык. (Помните, это можно изменить через параметры приложения.) По умолчанию язык вторичная форма текущемй локали. Это например определяет какое направление текста использует GTK+ слева на право или наоборот. Смотрите _gtk_get_lc_ctype() для примечаний относительно поведения в Windows.

Возвращает :

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

gtk_parse_args ()

gboolean    gtk_parse_args                  (int *argc,
                                             char ***argv);

Анализирует аргументы командной строки и инициализирует глобальные атрибуты GTK+, но не открывает фактическое подключение к дисплею. (Смотрите gdk_display_open(), gdk_get_display_arg_name())

Любые аргументы используемые GTK+ или GDK удаляются из массивов argc и argv соответственно обновляясь.

Вы не должны вызывать эту функцию если вы явно используете gtk_init(), или gtk_init_check().

`argc` :	Указатель номеров аргументов командной строки.
`argv` :	Указатель на массив аргументов командной строки.
Возвращает :	`TRUE` если инициализация выполнена, иначе `FALSE`.

gtk_init ()

void        gtk_init                        (int *argc,
                                             char ***argv);

Эта функция вызывается перед любыми другими функциями GTK+ в вашей программе. Она инициализирует всё что нужно для управления и анализирует некоторые стандартные аргументы командной строки. argc и argv откорректированы соответствующим образом, поэтому ваш собственный код никогда не увидит стандартных аргументов.

Помните, есть некоторые альтернативные пути инициализации GTK+: если вы вызовите gtk_parse_args(), gtk_init_check(), gtk_init_with_args() или g_option_context_parse() с группой опций возвращённых gtk_get_option_group(), вы не должны вызывать gtk_init().

Напоминание

Эта функция закроет вашу программу если она не сможет инициализировать GUI по некоторым причинам. Если вы хотите чтобы ваша программа переходила в текстовый режим вместо закрытия, вы должны использовать gtk_init_check().

Напоминание

`argc` :	Адрес параметра `argc` в вашей `main()` функции. Изменяется если какие-нибудь параметры были обработаны.
`argv` :	Адрес `argv` параметра `main()`. Любые параметры понятные для `gtk_init()` зачищаются перед возвращением.

gtk_init_check ()

gboolean    gtk_init_check                  (int *argc,
                                             char ***argv);

Эта функция выполняет ту же работу что и gtk_init() с одним отличием: Она не закрывает программу если GUI не смог инициализироваться. Вместо этого она возвращает FALSE во время сбоя.

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

`argc` :	Адрес параметра `argc` в вашей `main()` функции. Изменяется если какие-нибудь параметры были обработаны.
`argv` :	Адрес `argv` параметра `main()`. Любые параметры понятные для `gtk_init()` зачищаются перед возвращением.
Возвращает :	`TRUE` если GUI смог полностью инициализироваться, `FALSE` в любом другом случае.

gtk_init_with_args ()

gboolean    gtk_init_with_args              (int *argc,
                                             char ***argv,
                                             char *parameter_string,
                                             GOptionEntry *entries,
                                             char *translation_domain,
                                             GError **error);

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

`argc` :	указатель номера аргумента командной строки.
`argv` :	указатель на массив аргументов командной строки.
`parameter_string` :	Строка которая отображается в первой линии вывода `--help`, после `programname [OPTION...]`
`entries` :	Массив с `NULL`-символом в конце GOptionEntrys описание опций вашей программы
`translation_domain` :	область преобразования использующаяся для перевода вывода `help`, для опции `entries` с `gettext()`, или `NULL`
`error` :	Место для хранения возвращаемых ошибок
Возвращает :	`TRUE` если GUI был полностью инициализирован, `FALSE` в любом другом случае.

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

gtk_get_option_group ()

GOptionGroup* gtk_get_option_group          (gboolean open_default_display);

Возвращает GOptionGroup для параметров командной строки распознанных GTK+ и GDK. Вы должны добавить эту группу в ваш GOptionContext с помощью g_option_context_add_group(), если вы используете g_option_context_parse() для анализа ваших аргументов командной строки.

`open_default_display` :	Открыт ли дисплей по умолчанию когда анализируются параметры командной строки
Возвращает :	GOptionGroup для распознанных GTK+ аргументов командной строки

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

gtk_exit ()

void        gtk_exit                        (gint error_code);

Внимание

gtk_exit устарела и не нужно её использовать во вновь создаваемом коде. Вместо неё используйте стандартную функцию exit().

Закрывает программу и возвращает полученный при выходе код. Эта функция полностью выключает GUI и освобождает ресурсы выделенные для GTK+.

error_code :

Возвращает значение помещенное вызовом. Это зависит от целевой системы, но по крайней мере в Unix системах 0 успешное выполнение.

gtk_events_pending ()

gboolean    gtk_events_pending              (void);

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

Пример 2. Обновление GUI в течении длительного вычисления.

        /* выполняются вычисления */
...
        while (gtk_events_pending ())
          gtk_main_iteration ();
...
        /* вычисления продолжаются */

Возвращает :

TRUE если какое-нибудь событие обрабатывается, FALSE в любом другом случае.

gtk_main ()

void        gtk_main                        (void);

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

gtk_main_level ()

guint       gtk_main_level                  (void);

Запрашивает текущий уровень вложенности в основном цикле. Это может быть полезным когда вызывается gtk_quit_add().

Возвращает :

Уровень вложенности текущемго запроса основного цикла.

gtk_main_quit ()

void        gtk_main_quit                   (void);

Делает самый глубокий запрос возвращённый из основного цикла, когда получает контроль.

gtk_main_iteration ()

gboolean    gtk_main_iteration              (void);

Выполняет единственную итерацию mainloop. Если нет событий ожидающих обработки, GTK+ будет блокирован пока не произойдет следующее событие. Если вы не хотите блокировать, то смотрите gtk_main_iteration_do() или сначала проверяйте какие события находятся на рассмотрении с помощью gtk_events_pending().

Возвращает :

TRUE Если gtk_main_quit() может быть вызван для самого внутреннего mainloop.

gtk_main_iteration_do ()

gboolean    gtk_main_iteration_do           (gboolean blocking);

Выполняет единственную итерацию mainloop. Если нет любых доступных событий возвращения или блокирования зависящего от значения blocking.

`blocking` :	`TRUE` Если нужно блокировать GTK+ когда нет событий на рассмотрении.
Возвращает :	`TRUE` Если `gtk_main_quit()` может быть вызван самый внутренний mainloop.

gtk_main_do_event ()

void        gtk_main_do_event               (GdkEvent *event);

Обрабатывает единственное событие GDK. Это позволяет фильтровать события между GDK и GTK+. Вы не будете нуждаться в непосредственном вызове этой функции.

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

Сжимает вход/выход зарегистрированных событий. Если событие прошло создавая спаренное событие входа/выхода со следующим, то оба события выбрасываются (peeked from GDK). Это предотвращает нежелательное выделение виджета при пересечении с указателем.
Находит виджет который получил событие. Если виджет не может быть определён, событие отбрасывается или передаётся функции gtk_selection_incr_event()являясь транзакцией INCR.
Передаёт событие в стек, таким образом вы можете запросить текущую обработку события с помощью функции gtk_get_current_event().
Передаёт событие виджету. Если активен перехват всех событий для виджетов, те которые не помещены в виджет перехвата передаются позже с некоторыми исключениями:
- Удаляются и разрушаются замороженные события отправленные виджету события, по очевидным причинам.
- События непосредственно связанные с визуальным отображением виджета событий.
- События выхода поставляемые виджету событий, если событие входа переданное ему прежде, не спарено с событием выхода.
- Перемещаемые события не переадресованы, потому что неясна семантика.
Другой интересный момент заключается в том, что все ключевые события первыми проходят через ключевые функции слежения. Прочтите описание gtk_key_snooper_install() если вам нужна эта особенность.
После завершения передачи, событие выталкивается из стека событий.

event :

Событие передаваемое для обработки GDK.

GtkModuleInitFunc ()

void        (*GtkModuleInitFunc)            (gint *argc,
                                             gchar ***argv);

Каждый модуль GTK+ должен иметь функцию gtk_module_init() с этим прототипом. Эта функция вызывается после загрузки модулей очищенных argc и argv от любых параметров, которые GTK+ обрабатывает самостоятельно.

`argc` :	Указывает номер аргумента оставленного после `gtk_init()`.
`argv` :	Пункты вектора аргумента.

GtkModuleDisplayInitFunc ()

void        (*GtkModuleDisplayInitFunc)     (GdkDisplay *display);

display :

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

gtk_true ()

gboolean    gtk_true                        (void);

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

Пример 3.Не закрывающееся окно

#include <gtk/gtk.h>

int
main (int argc, char **argv)
{
  GtkWidget     *win, *but;

  gtk_init( &argc, &argv );

  win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  g_signal_connect (win, "delete-event",
                    G_CALLBACK (gtk_true), NULL);
  g_signal_connect (win, "destroy",
                    G_CALLBACK (gtk_main_quit), NULL);

  but = gtk_button_new_with_label ("Close yourself. I mean it!");
  g_signal_connect_swapped (but, "clicked",
                  G_CALLBACK (gtk_object_destroy), win);
  gtk_container_add (GTK_CONTAINER (win), but);

  gtk_widget_show_all (win);
  gtk_main ();
  return 0;
}

Возвращает :

TRUE

gtk_false ()

gboolean    gtk_false                       (void);

Аналог gtk_true(), но эта функция всегда возвращает FALSE.

Возвращает :

FALSE

gtk_grab_add ()

void        gtk_grab_add                    (GtkWidget *widget);

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

widget :

Виджет который перехватывает события клавиатуры и мыши.

gtk_grab_get_current ()

GtkWidget*  gtk_grab_get_current            (void);

Запрашивает текущую перехваченную по умолчанию группу окна.

Возвращает :

Виджет который в данный момент перехвачен, или NULL если нет активного перехвата.

gtk_grab_remove ()

void        gtk_grab_remove                 (GtkWidget *widget);

Удаляет захват данного виджета. Вы имеете спаренные вызовы gtk_grab_add() и gtk_grab_remove().

widget :

Виджет который в данный момент захвачен.

gtk_init_add ()

void        gtk_init_add                    (GtkFunction function,
                                             gpointer data);

Регистрирует функцию вызванную при запуске основного цикла (mainloop).

`function` :	Функция вызываемая после `gtk_main()`.
`data` :	Данные помещаемые в данную функцию.

gtk_quit_add_destroy ()

void        gtk_quit_add_destroy            (guint main_level,
                                             GtkObject *object);

Более аккуратное разрушение object в этом случае выход из основного цикла происходит на уровне main_level.

`main_level` :	Уровень на котором происходит аккуратный выход из основного цикла.
`object` :	Разрушаемый объект.

gtk_quit_add ()

guint       gtk_quit_add                    (guint main_level,
                                             GtkFunction function,
                                             gpointer data);

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

`main_level` :	Уровень с которого вызвана функция прекращения. Вы можете поместить сюда 0 чтобы иметь функцию выполняющую прекращение текущемго основного цикла.
`function` :	Функция для вызова. Должна возвращать 0 чтобы удалиться из списка обработчика выхода. Иначе функция может быть вызвана снова.
`data` :	Пункты помещаемые в вызываемую `function`.
Возвращает :	Маркер для обработчика выхода (вам нужно это для `gtk_quit_remove()`) или 0 если вы поместили `NULL` в `function`.

gtk_quit_add_full ()

guint       gtk_quit_add_full               (guint main_level,
                                             GtkFunction function,
                                             GtkCallbackMarshal marshal,
                                             gpointer data,
                                             GtkDestroyNotify destroy);

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

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

`main_level` :	Уровень на котором должна быть вызвана функция прекращения. Вы можете поместить сюда 0, чтобы иметь функцию вызываемую при завершении текущемго основного цикла.
`function` :	Функция которая вызывается. Должна возвращать 0 чтобы удалиться из списка обработчика выхода. Иначе функция может быть вызвана снова.
`marshal` :	Используемый сигнальщик (marshaller). Если не-`NULL`, `function` игнорируется.
`data` :	Данные помещаемые в вызванную `function`.
`destroy` :	Вызов функции для разрушения `data`. Получает `data` как аргумент.
Возвращает :	Маркер для обработчика выхода (вам нужно это для `gtk_quit_remove()`) или 0 если вы поместили `NULL` в `function`.

gtk_quit_remove ()

void        gtk_quit_remove                 (guint quit_handler_id);

Удаляет обработчик выхода с помощью идентификатора.

quit_handler_id :

Идентификатор возвращенный из обработчика.

gtk_quit_remove_by_data ()

void        gtk_quit_remove_by_data         (gpointer data);

Удаляет обработчик выхода идентифицируемый полем data.

data :

Указатель размещённый как data в gtk_quit_add() или gtk_quit_add_full().

gtk_timeout_add_full ()

guint       gtk_timeout_add_full            (guint32 interval,
                                             GtkFunction function,
                                             GtkCallbackMarshal marshal,
                                             gpointer data,
                                             GtkDestroyNotify destroy);

Внимание

gtk_timeout_add_full устарела и не должна использоваться во вновь создаваемом коде, вместо неё используйте g_timeout_add_full().

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

`interval` :	Время между вызовами функции, в миллисекундах (1/1000ths секунды.)
`function` :	Периодически вызываемая функция.
`marshal` :	Сигнальщик используемый вместо функции (если не-`NULL`).
`data` :	Данные помещаемые в функцию.
`destroy` :	Функция вызываемая когда перерыв разрушен или равен `NULL`.
Возвращает :	Уникальный id для исходного события.

gtk_timeout_add ()

guint       gtk_timeout_add                 (guint32 interval,
                                             GtkFunction function,
                                             gpointer data);

Внимание

gtk_timeout_add устарела и не должна использоваться во вновь создаваемом коде, вместо неё используйте g_timeout_add().

`interval` :	Время между вызовами функции, в миллисекундах (1/1000ths секунды.)
`function` :	Периодически вызываемая функция.
`data` :	Данные помещаемые в функцию.
Возвращает :	Уникальный id для исходного события.

gtk_timeout_remove ()

void        gtk_timeout_remove              (guint timeout_handler_id);

Внимание

gtk_timeout_remove устарела и не должна использоваться во вновь создаваемом коде, вместо неё используйте g_source_remove().

Удаляет при разрушении паузы всю полученную информацию.

timeout_handler_id :

Идентификатор возвращаемый при установки паузы.

gtk_idle_add ()

guint       gtk_idle_add                    (GtkFunction function,
                                             gpointer data);

Внимание

gtk_idle_add устарела и не должна использоваться во вновь создаваемом коде, вместо неё используйте g_idle_add() .

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

`function` :	Вызываемая функция.
`data` :	Информация помещаемая в функцию.
Возвращает :	Уникальный дескриптор для этой регистрации.

gtk_idle_add_priority ()

guint       gtk_idle_add_priority           (gint priority,
                                             GtkFunction function,
                                             gpointer data);

Внимание

gtk_idle_add_priority устарела и не должна использоваться во вновь создаваемом коде, вместо неё используйте g_idle_add_full() .

Как и gtk_idle_add() эта функция позволяет вызывать функцию когда в основном цикле ничего не происходит. Различие в том, что вы можете присвоить приоритет отличный от GTK_PRIORITY_DEFAULT пустой функции.

`priority` :	Приоритет который не должен быть выше `G_PRIORITY_HIGH_IDLE`. Помните, вы вмешаетесь в GTK+ если установите приоритет выше `GTK_PRIORITY_RESIZE`.
`function` :	Вызываемая функция.
`data` :	Данные помещаемые в функцию.
Возвращает :	Уникальный id для исходного события.

gtk_idle_add_full ()

guint       gtk_idle_add_full               (gint priority,
                                             GtkFunction function,
                                             GtkCallbackMarshal marshal,
                                             gpointer data,
                                             GtkDestroyNotify destroy);

Внимание

gtk_idle_add_full устарела и не должна использоваться во вновь создаваемом коде, вместо неё используйте g_idle_add_full() .

`priority` :	Приоритет который не должен быть выше `G_PRIORITY_HIGH_IDLE`. Помните, вы вмешаетесь в GTK+ если установите приоритет выше `GTK_PRIORITY_RESIZE`.
`function` :	Вызываемая функция.
`marshal` :	Сигнальщик используемый вместо функции (если не-`NULL`).
`data` :	Данные помещаемые в функцию.
`destroy` :	Функция вызываемая после завершения паузы или `NULL`.
Возвращает :	Уникальный id для исходного события.

gtk_idle_remove ()

void        gtk_idle_remove                 (guint idle_handler_id);

Внимание

gtk_idle_remove устарела и не должна использоваться во вновь создаваемом коде, вместо неё используйте g_source_remove() .

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

idle_handler_id :

Идентификатор пустой функции для удаления.

gtk_idle_remove_by_data ()

void        gtk_idle_remove_by_data         (gpointer data);

Внимание

gtk_idle_remove_by_data устарела и не должна использоваться во вновь создаваемом коде, вместо неё используйте g_idle_remove_by_data().

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

data :

Данные идентифицирующие пустую функцию для удаления.

gtk_input_add_full ()

guint       gtk_input_add_full              (gint source,
                                             GdkInputCondition condition,
                                             GdkInputFunction function,
                                             GtkCallbackMarshal marshal,
                                             gpointer data,
                                             GtkDestroyNotify destroy);

Внимание

gtk_input_add_full устарела и не должна использоваться во вновь создаваемом коде, вместо неё используйте g_io_add_watch_full().

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

`source` :	Дескриптор файла.
`condition` :	условие.
`function` :	Функция вызова.
`marshal` :	Сигнальщик используемый вместо функции (если не-`NULL`).
`data` :	Данные обратного вызова помещённые `function`.
`destroy` :	Callback-функция вызванная с `data` , когда обработчик ввода удалён, или равен `NULL`.
Возвращает :	Уникальный id для исходного события; может использоваться с функцией `gtk_input_remove()`.

gtk_input_remove ()

void        gtk_input_remove                (guint input_handler_id);

Внимание

gtk_input_remove устарела и не должна использоваться во вновь создаваемом коде, вместо неё используйте g_source_remove().

Удаляет функцию с данным id.

input_handler_id :

Идентификатор функции для удаления.

GTK_PRIORITY_REDRAW

#define GTK_PRIORITY_REDRAW     (G_PRIORITY_HIGH_IDLE + 20)

Внимание

GTK_PRIORITY_REDRAW устарел и не должен использоваться во вновь создаваемом коде.

Используется для перерисовки связанного материала. Это используется внутри GTK+, чтобы выполнить незаконченные перерисовки. Этот приоритет ниже чем GTK_PRIORITY_RESIZE, чтобы избежать перерисовки перед изменением размера виджета (потому что это дублирующая перерисовка).

Предупреждение

Этот макрос устарел. Вы должны использовать вместо него GDK_PRIORITY_REDRAW.

GTK_PRIORITY_RESIZE

#define GTK_PRIORITY_RESIZE     (G_PRIORITY_HIGH_IDLE + 10)

Используйте этот приоритет для изменения размера связанного материала. Он используется внутри GTK+ для расчета размеров виджетов. Этот приоритет больше чем GTK_PRIORITY_REDRAW, чтобы избежать изменения размера виджета который был только перерисован.

GTK_PRIORITY_HIGH

#define GTK_PRIORITY_HIGH       G_PRIORITY_HIGH

Внимание

GTK_PRIORITY_HIGH устарел и не должен использоваться во вновь создаваемом коде.

Используется для большего приоритета паузы. Этот приоритет ни когда не используется внутри GTK+, поэтому все выполняющееся с этим приоритетом будет выполняться прежде, чем что-нибудь внутри инструментария.

Предупреждение

Этот макрос устарел. Вы должны использовать вместо него G_PRIORITY_HIGH.

GTK_PRIORITY_INTERNAL

#define GTK_PRIORITY_INTERNAL   GTK_PRIORITY_REDRAW

Внимание

GTK_PRIORITY_INTERNAL устарел и не должен использоваться во вновь создаваемом коде.

Этот приоритет для внутреннего использования GTK+. Не используйте в ваших приложениях.

GTK_PRIORITY_DEFAULT

#define GTK_PRIORITY_DEFAULT    G_PRIORITY_DEFAULT_IDLE

Внимание

GTK_PRIORITY_DEFAULT устарел и не должен использоваться во вновь создаваемом коде.

Приоритет по умолчанию для пустой функции.

Предупреждение

Этот макрос устарел. Вы должны использовать вместо него G_PRIORITY_DEFAULT_IDLE.

GTK_PRIORITY_LOW

#define GTK_PRIORITY_LOW        G_PRIORITY_LOW

Внимание

GTK_PRIORITY_LOW устарел и не должен использоваться во вновь создаваемом коде.

Приоритет для очень не значительных задач.

Предупреждение

Этот макрос устарел. Вы должны использовать вместо него G_PRIORITY_LOW.

gtk_key_snooper_install ()

guint       gtk_key_snooper_install         (GtkKeySnoopFunc snooper,
                                             gpointer func_data);

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

`snooper` :	GtkKeySnoopFunc.
`func_data` :	Данные помещаемые в `snooper`.
Возвращает :	Уникальный id ключевого слежения, используется с `gtk_key_snooper_remove()`.

GtkKeySnoopFunc ()

gint        (*GtkKeySnoopFunc)              (GtkWidget *grab_widget,
                                             GdkEventKey *event,
                                             gpointer func_data);

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

`grab_widget` :	Виджет в который будет доставлено событие.
`event` :	Ключевое событие.
`func_data` :	`func_data` поставляется `gtk_key_snooper_install()`.
Возвращает :	`TRUE` останавливает обработку `event`, `FALSE` продолжает.

gtk_key_snooper_remove ()

void        gtk_key_snooper_remove          (guint snooper_handler_id);

удаляет ключевую функцию слежения используя полученный id.

snooper_handler_id :

Идентификатор ключевой функции для удаления.

gtk_get_current_event ()

GdkEvent*   gtk_get_current_event           (void);

Получает копию события обрабатываемого в текущий момент GTK+. Например, если вы получите "clicked" сигнал от GtkButton, то текущеме событие будет GdkEventButton, которым управляет "clicked" сигнал. Возвращаемое событие может быть освобождено функцией gdk_event_free(). Если нет текущемго события, функция возвращает NULL.

Возвращает :

Копию текущемго события, или NULL если нет текущемго события.

gtk_get_current_event_time ()

guint32     gtk_get_current_event_time      (void);

Если есть текущеме событие имеющее метку временем (timestamp), возвращает эту метку, иначе возвращает GDK_CURRENT_TIME.

Возвращает :

timestamp текущемго события, или GDK_CURRENT_TIME.

gtk_get_current_event_state ()

gboolean    gtk_get_current_event_state     (GdkModifierType *state);

Если есть текущеме событие имеющее поле статуса (state), помещает это поле статуса в state и возвращает TRUE, иначе возвращает FALSE.

`state` :	Размещает сохранённый статус текущемго события.
Возвращает :	`TRUE` если есть текущеме событие с полем статус

gtk_get_event_widget ()

GtkWidget*  gtk_get_event_widget            (GdkEvent *event);

Если event равен NULL или событие не связанно ни с одним виджетом, возвращает NULL, иначе возвращает виджет получивший событие изначально.

`event` :	GdkEvent
Возвращает :	Виджет изначально получивший `event`, или `NULL`

gtk_propagate_event ()

void        gtk_propagate_event             (GtkWidget *widget,
                                             GdkEvent *event);

Отправляет событие виджету, размножая событие в родительские виджеты если событие остаётся не обработанным. События полученные GTK+ из GDK обычно начинаются в gtk_main_do_event(). В зависимости от типа события, существования модальных диалогов, перехватов, и т.д., событие может быть размножено; если так, то эта функция используется. gtk_propagate_event() вызывает gtk_widget_event() в каждый виджет которому решено послать событие. Поэтому gtk_widget_event() функция самого низкого уровня (lowest-level); она просто издаёт "event" и возможно event-специфичный сигнал на виджете. gtk_propagate_event() немного более высокого уровня (higher-level) и gtk_main_do_event() самого высокого уровня.

Вы наиболее вероятно не захотите использовать упомянутые функции; синтезирование событий редко необходимо. Посмотрите списки рассылки для выяснения лучших способов, как добиться вашей цели. Например, используйте gdk_window_invalidate_rect() или gtk_widget_queue_draw() вместо экспонирования событий.

`widget` :	GtkWidget
`event` :	событие

Смотрите также

Смотрите руководство GLib, особенно GMainLoop и сигнал-связанные функции, такие как g_signal_connect().

Партнёры:

Хостинг:

Закладки на сайте
Проследить за страницей

Created 1996-2024 by Maxim Chirkov
Добавить, Поддержать, Вебмастеру