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 объекта можно установить, обратившись к внутреннему дочернему элементу «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);

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

При уничтожении элемента управления все ссылки, которые он содержит на другие объекты, будут освобождены:

Ожидается, что все ссылки, удерживаемые на элементе управления, также будут освобождены; вы должны подключиться к сигналу “destroy”, если удерживаете ссылку на widget и хотите удалить её, когда эта функция вызывается. Это не обязательно, если вы реализуете GtkContainer, так как вы сможете использовать виртуальную функцию GtkContainerClass.remove() для этого.

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

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

См. также: gtk_container_remove()

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(), когда запрос на размер виджета не изменился, но он хочет переместить содержимое.

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

С: 3.20

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 группы акселераторов (который можно найти с помощью 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; если сигнал не переопределяется обработчиком или в производном виджете, то проверка по умолчанию заключается в том, что виджет должен быть активным, и сам виджет, и все его предки должны быть отображены.

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

Для виджетов, которые могут быть «активированы» (кнопки, пункты меню и т. д.), эта функция активирует их. Активация происходит при нажатии клавиши Enter на виджете во время навигации по клавишам. Если 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_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()).

Since: 3.0

gtk_widget_get_device_enabled ()

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

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

Since: 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-derived, который, в свою очередь, находится внутри окна верхнего уровня 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);

Устанавливает визуальный режим, который должен использоваться виджетом и его дочерними элементами для создания окна Gdk. Визуальный режим должен находиться на том же экран Gdk, что и возвращает 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” для окна Gtk. Функция вызывает 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.

Since: 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.

Since: 3.18

gtk_widget_set_font_map ()

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

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

Since: 3.18

gtk_widget_get_font_map ()

PangoFontMap *
gtk_widget_get_font_map (GtkWidget *widget);

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

Since: 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 в противном случае.

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() на окне виджета и всех его дочерних окон. После того, как главная петля станет свободной (после обработки текущей порции событий), окно получит события отображения для объединения всех областей, которые были отмечены для перерисовки.

Обычно эту функцию используют только при реализации виджетов. Её также можно использовать для планирования перерисовки 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_draw_frame() и gdk_window_end_draw_frame() вызываются автоматически вокруг событий отображения, отправленных виджету. gdk_window_begin_draw_frame() перенаправляет всё рисование в окно виджета на отложенный буфер, а gdk_window_end_draw_frame() рисует буфер на экран. В результате пользователь видит обновление окна за один плавный шаг, а не отдельных графических примитивов.

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

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

В GTK и GDK 3.10 была перестроена прозрачная отрисовка. С тех пор события отображения для буферизованных виджетов собираются в одно событие для верхнего 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.