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

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

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

Ожидается, что все ссылки на элемент управления также будут освобождены; вы должны подключиться к сигналу “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”. Или просто подключение к сигналу “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().

С: 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” виджета.

Если у дочернего виджета 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_group и путь ускорителя accel_path. При нажатии сочетания клавиш, определённого для 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; если сигнал не переопределён обработчиком или в производном виджете, то по умолчанию требуется, чтобы виджет был активен, и он сам и все его предки были отображены.

С: 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_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 или NULL, если такового нет.

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

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()), но, например, средства разработки GUI могут обрабатывать их по-другому.

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 или какой-либо его части.

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

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

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

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

gtk_widget_class_install_style_property ()

void
gtk_widget_class_install_style_property
                               (GtkWidgetClass *klass,
                                GParamSpec *pspec);

Устанавливает свойство стиля для класса виджета. Парсер для свойства стиля определяется типом значения pspec .

gtk_widget_class_install_style_property_parser ()

void
gtk_widget_class_install_style_property_parser
                               (GtkWidgetClass *klass,
                                GParamSpec *pspec,
                                GtkRcPropertyParser parser);

Устанавливает свойство стиля для класса виджета.

[skip]

gtk_widget_class_find_style_property ()

GParamSpec *
gtk_widget_class_find_style_property (GtkWidgetClass *klass,
                                      const gchar *property_name);

Ищет свойство стиля класса виджета по имени.

С момента: 2.2

gtk_widget_class_list_style_properties ()

GParamSpec **
gtk_widget_class_list_style_properties
                               (GtkWidgetClass *klass,
                                guint *n_properties);

Возвращает все свойства стиля класса виджета.

С момента: 2.2

gtk_widget_region_intersect ()

cairo_region_t *
gtk_widget_region_intersect (GtkWidget *widget,
                             const cairo_region_t *region);

Вычисляет пересечение области виджета и region , возвращая пересечение. Результат может быть пустым, используйте cairo_region_is_empty() для проверки.

gtk_widget_send_expose ()

gint
gtk_widget_send_expose (GtkWidget *widget,
                        GdkEvent *event);

Функция, которая используется очень редко. Эта функция используется для вызова события expose для виджета. Эта функция обычно не используется напрямую. Единственный случай её использования — при распространении события expose на виджет без окна (gtk_widget_get_has_window() равно FALSE), и это обычно выполняется с помощью gtk_container_propagate_draw().

Если вы хотите заставить перерисовать область окна, используйте gdk_window_invalidate_rect() или gdk_window_invalidate_region(). Чтобы вызвать перерисовку немедленно, выполните вызов gdk_window_process_updates() после этого.

gtk_widget_send_focus_change ()

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

Отправляет изменение фокуса event в widget

Данная функция не предназначена для использования приложениями. Единственный случай её использования — когда GtkWidget необходимо назначить фокус элементу, который семантически принадлежит первому элементу, даже если он не является прямым потомком — например, поле поиска в всплывающем окне, подобно быстрому поиску в GtkTreeView.

Пример использования:

С: 2.20