GtkWidget

Управление геометрией по высоте для ширины

GTK+ использует систему управления геометрией по высоте для ширины (и ширине для высоты). Высота для ширины означает, что виджет может изменять необходимый вертикальный размер в зависимости от предоставленного горизонтального размера (и аналогично для ширины для высоты). Наиболее распространённым примером является метка, которая перестраивается, чтобы заполнить доступную ширину, переходит на меньшее количество строк и, следовательно, требует меньшей высоты.

Управление геометрией по высоте для ширины в GTK+ реализовано с помощью пяти виртуальных методов:

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

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

Например, при запросе в обычном режиме GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH: сначала вычисляется минимальная и естественная ширина каждого виджета в интерфейсе с помощью gtk_widget_get_preferred_width(). Поскольку предпочтительные ширины для каждого контейнера зависят от предпочтительных ширин их дочерних элементов, эта информация распространяется вверх по иерархии, и, в конечном итоге, определяется минимальная и естественная ширина для всего верхнего уровня. Далее, верхний уровень будет использовать минимальную ширину для запроса минимальной высоты, контекстуальной к этой ширине, с помощью gtk_widget_get_preferred_height_for_width(), что также будет высокорекурсивной операцией. Минимальная высота для минимальной ширины обычно используется для установки ограничения минимального размера на верхнем уровне (если явно не используется gtk_window_set_geometry_hints()).

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

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

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

Например, GtkLabel, который выполняет перенос слов по высоте для ширины, не ожидает вызова GtkWidgetClass.get_preferred_height(), поскольку этот вызов специфичен для запросов по ширине для высоты. В этом случае метка должна вернуть высоту, необходимую для своей минимально возможной ширины. Следуя этому правилу, любой виджет, обрабатывающий запросы по высоте для ширины или ширине для высоты, всегда будет выделять достаточно места для размещения собственного содержимого.

Вот несколько примеров того, как виджет GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH обычно обрабатывает запросы по ширине для высоты, для GtkWidgetClass.get_preferred_height() он будет:

А в GtkWidgetClass.get_preferred_width_for_height() он просто вернёт минимальную и естественную ширину:

Зачастую виджету необходимо получить свой собственный запрос во время запроса размера или распределения. Например, при вычислении высоты ему может потребоваться также вычислить ширину. Или при принятии решения о том, как использовать выделение, виджету может потребоваться узнать свой естественный размер. В этих случаях виджет должен быть внимателен при прямом вызове своих виртуальных методов, как это:

Использовать обертки функций, таких как gtk_widget_get_preferred_width() внутри собственной реализации запроса размера не сработает. Они возвращают запрос, скорректированный GtkSizeGroup и виртуальным методом GtkWidgetClass.adjust_size_request(). Если виджет использовал обертки внутри своих виртуальных методов, то корректировки (такие как отступы виджета) применялись бы дважды. GTK+ поэтому не допускает этого и выведет предупреждение, если вы попытаетесь это сделать.

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

Начиная с версии 3.10 GTK+ также поддерживает вертикальное выравнивание по отметке базовой линии виджетов. Это означает, что виджеты позиционируются так, что типографические отметки базовых линий виджетов в одной строке выровнены. Это происходит, если виджет поддерживает отметки базовых линий, имеет вертикальное выравнивание GTK_ALIGN_BASELINE и находится внутри контейнера, который поддерживает отметки базовых линий и имеет естественный «ряд», к которому он выравнивается по отметке базовой линии, или отметку базовой линии, присвоенную ему родительским контейнером.

Поддержка выравнивания по отметке базовой линии для виджета выполняется виртуальной функцией GtkWidgetClass.get_preferred_height_and_baseline_for_width(). Она позволяет сообщать отметку базовой линии вместе с минимальной и естественной высотой. Если отметки базовой линии нет, вы можете вернуть -1, чтобы указать это. По умолчанию эта виртуальная функция обращается к GtkWidgetClass.get_preferred_height() и GtkWidgetClass.get_preferred_height_for_width(), поэтому если отметки базовых линий не поддерживаются, её реализовывать не обязательно.

Если виджет выровнен по отметке базовой линии, ему будет выделено всё пространство в родителе, как будто он был GTK_ALIGN_FILL, но выбранную отметку базовой линии можно найти с помощью gtk_widget_get_allocated_baseline(). Если у неё есть значение, отличное от -1, вам необходимо выровнять виджет таким образом, чтобы отметка базовой линии появлялась в нужном месте.

Свойства стиля

GtkWidget вводит «свойства стиля» — это, по сути, свойства объекта, которые хранятся не в объекте, а в объекте стиля, связанном с виджетом. Свойства стиля устанавливаются в файлах ресурсов. Этот механизм используется для настройки таких вещей, как положение стрелок полосы прокрутки с помощью темы, давая авторам тем больше контроля над внешним видом приложений без необходимости написания движка темы на C.

Используйте gtk_widget_class_install_style_property() для установки свойств стиля для класса виджета, gtk_widget_class_find_style_property() или gtk_widget_class_list_style_properties() для получения информации о существующих свойствах стиля и gtk_widget_style_get_property(), gtk_widget_style_get() или gtk_widget_style_get_valist() для получения значения свойства стиля.

GtkWidget как GtkBuildable

Реализация GtkWidget интерфейса GtkBuildable поддерживает пользовательский элемент <accelerator>, у которого есть атрибуты с названиями «key», «modifiers» и «signal» и который позволяет указывать активаторы.

Пример фрагмента определения пользовательского интерфейса, задающего активатор:

В дополнение к активаторам, GtkWidget также поддерживает пользовательский элемент <accessible>, который поддерживает действия и отношения. Свойства реализации доступности объекта можно установить, обратившись к внутреннему дочернему элементу «accessible» GtkWidget.

Пример фрагмента определения пользовательского интерфейса, задающего доступность:

Наконец, GtkWidget позволяет связывать с виджетами информацию о стиле, такую как классы стиля, с помощью пользовательского элемента <style>:

Создание составных виджетов из шаблона XML

GtkWidget предоставляет средства для автоматизации процесса создания составных виджетов с использованием языка описания интерфейса GtkBuilder.

Для создания составных виджетов с помощью XML GtkBuilder необходимо связать описание интерфейса с классом виджета во время инициализации класса с помощью gtk_widget_class_set_template().

Семантика описания интерфейса, ожидаемая в описаниях составных шаблонов, немного отличается от обычного XML GtkBuilder.

В отличие от обычных описаний интерфейса, gtk_widget_class_set_template() будет ожидать тег <template> как непосредственного потомка тега <interface> верхнего уровня. Тег <template> должен содержать атрибут «class», значение которого должно быть именем типа виджета. Дополнительно можно указать атрибут «parent» для указания непосредственного родительского типа типа виджета. Этот атрибут игнорируется GtkBuilder, но необходим Glade для интроспекции свойств и внутренних потомков для данного типа, когда фактический тип не существует.

XML, содержащийся внутри тега <template>, ведет себя так, как будто он добавлен в тег <object>, определяющий widget. Вы можете задавать свойства widget, вставляя теги <property> в тег <template>, а также добавлять теги <child> для добавления потомков и расширения widget обычным образом, как и с тегами <object>.

Кроме того, теги <object> также могут быть добавлены перед и после начального тега <template> обычным способом, что позволяет определить вспомогательные объекты, которые могут быть ссылкой на другие виджеты, объявленные как потомки тега <template>.

Пример определения шаблона GtkBuilder:

Как правило, вы размещаете фрагмент шаблона в файле, который включен в ваш проект, используя GResource. Для загрузки шаблона необходимо вызвать gtk_widget_class_set_template_from_resource() из инициализации класса вашего типа GtkWidget:

Также вам необходимо вызвать gtk_widget_init_template() из функции инициализации экземпляра:

Вы можете получить доступ к виджетам, определенным в шаблоне, используя функцию gtk_widget_get_template_child(), но обычно вы объявляете указатель в структуре частных данных экземпляра вашего типа с тем же именем, что и виджет в определении шаблона, и вызываете gtk_widget_class_bind_template_child_private() с этим именем, например.

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

GtkCallback ()

void
(*GtkCallback) (GtkWidget *widget,
                gpointer data);

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

gtk_widget_new ()

GtkWidget *
gtk_widget_new (GType type,
                const gchar *first_property_name,
                ...);

Эта вспомогательная функция создает элемент управления и устанавливает его свойства за один раз. Например, вы можете написать: gtk_widget_new (GTK_TYPE_LABEL, "label", "Hello World", "xalign", 0.0, NULL) для создания выровненного по левому краю метки. Эквивалентно g_object_new(), но возвращает элемент управления, поэтому вам не нужно преобразовывать сам объект.

gtk_widget_destroy ()

void
gtk_widget_destroy (GtkWidget *widget);

Уничтожает элемент управления.

При уничтожении элемента управления он разорвет все ссылки, которые он держит на другие объекты. Если элемент управления находится внутри контейнера, элемент управления будет удален из контейнера. Если элемент управления является верхним (производным от GtkWindow), он будет удален из списка верхних элементов, и ссылка GTK+ на него будет удалена. Удаление элемента управления из его контейнера или списка верхних элементов приводит к окончанию элемента управления, если вы не добавили дополнительные ссылки на элемент управления с помощью g_object_ref().

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

gtk_widget_in_destruction ()

gboolean
gtk_widget_in_destruction (GtkWidget *widget);

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

gtk_widget_destroyed ()

void
gtk_widget_destroyed (GtkWidget *widget,
                      GtkWidget **widget_pointer);

Эта функция устанавливает *widget_pointer в NULL, если widget_pointer != NULL. Она предназначена для использования в качестве обратного вызова, подключенного к сигналу «destroy» элемента управления. Вы подключаете gtk_widget_destroyed() в качестве обработчика сигнала и передаете адрес вашей переменной элемента управления в качестве пользовательских данных. Затем, когда элемент управления уничтожается, переменная будет установлена в NULL. Полезно, например, для предотвращения нескольких копий одного и того же диалога.

gtk_widget_unparent ()

void
gtk_widget_unparent (GtkWidget *widget);

Эта функция предназначена только для использования в реализациях элементов управления. Должна вызываться реализациями метода remove в GtkContainer для отсоединения дочернего элемента от контейнера.

gtk_widget_show ()

void
gtk_widget_show (GtkWidget *widget);

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

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

При отображении верхнего контейнера он сразу же реализуется и отображается; другие отображенные элементы управления реализуются и отображаются, когда их верхний контейнер реализуется и отображается.

gtk_widget_show_now ()

void
gtk_widget_show_now (GtkWidget *widget);

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

gtk_widget_hide ()

void
gtk_widget_hide (GtkWidget *widget);

Отменяет действие gtk_widget_show(), делая элемент управления скрытым (невидимым для пользователя).

gtk_widget_show_all ()

void
gtk_widget_show_all (GtkWidget *widget);

Рекурсивно отображает элемент управления и все дочерние элементы управления (если элемент управления является контейнером).

gtk_widget_map ()

void
gtk_widget_map (GtkWidget *widget);

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

gtk_widget_unmap ()

void
gtk_widget_unmap (GtkWidget *widget);

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

gtk_widget_realize ()

void
gtk_widget_realize (GtkWidget *widget);

Создаёт ресурсы GDK (системы оконного менеджера) для виджета. Например, widget->window будет создан, когда виджет будет реализован. Обычно реализация происходит неявно; если вы отображаете виджет и все его контейнеры-родители, виджет будет реализован и отображён автоматически.

Для реализации виджета необходимо, чтобы все его родительские виджеты были реализованы; вызов gtk_widget_realize() реализует родителей виджета помимо самого widget. Если виджет ещё не находится внутри верхнего окна при его реализации, могут возникнуть проблемы.

Эта функция в основном используется в реализациях виджетов и не очень полезна в других случаях. Во многих ситуациях, когда вам кажется, что она может понадобиться, лучше подключиться к сигналу, который будет вызван после автоматической реализации виджета, например, к сигналу “draw”. Или просто g_signal_connect() к сигналу “realize”.

gtk_widget_unrealize ()

void
gtk_widget_unrealize (GtkWidget *widget);

Эта функция полезна только в реализациях виджетов. Приводит к тому, что виджет не реализован (освобождает все ресурсы GDK, связанные с виджетом, такие как widget->window).

gtk_widget_draw ()

void
gtk_widget_draw (GtkWidget *widget,
                 cairo_t *cr);

Отображает widget на cr. Левый верхний угол виджета будет отображён в текущей точке начала координат cr.

Вы должны передать контекст cairo в качестве аргумента cr, который находится в исходном состоянии. В противном случае результат отрисовки не определён. Например, изменение оператора с помощью cairo_set_operator() или ширины линии с помощью cairo_set_line_width() может иметь нежелательные побочные эффекты. Однако вы можете изменить матрицу преобразования контекста — например, с помощью cairo_scale(), cairo_translate() или cairo_set_matrix(), а также область обрезки с помощью cairo_clip() перед вызовом этой функции. Также разрешается изменять контекст с помощью cairo_save() и cairo_push_group() перед вызовом этой функции.

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

С версии: 3.0

gtk_widget_queue_draw ()

void
gtk_widget_queue_draw (GtkWidget *widget);

Эквивалентно вызову gtk_widget_queue_draw_area() для всей области виджета.

gtk_widget_queue_resize ()

void
gtk_widget_queue_resize (GtkWidget *widget);

Эта функция предназначена только для использования в реализациях виджетов. Помечает виджет для пересчёта размеров; должна вызываться, когда у виджета по какой-либо причине запрашивается новый размер. Например, при изменении текста в GtkLabel, GtkLabel вызывает пересчёт размера, чтобы обеспечить достаточное пространство для нового текста.

Обратите внимание, что вы не можете вызвать gtk_widget_queue_resize() для виджета изнутри реализации виртуального метода GtkWidgetClass::size_allocate. Вызовы gtk_widget_queue_resize() изнутри GtkWidgetClass::size_allocate будут проигнорированы.

gtk_widget_queue_resize_no_redraw ()

void
gtk_widget_queue_resize_no_redraw (GtkWidget *widget);

Эта функция работает аналогично gtk_widget_queue_resize(), но виджет не делает недействительным.

С версии: 2.4

gtk_widget_queue_allocate ()

void
gtk_widget_queue_allocate (GtkWidget *widget);

Эта функция предназначена только для использования в реализациях виджетов.

Помечает виджет для повторного выполнения функции GtkWidgetClass::size_allocate. Используйте эту функцию вместо gtk_widget_queue_resize(), когда запрос размера widget не изменился, но нужно переместить содержимое.

Пример использования этой функции — gtk_widget_set_halign().

gtk_widget_get_frame_clock ()

GdkFrameClock *
gtk_widget_get_frame_clock (GtkWidget *widget);

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

gdk_frame_clock_request_phase() приведёт к появлению нового кадра в таймере, но не обязательно перерисует какие-либо виджеты. Для перерисовки виджета используйте gtk_widget_queue_draw(), которое делает виджет недействительным (то есть планирует отрисовку в следующем кадре). gtk_widget_queue_draw() также приведёт к запросу кадра в соответствующем таймере кадра.

Таймер кадра виджета не меняется, пока виджет отображён. Перемещение виджета (что подразумевает временное скрытие) может изменить таймер кадра виджета.

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

С версии: 3.8

gtk_widget_get_scale_factor ()

gint
gtk_widget_get_scale_factor (GtkWidget *widget);

Получает внутренний масштаб, преобразующий координаты окна в фактические пиксели устройства. На традиционных системах это 1, на устройствах с высокой плотностью пикселей — большее значение (обычно 2).

См. gdk_window_get_scale_factor().

С версии: 3.10

GtkTickCallback ()

gboolean
(*GtkTickCallback) (GtkWidget *widget,
                    GdkFrameClock *frame_clock,
                    gpointer user_data);

Тип обратного вызова для добавления функции обновления анимации. См. gtk_widget_add_tick_callback().

С версии: 3.8

gtk_widget_add_tick_callback ()

guint
gtk_widget_add_tick_callback (GtkWidget *widget,
                              GtkTickCallback callback,
                              gpointer user_data,
                              GDestroyNotify notify);

Планирует обновление кадра анимации и добавляет обратный вызов, который будет вызываться перед каждым кадром. Пока обратный вызов не удалён, он будет вызываться часто (обычно со скоростью кадров устройства вывода или так быстро, как приложение может перерисоваться, что медленнее). По этой причине, он наиболее подходит для обработки графики, которая изменяется в каждом или в нескольких кадрах. Обратный вызов для таймера кадров не подразумевает автоматическое перераспределение или перерисовку. Если вам нужна перерисовка или перераспределение, и вы не меняете свойства виджета, которые бы это спровоцировали (например, изменение текста GtkLabel), то вам нужно вызвать gtk_widget_queue_resize() или gtk_widget_queue_draw_area() самостоятельно.

gdk_frame_clock_get_frame_time() обычно используется для тайминга непрерывной анимации, и gdk_frame_timings_get_predicted_presentation_time(), если вы пытаетесь отобразить отдельные кадры в определённые моменты времени.

Это более удобная альтернатива прямому подключению к сигналу “update” объекта GdkFrameClock, так как вам не нужно беспокоиться о том, когда GdkFrameClock назначен виджету.

С версии: 3.8

gtk_widget_remove_tick_callback ()

void
gtk_widget_remove_tick_callback (GtkWidget *widget,
                                 guint id);

Удаляет обратный вызов для таймера кадров, ранее зарегистрированный с помощью gtk_widget_add_tick_callback().

С версии: 3.8

gtk_widget_size_request ()

void
gtk_widget_size_request (GtkWidget *widget,
                         GtkRequisition *requisition);

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

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

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

gtk_widget_get_child_requisition ()

void
gtk_widget_get_child_requisition (GtkWidget *widget,
                                  GtkRequisition *requisition);

Эта функция предназначена только для реализации виджетов. Получает widget->requisition, если на виджет не навязана определённая геометрия (например, с помощью gtk_widget_set_size_request()), в противном случае возвращает заданную геометрию вместо запросов на выделение места виджета.

Эта функция отличается от gtk_widget_size_request() тем, что она извлекает последнее значение запрошенного размера из widget->requisition, в то время как gtk_widget_size_request() фактически вызывает метод «size_request» у widget для вычисления запрошенного размера и заполнения widget->requisition, и только после этого возвращает widget->requisition.

Так как эта функция не вызывает метод «size_request», она может использоваться только когда известно, что widget->requisition актуальна, то есть, gtk_widget_size_request() был вызван после последнего запроса на изменение размера. В общем случае, такой информацией обладают только реализации контейнеров; приложения должны использовать gtk_widget_size_request().

gtk_widget_size_allocate ()

void
gtk_widget_size_allocate (GtkWidget *widget,
                          GtkAllocation *allocation);

Эта функция используется только подклассами GtkContainer для назначения размера и положения дочерним виджетам.

В этой функции выделение может быть скорректировано. Оно будет принудительно ограничено минимальным размером 1x1, и будет использован виртуальный метод adjust_size_allocation дочернего виджета для корректировки выделения. Стандартные корректировки включают удаление отступов виджета и применение свойств «halign» и «valign» виджета.

Для базовой поддержки в контейнерах необходимо использовать gtk_widget_size_allocate_with_baseline() вместо этого.

gtk_widget_size_allocate_with_baseline ()

void
gtk_widget_size_allocate_with_baseline
                               (GtkWidget *widget,
                                GtkAllocation *allocation,
                                gint baseline);

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

В этой функции выделение и базовая линия могут быть скорректированы. Она будет принудительно ограничена минимальным размером 1x1, и будут использованы виртуальные методы adjust_size_allocation и adjust_baseline_allocation дочернего виджета для корректировки выделения и базовой линии. Стандартные корректировки включают удаление отступов виджета и применение свойств «halign» и «valign» виджета.

Если у дочернего виджета нет выравнивания по базовой линии (GTK_ALIGN_BASELINE), параметр baseline игнорируется, и используется значение -1.

С версии: 3.10

gtk_widget_add_accelerator ()

void
gtk_widget_add_accelerator (GtkWidget *widget,
                            const gchar *accel_signal,
                            GtkAccelGroup *accel_group,
                            guint accel_key,
                            GdkModifierType accel_mods,
                            GtkAccelFlags accel_flags);

Устанавливает ускоритель для данного widget в accel_group, который вызывает событие accel_signal при активации ускорителя. accel_group необходимо добавить к верхнему уровню виджета через gtk_window_add_accel_group(), и сигнал должен быть типа G_SIGNAL_ACTION. Ускорители, добавленные с помощью этой функции, нельзя изменить во время выполнения. Если требуется поддержка ускорителей, которые можно изменять пользователем, используйте gtk_accel_map_add_entry() и gtk_widget_set_accel_path() или gtk_menu_item_set_accel_path().

gtk_widget_remove_accelerator ()

gboolean
gtk_widget_remove_accelerator (GtkWidget *widget,
                               GtkAccelGroup *accel_group,
                               guint accel_key,
                               GdkModifierType accel_mods);

Удаляет ускоритель из widget, установленный ранее с помощью gtk_widget_add_accelerator().

gtk_widget_set_accel_path ()

void
gtk_widget_set_accel_path (GtkWidget *widget,
                           const gchar *accel_path,
                           GtkAccelGroup *accel_group);

Учитывая группу акселераторов, accel_group, и путь акселератора, accel_path, настраивает акселератор в accel_group, так что всякий раз, когда нажимается сочетание клавиш, определённое для accel_path, будет активирован widget. Это удаляет все акселераторы (для любой группы акселераторов), установленные предыдущими вызовами gtk_widget_set_accel_path(). Ассоциация акселераторов с путями позволяет пользователю их изменять, а изменения сохранять для последующего использования. (См. gtk_accel_map_save().)

Эта функция — низкоуровневая функция, скорее всего, используемая системой создания меню, например, GtkUIManager. Если используется GtkUIManager, настройка путей акселераторов выполняется автоматически.

Даже если вы не используете GtkUIManager, если вы хотите настроить акселераторы только для пунктов меню, gtk_menu_item_set_accel_path() предоставляет несколько более удобный интерфейс.

Обратите внимание, что строка accel_path будет храниться в GQuark. Следовательно, если вы передаёте статическую строку, вы можете сэкономить некоторое количество памяти, предварительно интернировав её с помощью g_intern_static_string().

gtk_widget_list_accel_closures ()

GList *
gtk_widget_list_accel_closures (GtkWidget *widget);

Выводит замыкания, используемые widget для соединений с группами акселераторов с помощью gtk_accel_group_connect_by_path() или gtk_accel_group_connect(). Замыкания могут быть использованы для отслеживания изменений акселераторов на widget, подключившись к сигналу GtkAccelGroup ::accel-changed группы акселераторов GtkAccelGroup, который можно получить с помощью gtk_accel_group_from_accel_closure().

gtk_widget_can_activate_accel ()

gboolean
gtk_widget_can_activate_accel (GtkWidget *widget,
                               guint signal_id);

Определяет, можно ли в данный момент активировать акселератор, активирующий сигнал, идентифицируемый signal_id. Это делается путём передачи сигнала “can-activate-accel” на widget; если сигнал не переопределён обработчиком или в производном виджете, то проверка по умолчанию заключается в том, что виджет должен быть активным, а виджет и все его предки должны быть отображены.

С: 2.4

gtk_widget_event ()

gboolean
gtk_widget_event (GtkWidget *widget,
                  GdkEvent *event);

Редко используемая функция. Эта функция используется для передачи сигналов событий на виджет (эти сигналы никогда не должны передаваться без использования этой функции). Если вы хотите синтезировать событие, не используйте эту функцию; вместо этого используйте gtk_main_do_event(), чтобы событие вело себя так, как если бы оно находилось в очереди событий. Не синтезируйте события expose; вместо этого используйте gdk_window_invalidate_rect() для обновления области окна.

gtk_widget_activate ()

gboolean
gtk_widget_activate (GtkWidget *widget);

Для виджетов, которые могут быть «активированы» (кнопки, пункты меню и т. д.), эта функция активирует их. Активация — это то, что происходит при нажатии клавиши Ввод на виджете во время навигации по клавиатуре. Если widget не может быть активирован, функция возвращает FALSE.

gtk_widget_reparent ()

void
gtk_widget_reparent (GtkWidget *widget,
                     GtkWidget *new_parent);

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

gtk_widget_intersect ()

gboolean
gtk_widget_intersect (GtkWidget *widget,
                      const GdkRectangle *area,
                      GdkRectangle *intersection);

Вычисляет пересечение области виджета widget и area, сохраняя пересечение в intersection, и возвращает TRUE, если пересечение произошло. intersection может быть NULL, если вас интересует только факт наличия пересечения.

gtk_widget_is_focus ()

gboolean
gtk_widget_is_focus (GtkWidget *widget);

Определяет, является ли виджет виджетом фокуса внутри своего верхнего уровня. (Это не означает, что свойство “has-focus” обязательно установлено; свойство “has-focus” будет установлено только в том случае, если виджет верхнего уровня дополнительно имеет глобальный фокус ввода.)

gtk_widget_grab_focus ()

void
gtk_widget_grab_focus (GtkWidget *widget);

Принудительно устанавливает фокус клавиатуры для widget внутри GtkWindow, в котором он находится. widget должен быть фокусируемым виджетом, например, GtkEntry; что-то вроде GtkFrame не сработает.

Точнее, у него должен быть установлен флаг GTK_CAN_FOCUS. Используйте gtk_widget_set_can_focus() для изменения этого флага.

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

gtk_widget_grab_default ()

void
gtk_widget_grab_default (GtkWidget *widget);

Принудительно устанавливает widget в качестве виджета по умолчанию. widget должен быть виджетом по умолчанию; обычно вы сами обеспечиваете это, вызывая gtk_widget_set_can_default() со значением TRUE. Виджет по умолчанию активируется, когда пользователь нажимает Enter в окне. Виджеты по умолчанию должны быть активируемыми, то есть gtk_widget_activate() должно их затрагивать. Обратите внимание, что для виджетов GtkEntry свойство «activates-default» должно быть установлено в TRUE, прежде чем они активируют виджет по умолчанию при нажатии Enter и фокусировке на GtkEntry.

gtk_widget_set_name ()

void
gtk_widget_set_name (GtkWidget *widget,
                     const gchar *name);

Виджеты могут иметь имена, что позволяет ссылаться на них из файла CSS. Вы можете применить стиль к виджетам с определённым именем в файле CSS. Смотрите документацию по синтаксису CSS (на той же странице, что и документация по GtkStyleContext).

Обратите внимание, что синтаксис CSS имеет определённые специальные символы для разграничения и представления элементов в селекторе (точка, #, >, *...), поэтому использование этих символов сделает ваш виджет несовместимым по имени. Любая комбинация буквенно-цифровых символов, дефисов и подчёркиваний подойдёт.

gtk_widget_get_name ()

const gchar *
gtk_widget_get_name (GtkWidget *widget);

Возвращает имя виджета. Смотрите gtk_widget_set_name() для значения имён виджетов.

gtk_widget_set_state ()

void
gtk_widget_set_state (GtkWidget *widget,
                      GtkStateType state);

Эта функция предназначена для использования в реализации виджетов. Устанавливает состояние виджета (нечувствительность, предварительное освещение и т.д.). Обычно вы должны устанавливать состояние с помощью оберток функций, таких как gtk_widget_set_sensitive().

gtk_widget_set_sensitive ()

void
gtk_widget_set_sensitive (GtkWidget *widget,
                          gboolean sensitive);

Устанавливает чувствительность виджета. Виджет чувствителен, если пользователь может взаимодействовать с ним. Нечувствительные виджеты «серые» и пользователь с ними взаимодействовать не может. Нечувствительные виджеты также известны как «неактивные», «отключенные» или «призрачные» в некоторых других наборах инструментов.

gtk_widget_set_parent ()

void
gtk_widget_set_parent (GtkWidget *widget,
                       GtkWidget *parent);

Эта функция полезна только при реализации подклассов GtkContainer. Устанавливает контейнер в качестве родительского для widget и обрабатывает некоторые детали, такие как обновление состояния и стиля дочернего элемента, чтобы отразить его новое местоположение. Противоположная функция — gtk_widget_unparent().

gtk_widget_set_parent_window ()

void
gtk_widget_set_parent_window (GtkWidget *widget,
                              GdkWindow *parent_window);

Устанавливает родительское окно по умолчанию для widget .

Для классов GtkWindow установка parent_window влияет на то, является ли окно главным окном или может быть вложено в другие виджеты.

Для классов GtkWindow это необходимо выполнить до реализации окна.

gtk_widget_get_parent_window ()

GdkWindow *
gtk_widget_get_parent_window (GtkWidget *widget);

Возвращает родительское окно widget .

gtk_widget_set_events ()

void
gtk_widget_set_events (GtkWidget *widget,
                       gint events);

Устанавливает маску событий (см. GdkEventMask) для виджета. Маска событий определяет, какие события будет получать виджет. Имейте в виду, что у разных виджетов разные значения маски событий по умолчанию, и изменение маски может нарушить функциональность виджета, поэтому будьте осторожны. Эту функцию необходимо вызвать, пока виджет не реализован. Рассмотрите gtk_widget_add_events() для уже реализованных виджетов или если вы хотите сохранить существующую маску событий. Эта функция не может быть использована с виджетами без окна. (См. gtk_widget_get_has_window()). Чтобы получить события для этих виджетов, поместите их внутрь GtkEventBox и получайте события на нём.

gtk_widget_get_events ()

gint
gtk_widget_get_events (GtkWidget *widget);

Возвращает маску событий (см. GdkEventMask) для виджета. Это события, которые получит виджет.

Примечание: Внутренне, маска событий виджета будет логическим ИЛИ маски событий, установленной с помощью gtk_widget_set_events() или gtk_widget_add_events(), и маски событий, необходимой для каждого GtkEventController, созданного для виджета.

gtk_widget_add_events ()

void
gtk_widget_add_events (GtkWidget *widget,
                       gint events);

Добавляет события из битового поля events к маске событий для widget . Подробности см. в gtk_widget_set_events() и в обзоре обработки событий.

gtk_widget_set_device_events ()

void
gtk_widget_set_device_events (GtkWidget *widget,
                              GdkDevice *device,
                              GdkEventMask events);

Устанавливает маску событий устройства (см. GdkEventMask) для виджета. Маска событий определяет, какие события виджет будет получать от device . Имейте в виду, что у разных виджетов разные значения маски событий по умолчанию, и изменение маски может нарушить функциональность виджета, поэтому будьте осторожны. Эту функцию необходимо вызвать, пока виджет не реализован. Рассмотрите gtk_widget_add_device_events() для уже реализованных виджетов или если вы хотите сохранить существующую маску событий. Эта функция не может быть использована с виджетами без окна (которые возвращают FALSE из gtk_widget_get_has_window()); для получения событий на этих виджетах поместите их внутрь GtkEventBox и получайте события на нём.

Since: 3.0

gtk_widget_get_device_events ()

GdkEventMask
gtk_widget_get_device_events (GtkWidget *widget,
                              GdkDevice *device);

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

Since: 3.0

gtk_widget_add_device_events ()

void
gtk_widget_add_device_events (GtkWidget *widget,
                              GdkDevice *device,
                              GdkEventMask events);

Добавляет события устройства из битового поля events к маске событий для widget . Подробности см. в gtk_widget_set_device_events().

Since: 3.0

gtk_widget_set_device_enabled ()

void
gtk_widget_set_device_enabled (GtkWidget *widget,
                               GdkDevice *device,
                               gboolean enabled);

Включает или отключает GdkDevice для взаимодействия с widget и всеми его дочерними элементами.

Это делается путём обхода иерархии GdkWindow и включения той же маски, что и для основных событий (т.е. той, что возвращает gdk_window_get_events()).

С: 3.0

gtk_widget_get_device_enabled ()

gboolean
gtk_widget_get_device_enabled (GtkWidget *widget,
                               GdkDevice *device);

Возвращает, может ли device взаимодействовать с widget и его дочерними элементами. См. gtk_widget_set_device_enabled().

С: 3.0

gtk_widget_get_toplevel ()

GtkWidget *
gtk_widget_get_toplevel (GtkWidget *widget);

Эта функция возвращает самый верхний виджет в иерархии контейнеров, частью которой является widget. Если у widget нет родительских виджетов, он возвращается как самый верхний виджет. Ссылка на возвращённый виджет не добавляется; его не нужно удалять.

Обратите внимание на различие в поведении по сравнению с gtk_widget_get_ancestor(); gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW) вернёт NULL, если widget не находился в окне верхнего уровня, и если окно находилось внутри виджета, производного от GtkWindow, который, в свою очередь, находился внутри верхнего окна GtkWindow. Хотя второй случай может показаться маловероятным, он действительно происходит, когда GtkPlug вставлен внутрь GtkSocket в одном и том же приложении.

Для надёжного поиска верхнего окна GtkWindow используйте gtk_widget_get_toplevel() и вызовите gtk_widget_is_toplevel() для результата.

gtk_widget_get_ancestor ()

GtkWidget *
gtk_widget_get_ancestor (GtkWidget *widget,
                         GType widget_type);

Получает первого предка widget типа widget_type. Например, gtk_widget_get_ancestor (widget, GTK_TYPE_BOX) получает первый GtkBox, являющийся предком widget. Ссылка на возвращённый виджет не добавляется; его не нужно удалять. См. примечание о проверке верхнего GtkWindow в документации для gtk_widget_get_toplevel().

Обратите внимание, что в отличие от gtk_widget_is_ancestor(), gtk_widget_get_ancestor() считает widget предком самого себя.

gtk_widget_get_visual ()

GdkVisual *
gtk_widget_get_visual (GtkWidget *widget);

Получает визуальное представление, которое будет использоваться для отрисовки widget.

gtk_widget_set_visual ()

void
gtk_widget_set_visual (GtkWidget *widget,
                       GdkVisual *visual);

Устанавливает визуальное представление, которое должно использоваться виджетом и его дочерними элементами для создания GdkWindows. Визуальное представление должно находиться на том же GdkScreen, что и возвращает gtk_widget_get_screen(), поэтому необходимо обработать сигнал “screen-changed”.

Установка нового visual не заставит widget пересоздать свои окна, поэтому вы должны вызвать эту функцию до того, как widget будет реализован.

gtk_widget_get_pointer ()

void
gtk_widget_get_pointer (GtkWidget *widget,
                        gint *x,
                        gint *y);

Получает положение указателя мыши в координатах виджета. Координаты виджета немного необычны; по историческим причинам они определяются как widget->window координаты для виджетов, которые возвращают TRUE для gtk_widget_get_has_window(); и относительны к widget->allocation.x , widget->allocation.y в противном случае.

gtk_widget_is_ancestor ()

gboolean
gtk_widget_is_ancestor (GtkWidget *widget,
                        GtkWidget *ancestor);

Определяет, находится ли widget где-то внутри ancestor, возможно, с промежуточными контейнерами.

gtk_widget_translate_coordinates ()

gboolean
gtk_widget_translate_coordinates (GtkWidget *src_widget,
                                  GtkWidget *dest_widget,
                                  gint src_x,
                                  gint src_y,
                                  gint *dest_x,
                                  gint *dest_y);

Преобразует координаты, относительные к размещению src_widget, в координаты, относительные к размещениям dest_widget. Для выполнения этой операции оба виджета должны быть реализованы и должны иметь общий верхний уровень.

gtk_widget_hide_on_delete ()

gboolean
gtk_widget_hide_on_delete (GtkWidget *widget);

Вспомогательная функция; предназначена для подключения к сигналу “delete-event” на GtkWindow. Функция вызывает gtk_widget_hide() для своего аргумента, затем возвращает TRUE. При подключении к ::delete-event, это означает, что нажатие кнопки закрытия окна (обычно в правом верхнем углу рамки окна) скроет, но не уничтожит окно. По умолчанию GTK+ уничтожает окна при получении ::delete-event.

gtk_widget_set_style ()

void
gtk_widget_set_style (GtkWidget *widget,
                      GtkStyle *style);

Используется для установки GtkStyle для виджета (widget->style ). Начиная с GTK 3, эта функция ничего не делает, переданный стиль игнорируется.

gtk_widget_ensure_style ()

void
gtk_widget_ensure_style (GtkWidget *widget);

Обеспечивает наличие стиля у widget (widget->style).

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

gtk_widget_get_style ()

GtkStyle *
gtk_widget_get_style (GtkWidget *widget);

Просто функция доступа, возвращающая widget->style.

gtk_widget_reset_rc_styles ()

void
gtk_widget_reset_rc_styles (GtkWidget *widget);

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

Эта функция не полезна для приложений.

gtk_widget_get_default_style ()

GtkStyle *
gtk_widget_get_default_style (void);

Возвращает стиль по умолчанию, используемый всеми виджетами изначально.

gtk_widget_set_direction ()

void
gtk_widget_set_direction (GtkWidget *widget,
                          GtkTextDirection dir);

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

Если направление установлено в GTK_TEXT_DIR_NONE, то будет использоваться значение, установленное функцией gtk_widget_set_default_direction().

gtk_widget_get_direction ()

GtkTextDirection
gtk_widget_get_direction (GtkWidget *widget);

Получает направление чтения для определённого виджета. См. gtk_widget_set_direction().

gtk_widget_set_default_direction ()

void
gtk_widget_set_default_direction (GtkTextDirection dir);

Устанавливает направление чтения по умолчанию для виджетов, для которых направление не было явно установлено с помощью gtk_widget_set_direction().

gtk_widget_get_default_direction ()

GtkTextDirection
gtk_widget_get_default_direction (void);

Получает текущее направление чтения по умолчанию. См. gtk_widget_set_default_direction().

gtk_widget_shape-combine-region ()

void
gtk_widget_shape_combine_region (GtkWidget *widget,
                                 cairo_region_t *region);

Устанавливает форму для окна GDK этого виджета. Это позволяет создавать прозрачные окна и т. п., см. gdk_window_shape_combine_region() для получения дополнительной информации.

С: 3.0

gtk_widget_input-shape-combine-region ()

void
gtk_widget_input_shape_combine_region (GtkWidget *widget,
                                       cairo_region_t *region);

Устанавливает форму ввода для окна GDK этого виджета. Это позволяет создавать окна, которые реагируют на щелчок мыши в непрямоугольной области, см. gdk_window_input_shape_combine_region() для получения дополнительной информации.

С: 3.0

gtk_widget_path ()

void
gtk_widget_path (GtkWidget *widget,
                 guint *path_length,
                 gchar **path,
                 gchar **path_reversed);

Получает полный путь к widget. Путь — это просто имя виджета и всех его родительских элементов в иерархии контейнеров, разделенных точками. Имя виджета берётся из gtk_widget_get_name(). Пути используются для применения стилей к виджету в файлах конфигурации gtkrc. Имена виджетов по умолчанию — это тип виджета (например, «GtkButton»), но их можно задать значением, специфичным для приложения, с помощью gtk_widget_set_name(). Задавая имя виджета, вы позволяете пользователям или авторам тем применять стили к этому конкретному виджету в своём файле gtkrc. path_reversed_p заполняет путь в обратном порядке, начиная с имени widget, а не с имени самого внешнего предка widget.

gtk_widget_class_path ()

void
gtk_widget_class_path (GtkWidget *widget,
                       guint *path_length,
                       gchar **path,
                       gchar **path_reversed);

Аналогично gtk_widget_path(), но всегда использует имя типа виджета, а не пользовательское имя, заданное с помощью gtk_widget_set_name().

gtk_widget_get_composite_name ()

gchar *
gtk_widget_get_composite_name (GtkWidget *widget);

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

gtk_widget_override_background_color ()

void
gtk_widget_override_background_color (GtkWidget *widget,
                                      GtkStateFlags state,
                                      const GdkRGBA *color);

Устанавливает цвет фона для использования виджетом.

Все остальные значения стиля остаются без изменений. См. gtk_widget_override_color().

С версии: 3.0

gtk_widget_override_color ()

void
gtk_widget_override_color (GtkWidget *widget,
                           GtkStateFlags state,
                           const GdkRGBA *color);

Устанавливает цвет, используемый для виджета.

Все другие значения стиля остаются неизменными.

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

Этот API в основном предназначен как быстрый способ для приложений изменить внешний вид виджета. Если вы разрабатываете библиотеку виджетов и намерены, чтобы это изменение было тематически оформлено, лучше это сделать, задав осмысленные CSS-классы в вашей реализации виджета/контейнера через gtk_style_context_add_class().

Таким образом, ваша библиотека виджетов может установить GtkCssProvider с приоритетом GTK_STYLE_PROVIDER_PRIORITY_FALLBACK, чтобы обеспечить стандартное стилирование для тех виджетов, которые в этом нуждаются, и эта тема может быть полностью перекрыта темой пользователя.

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

С: 3.0

gtk_widget_override_font ()

void
gtk_widget_override_font (GtkWidget *widget,
                          const PangoFontDescription *font_desc);

Устанавливает шрифт, используемый для виджета. Все другие значения стиля остаются неизменными. См. gtk_widget_override_color().

С: 3.0

gtk_widget_override_symbolic_color ()

void
gtk_widget_override_symbolic_color (GtkWidget *widget,
                                    const gchar *name,
                                    const GdkRGBA *color);

Устанавливает символьный цвет для виджета.

Все остальные значения стиля остаются неизменными. См. gtk_widget_override_color(), чтобы переопределить цвет переднего или заднего плана.

С: 3.0

gtk_widget_override_cursor ()

void
gtk_widget_override_cursor (GtkWidget *widget,
                            const GdkRGBA *cursor,
                            const GdkRGBA *secondary_cursor);

Устанавливает цвет курсора, используемый в виджете, переопределяя свойства стиля cursor-color и secondary-cursor-color. Все остальные значения стиля остаются неизменными. См. также gtk_widget_modify_style().

Обратите внимание, что основополагающие свойства имеют тип GdkColor, поэтому значение альфа-канала в primary и secondary будет проигнорировано.

С: 3.0

gtk_widget_modify_style ()

void
gtk_widget_modify_style (GtkWidget *widget,
                         GtkRcStyle *style);

Изменяет значения стиля виджета.

Изменения, внесённые с помощью этого метода, имеют приоритет над значениями стиля, заданными в файле RC, но они будут перезаписаны, если стиль явно задан для виджета с помощью gtk_widget_set_style(). GtkRcStyle разработан так, чтобы каждый элемент мог быть установлен или сброшен, поэтому с помощью этой функции можно изменить некоторые значения стиля, оставив другие без изменений.

Обратите внимание, что изменения, внесённые с помощью этой функции, не суммируются с предыдущими вызовами gtk_widget_modify_style() или такими функциями, как gtk_widget_modify_fg(). Если вы хотите сохранить предыдущие значения, сначала вызовите gtk_widget_get_modifier_style(), внесите изменения в возвращаемый стиль, а затем вызовите gtk_widget_modify_style() с этим стилем. С другой стороны, если вы сначала вызовете gtk_widget_modify_style(), последующие вызовы таких функций gtk_widget_modify_fg() будут суммировать эффект с начальными изменениями.

gtk_widget_get_modifier_style ()

GtkRcStyle *
gtk_widget_get_modifier_style (GtkWidget *widget);

Возвращает текущий стиль модификатора для виджета. (Как задано gtk_widget_modify_style().) Если стиль ранее не был задан, будет создан новый GtkRcStyle со всеми значениями, сброшенными как стиль модификатора для виджета. Если вы вносите изменения в этот rc-стиль, вы должны вызвать gtk_widget_modify_style(), передав возвращённый rc-стиль, чтобы убедиться, что ваши изменения вступят в силу.

Внимание: передача стиля обратно в gtk_widget_modify_style() обычно приводит к его уничтожению, потому что gtk_widget_modify_style() копирует переданный стиль и устанавливает копию в качестве нового стиля модификатора, тем самым удаляя любую ссылку на старый стиль модификатора. Добавьте ссылку на стиль модификатора, если хотите сохранить его.

gtk_widget_modify_fg ()

void
gtk_widget_modify_fg (GtkWidget *widget,
                      GtkStateType state,
                      const GdkColor *color);

Устанавливает цвет переднего плана для виджета в определённом состоянии.

Все остальные значения стиля остаются неизменными. См. также gtk_widget_modify_style().

gtk_widget_modify_bg ()

void
gtk_widget_modify_bg (GtkWidget *widget,
                      GtkStateType state,
                      const GdkColor *color);

Устанавливает цвет фона для виджета в определённом состоянии.

Все остальные значения стиля остаются неизменными. См. также gtk_widget_modify_style().

gtk_widget_modify_text ()

void
gtk_widget_modify_text (GtkWidget *widget,
                        GtkStateType state,
                        const GdkColor *color);

Устанавливает цвет текста для виджета в определённом состоянии.

Все остальные значения стиля остаются без изменений. Цвет текста — это цвет переднего плана, используемый вместе с базовым цветом (см. gtk_widget_modify_base()) для виджетов, таких как GtkEntry и GtkTextView. См. также gtk_widget_modify_style().

gtk_widget_modify_base ()

void
gtk_widget_modify_base (GtkWidget *widget,
                        GtkStateType state,
                        const GdkColor *color);

Устанавливает базовый цвет виджета в определённом состоянии. Все остальные значения стиля остаются без изменений. Базовый цвет — это цвет фона, используемый вместе с цветом текста (см. gtk_widget_modify_text()) для виджетов, таких как GtkEntry и GtkTextView. См. также gtk_widget_modify_style().

gtk_widget_modify_font ()

void
gtk_widget_modify_font (GtkWidget *widget,
                        PangoFontDescription *font_desc);

Устанавливает шрифт для использования виджетом.

Все остальные значения стиля остаются без изменений. См. также gtk_widget_modify_style().

gtk_widget_modify_cursor ()

void
gtk_widget_modify_cursor (GtkWidget *widget,
                          const GdkColor *primary,
                          const GdkColor *secondary);

Устанавливает цвет курсора для использования в виджете, перезаписывая свойства стиля GtkWidget cursor-color и secondary-cursor-color.

Все остальные значения стиля остаются без изменений. См. также gtk_widget_modify_style().

С: 2.12

gtk_widget_create_pango_context ()

PangoContext *
gtk_widget_create_pango_context (GtkWidget *widget);

Создаёт новый PangoContext с соответствующей картой шрифтов, опциями шрифтов, описанием шрифта и основным направлением для рисования текста для данного виджета. См. также gtk_widget_get_pango_context().

gtk_widget_get_pango_context ()

PangoContext *
gtk_widget_get_pango_context (GtkWidget *widget);

Получает PangoContext с соответствующей картой шрифтов, описанием шрифта и основным направлением для данного виджета. В отличие от контекста, возвращаемого функцией gtk_widget_create_pango_context(), этот контекст принадлежит виджету (его можно использовать до тех пор, пока не изменится экран для виджета или виджет не будет удален из его верхнего уровня), и он будет обновлен в соответствии с любыми изменениями атрибутов виджета. Это можно отслеживать, используя сигнал “screen-changed” для виджета.

gtk_widget_set_font_options ()

void
gtk_widget_set_font_options (GtkWidget *widget,
                             const cairo_font_options_t *options);

Устанавливает cairo_font_options_t, используемые для рендеринга Pango в этом виджете. Если не установлено, будут использоваться параметры шрифта по умолчанию для GdkScreen.

С: 3.18

gtk_widget_get_font_options ()

const cairo_font_options_t *
gtk_widget_get_font_options (GtkWidget *widget);

Возвращает cairo_font_options_t, используемые для рендеринга Pango. Если не установлено, будут использованы параметры шрифта по умолчанию для GdkScreen.

С: 3.18

gtk_widget_set_font_map ()

void
gtk_widget_set_font_map (GtkWidget *widget,
                         PangoFontMap *font_map);

Устанавливает карту шрифтов для использования при рендеринге Pango. Если не установлено, виджет унаследует карту шрифтов от своего родителя.

С: 3.18

gtk_widget_get_font_map ()

PangoFontMap *
gtk_widget_get_font_map (GtkWidget *widget);

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

С: 3.18

gtk_widget_create_pango_layout ()

PangoLayout *
gtk_widget_create_pango_layout (GtkWidget *widget,
                                const gchar *text);

Создает новый PangoLayout с соответствующей картой шрифтов, описанием шрифта и основным направлением для отображения текста для этого виджета.

Если вы сохраняете PangoLayout, созданный таким образом, вам нужно его пересоздать, когда PangoContext виджета заменяется. Это можно отследить, используя сигнал “screen-changed” виджета.

gtk_widget_render_icon ()

GdkPixbuf *
gtk_widget_render_icon (GtkWidget *widget,
                        const gchar *stock_id,
                        GtkIconSize size,
                        const gchar *detail);

Вспомогательная функция, которая использует настройки темы для widget для поиска stock_id и отрисовки его в pixbuf. stock_id должен быть идентификатором значка по умолчанию, таким как GTK_STOCK_OPEN или GTK_STOCK_OK. size должен быть размером, таким как GTK_ICON_SIZE_MENU. detail должна быть строкой, которая идентифицирует виджет или код, выполняющий отрисовку, чтобы движки темы могли обрабатывать отрисовку для этого виджета или кода.

Пиксели в возвращаемом GdkPixbuf совместно используются с остальной частью приложения и не должны изменяться. Pixbuf следует освободить после использования с помощью g_object_unref().

gtk_widget_render_icon_pixbuf ()

GdkPixbuf *
gtk_widget_render_icon_pixbuf (GtkWidget *widget,
                               const gchar *stock_id,
                               GtkIconSize size);

Удобная функция, которая использует движок темы и настройки стиля для widget, чтобы найти stock_id и отобразить его в pixbuf. stock_id должен быть идентификатором значка по умолчанию, таким как GTK_STOCK_OPEN или GTK_STOCK_OK. size должен быть размером, таким как GTK_ICON_SIZE_MENU.

Пиксели в возвращаемом GdkPixbuf совместно используются с остальной частью приложения и не должны изменяться. Pixbuf следует освободить после использования с помощью g_object_unref().

С: 3.0

gtk_widget_pop_composite_child ()

void
gtk_widget_pop_composite_child (void);

Отменяет действие предыдущего вызова gtk_widget_push_composite_child().

gtk_widget_push_composite_child ()

void
gtk_widget_push_composite_child (void);

Делает все вновь созданные виджеты составными дочерними элементами до соответствующего вызова gtk_widget_pop_composite_child().

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

gtk_widget_queue_draw_area ()

void
gtk_widget_queue_draw_area (GtkWidget *widget,
                            gint x,
                            gint y,
                            gint width,
                            gint height);

Вспомогательная функция, которая вызывает gtk_widget_queue_draw_region() на области, созданной из заданных координат.

Здесь область задается в координатах виджета. Координаты виджета немного необычны; по историческим причинам они определяются как widget->window координаты для виджетов, которые возвращают TRUE для gtk_widget_get_has_window(), и относятся к widget->allocation.x , widget->allocation.y в противном случае.

width или height могут быть 0, в этом случае эта функция ничего не делает. Отрицательные значения для width и height запрещены.

gtk_widget_queue_draw_region ()

void
gtk_widget_queue_draw_region (GtkWidget *widget,
                              const cairo_region_t *region);

Отмечает область widget, определённую параметром region, для перерисовки, вызвав gdk_window_invalidate_region() в окне виджета и всех его дочерних окон. После того, как основной цикл станет бездействующим (после обработки текущей партии событий), окно получит события expose для объединения всех отмеченных областей.

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

С версии: 3.0

gtk_widget_set_app_paintable ()

void
gtk_widget_set_app_paintable (GtkWidget *widget,
                              gboolean app_paintable);

Устанавливает, будет ли приложение рисовать на виджете в обработчике события “draw”.

Это подсказка для виджета и не влияет на поведение ядра GTK+; многие виджеты полностью игнорируют этот флаг. Для виджетов, которые обращают внимание на этот флаг, таких как GtkEventBox и GtkWindow, эффект заключается в подавлении стандартного рисования фоном виджета темой. (Дети виджета всё ещё будут отрисовываться). Затем приложение полностью отвечает за отрисовку фона виджета.

Обратите внимание, что фон всё ещё отрисовывается, когда виджет отображается.

gtk_widget_set_double_buffered ()

void
gtk_widget_set_double_buffered (GtkWidget *widget,
                                gboolean double_buffered);

Виджеты по умолчанию с двойной буферизацией; вы можете использовать эту функцию, чтобы отключить буферизацию. «Двойная буферизация» просто означает, что gdk_window_begin_paint_region() и gdk_window_end_paint() вызываются автоматически вокруг событий expose, отправленных в виджет. gdk_window_begin_paint_region() перенаправляет всё рисование в окно виджета на буфер без отображения, и gdk_window_end_paint() отображает буфер на экран. Результат заключается в том, что пользователи видят обновление окна за один плавный шаг, и не видят отдельных графических примитивов, которые рендерятся.

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

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

В GTK и GDK 3.10 была перестроена для полупрозрачного рисования. С тех пор события expose для виджетов с двойной буферизацией сводятся к одному событию для верхнего GDK окна. Если вы теперь отключаете двойную буферизацию, вы вызовете отдельный этап рендеринга для каждого виджета. Это, вероятно, вызовет проблемы с рендерингом (в частности, связанные со стекированием) и, как правило, значительно увеличивает время рендеринга.

gtk_widget_set_redraw_on_allocate ()

void
gtk_widget_set_redraw_on_allocate (GtkWidget *widget,
                                   gboolean redraw_on_allocate);

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

Обратите внимание, что для виджетов, где gtk_widget_get_has_window() равно FALSE, установка этого флага в FALSE отключает все выделения при изменении размера: виджет даже не перерисуется, если его положение изменится; это позволяет контейнерам, которые ничего не рисуют, избегать избыточных отметок для перерисовки. Если вы установите этот флаг на виджет без окна, который рисует на widget->window, вы несёте ответственность за выделение как старого, так и нового выделения виджета при перемещении виджета и за выделение новых областей, когда размер виджета увеличивается.

gtk_widget_set_composite_name ()

void
gtk_widget_set_composite_name (GtkWidget *widget,
                               const gchar *name);

Устанавливает составное имя виджета. Виджет должен быть составным потомком своего родителя; см. gtk_widget_push_composite_child().

gtk_widget_mnemonic_activate ()

gboolean
gtk_widget_mnemonic_activate (GtkWidget *widget,
                              gboolean group_cycling);

Вызывает событие “mnemonic-activate”.

Обработчик по умолчанию для этого события активирует widget, если group_cycling равно FALSE, и просто получает фокус, если group_cycling равно TRUE.