GtkWidget

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

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

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

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

Если вы реализуете прямой подкласс GtkWidget, который поддерживает управление геометрией по высоте для ширины или ширине для высоты для себя или своих дочерних виджетов, виртуальная функция GtkWidgetClass.get_request_mode() также должна быть реализована и возвращать предпочтительный режим запроса виджета. Стандартная реализация этой виртуальной функции возвращает GTK_SIZE_REQUEST_CONSTANT_SIZE, что означает, что виджету будет передаваться только значение -1 в качестве значения for_size для его реализации GtkWidgetClass.measure().

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

Например, при запросе в нормальном режиме GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH: Во-первых, будут вычислены минимальная и естественная ширина каждого виджета в интерфейсе с использованием gtk_widget_measure() с направлением GTK_ORIENTATION_HORIZONTAL и значением for_size -1. Поскольку предпочтительные ширины каждого виджета зависят от предпочтительных ширин их дочерних элементов, эта информация распространяется по иерархии, и в конечном итоге определяется минимальная и естественная ширина для всего верхнего уровня. Затем верхний уровень использует минимальную ширину для запроса минимальной высоты, контекстуальной к этой ширине, с использованием gtk_widget_measure() с направлением GTK_ORIENTATION_VERTICAL и значением for_size, только что вычисленной ширины. Это также будет сильно рекурсивной операцией. Минимальная высота для минимальной ширины обычно используется для установки ограничения минимального размера на верхнем уровне.

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

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

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

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

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

Использование функции-обёртки gtk_widget_measure() внутри собственной реализации GtkWidgetClass.size-allocate() не сработает. Эти функции возвращают скорректированный запрос, учитывая GtkSizeGroup, флаги выравнивания и расширения виджета, а также его CSS-стиль. Если виджет использовал бы обёртки внутри реализаций своих виртуальных методов, то корректировки (например, отступы виджета) применялись бы дважды. Поэтому GTK этого не позволяет и выведет предупреждение, если вы попробуете сделать это.

Конечно, если вы получаете запрос размера для другого виджета, например, дочернего виджета, вы должны использовать gtk_widget_measure(). В противном случае вы не должным образом рассмотрите отступы виджета, GtkSizeGroup и т. д.

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

Поддержка выравнивания по базовой линии для виджета также выполняется виртуальной функцией GtkWidgetClass.measure(). Она позволяет сообщать как минимальный, так и естественный размер.

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

GtkWidget как GtkBuildable

Реализация GtkWidget интерфейса GtkBuildable поддерживает пользовательские элементы для указания различных аспектов виджетов, которые не выражены непосредственно как свойства.

Если родительский виджет использует GtkLayoutManager, GtkWidget поддерживает пользовательский элемент <layout>, используемый для определения свойств макета:

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

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

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

static void
foo_widget_measure (GtkWidget      *widget,
                    GtkOrientation  orientation,
                    int             for_size,
                    int            *minimum_size,
                    int            *natural_size,
                    int            *minimum_baseline,
                    int            *natural_baseline)
{
  if (orientation == GTK_ORIENTATION_HORIZONTAL)
    {
      // Calculate minimum and natural width
    }
  else // VERTICAL
    {
       if (i_am_in_height_for_width_mode)
         {
           int min_width, dummy;

           // First, get the minimum width of our widget
           GTK_WIDGET_GET_CLASS (widget)->measure (widget, GTK_ORIENTATION_HORIZONTAL, -1,
                                                   &min_width, &dummy, &dummy, &dummy);

           // Now use the minimum width to retrieve the minimum and natural height to display
           // that width.
           GTK_WIDGET_GET_CLASS (widget)->measure (widget, GTK_ORIENTATION_VERTICAL, min_width,
                                                   minimum_size, natural_size, &dummy, &dummy);
         }
       else
         {
           // ... some widgets do both.
         }
   }
}

gtk_widget_in_destruction ()

gboolean
gtk_widget_in_destruction (GtkWidget *widget);

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

gtk_widget_unparent ()

void
gtk_widget_unparent (GtkWidget *widget);

Эта функция предназначена только для использования в реализациях виджетов. Она должна вызываться родительскими виджетами для разъединения widget от родителя, обычно в методе удаления.

gtk_widget_show ()

void
gtk_widget_show (GtkWidget *widget);

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

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

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

gtk_widget_hide ()

void
gtk_widget_hide (GtkWidget *widget);

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

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

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

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

gtk_widget_unrealize ()

void
gtk_widget_unrealize (GtkWidget *widget);

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

gtk_widget_queue_draw ()

void
gtk_widget_queue_draw (GtkWidget *widget);

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

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_allocate ()

void
gtk_widget_queue_allocate (GtkWidget *widget);

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

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

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

gtk_widget_get_frame_clock ()

GdkFrameClock *
gtk_widget_get_frame_clock (GtkWidget *widget);

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

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

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

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

gtk_widget_get_scale_factor ()

int
gtk_widget_get_scale_factor (GtkWidget *widget);

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

См. gdk_surface_get_scale_factor().

GtkTickCallback ()

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

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

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().

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

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

gtk_widget_remove_tick_callback ()

void
gtk_widget_remove_tick_callback (GtkWidget *widget,
                                 guint id);

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

gtk_widget_size_allocate ()

void
gtk_widget_size_allocate (GtkWidget *widget,
                          const GtkAllocation *allocation,
                          int baseline);

Это простой вид gtk_widget_allocate(), который принимает новое положение widget в качестве части allocation .

gtk_widget_allocate ()

void
gtk_widget_allocate (GtkWidget *widget,
                     int width,
                     int height,
                     int baseline,
                     GskTransform *transform);

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

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

Для версии без преобразования, см. gtk_widget_size_allocate()

gtk_widget_class_add_shortcut ()

void
gtk_widget_class_add_shortcut (GtkWidgetClass *widget_class,
                               GtkShortcut *shortcut);

Устанавливает ярлык в widget_class . Каждый экземпляр, созданный для widget_class или его подклассов, унаследует этот ярлык и вызовет его.

Ярлыки, добавленные таким образом, будут активироваться на стадии GTK_PHASE_BUBBLE, что означает, что они могут быть активированы, если фокус находится на дочерних виджетах.

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

gtk_widget_class_add_binding ()

void
gtk_widget_class_add_binding (GtkWidgetClass *widget_class,
                              guint keyval,
                              GdkModifierType mods,
                              GtkShortcutFunc callback,
                              const char *format_string,
                              ...);

Создаёт новую комбинацию клавиш для widget_class, которая вызывает указанную callback с аргументами, считываемыми в соответствии с format_string . Аргументы и строка формата должны быть предоставлены так же, как и в g_variant_new().

Эта функция является удобной обёрткой вокруг gtk_widget_class_add_shortcut() и должна вызываться во время инициализации класса. Она не предоставляет возможности для пользовательских данных; если вам это необходимо, используйте gtk_widget_class_add_shortcut() с настраиваемой комбинацией клавиш.

[skip]

gtk_widget_class_add_binding_signal ()

void
gtk_widget_class_add_binding_signal (GtkWidgetClass *widget_class,
                                     guint keyval,
                                     GdkModifierType mods,
                                     const char *signal,
                                     const char *format_string,
                                     ...);

Создаёт новую комбинацию клавиш для widget_class, которая излучает указанное действие signal с аргументами, считываемыми в соответствии с format_string . Аргументы и строка формата должны быть предоставлены так же, как и в g_variant_new().

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

[skip]

gtk_widget_class_add_binding_action ()

void
gtk_widget_class_add_binding_action (GtkWidgetClass *widget_class,
                                     guint keyval,
                                     GdkModifierType mods,
                                     const char *action_name,
                                     const char *format_string,
                                     ...);

Создаёт новую комбинацию клавиш для widget_class, которая активирует указанное action_name с аргументами, считываемыми в соответствии с format_string . Аргументы и строка формата должны быть предоставлены так же, как и в g_variant_new().

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

[skip]

gtk_widget_class_set_layout_manager_type ()

void
gtk_widget_class_set_layout_manager_type
                               (GtkWidgetClass *widget_class,
                                GType type);

Устанавливает тип, используемый для создания менеджеров компоновки для виджетов класса widget_class . Указанный type должен быть подклассом GtkLayoutManager.

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

gtk_widget_class_get_layout_manager_type ()

GType
gtk_widget_class_get_layout_manager_type
                               (GtkWidgetClass *widget_class);

Возвращает тип GtkLayoutManager, используемый классом виджета GtkWidget.

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

gtk_widget_class_set_activate_signal ()

void
gtk_widget_class_set_activate_signal (GtkWidgetClass *widget_class,
                                      guint signal_id);

Устанавливает поле GtkWidgetClass.activate_signal с заданным signal_id; сигнал будет излучен при вызове gtk_widget_activate().

signal_id должен быть зарегистрирован с помощью g_signal_new() или g_signal_newv() перед вызовом этой функции.

gtk_widget_class_set_activate_signal_from_name ()

void
gtk_widget_class_set_activate_signal_from_name
                               (GtkWidgetClass *widget_class,
                                const char *signal_name);

Устанавливает поле GtkWidgetClass.activate_signal с идентификатором сигнала для данного signal_name; сигнал будет выпущен при вызове gtk_widget_activate().

Указанное signal_name для widget_type должно быть зарегистрировано с помощью g_signal_new() или g_signal_newv() перед вызовом этой функции.

gtk_widget_class_get_activate_signal ()

guint
gtk_widget_class_get_activate_signal (GtkWidgetClass *widget_class);

Возвращает идентификатор сигнала активации, установленного с помощью gtk_widget_class_set_activate_signal().

gtk_widget_activate ()

gboolean
gtk_widget_activate (GtkWidget *widget);

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

Активация происходит при нажатии клавиши Enter на виджете во время навигации по клавиатуре.

Если вы хотите самостоятельно обрабатывать привязку клавиш активации, рекомендуется использовать gtk_widget_class_add_shortcut() с действием, созданным с помощью gtk_signal_action_new().

Если widget не может быть активирован, функция возвращает FALSE.

gtk_widget_is_focus ()

gboolean
gtk_widget_is_focus (GtkWidget *widget);

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

gtk_widget_grab_focus ()

gboolean
gtk_widget_grab_focus (GtkWidget *widget);

Приводит к тому, что widget (или один из его потомков) получает фокус клавиатуры для GtkWindow, в котором он находится.

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

Вызов gtk_widget_grab_focus() на уже фокусированном виджете разрешен, не должен оказывать никакого влияния и возвращать TRUE.

gtk_widget_set_name ()

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

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

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

gtk_widget_get_name ()

const char *
gtk_widget_get_name (GtkWidget *widget);

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

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

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

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

gtk_widget_get_root ()

GtkRoot *
gtk_widget_get_root (GtkWidget *widget);

Возвращает виджет GtkRoot для widget или NULL если виджет не содержится в дереве виджетов с корневым виджетом.

Виджеты GtkRoot вернут себя здесь.

gtk_widget_get_native ()

GtkNative *
gtk_widget_get_native (GtkWidget *widget);

Возвращает виджет GtkNative, содержащий widget, или NULL если виджет не содержится внутри дерева виджетов с нативным предком.

Виджеты GtkNative вернут себя здесь.

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. К возвращаемому виджету не будет добавлена ссылка; его не нужно освобождать.

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

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,
                                  double src_x,
                                  double src_y,
                                  double *dest_x,
                                  double *dest_y);

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

gtk_widget_add_controller ()

void
gtk_widget_add_controller (GtkWidget *widget,
                           GtkEventController *controller);

Добавляет controller к widget, чтобы он получал события. Обычно эту функцию нужно вызывать сразу после создания любого вида GtkEventController.

gtk_widget_remove_controller ()

void
gtk_widget_remove_controller (GtkWidget *widget,
                              GtkEventController *controller);

Удаляет controller из widget, чтобы он больше не обрабатывал события. Он больше не должен использоваться.

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

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_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(), этот контекст принадлежит виджету (его можно использовать до тех пор, пока экран для виджета не изменится или виджет не будет удалён из его верхнего уровня), и он будет обновлён для соответствия любым изменениям атрибутов виджета. Это можно отслеживать, прослушивая изменения свойства “root” виджета.

gtk_widget_set_font_options ()

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

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

gtk_widget_get_font_options ()

const cairo_font_options_t *
gtk_widget_get_font_options (GtkWidget *widget);

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

gtk_widget_set_font_map ()

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

Устанавливает карту шрифтов для использования в Pango отрисовке. Карта шрифтов — это объект, используемый для поиска шрифтов. Установка пользовательской карты шрифтов может быть полезной в особых ситуациях, например, когда необходимо добавить приложения специфические шрифты к набору доступных шрифтов.

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

gtk_widget_get_font_map ()

PangoFontMap *
gtk_widget_get_font_map (GtkWidget *widget);

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

gtk_widget_create_pango_layout ()

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

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

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

gtk_widget_get_cursor ()

GdkCursor *
gtk_widget_get_cursor (GtkWidget *widget);

Запрашивает курсор, установленный с помощью gtk_widget_set_cursor(). Подробности см. в этой функции.

gtk_widget_set_cursor ()

void
gtk_widget_set_cursor (GtkWidget *widget,
                       GdkCursor *cursor);

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

Если cursor равно NULL, widget будет использовать курсор, унаследованный от родительского виджета.

gtk_widget_set_cursor_from_name ()

void
gtk_widget_set_cursor_from_name (GtkWidget *widget,
                                 const char *name);

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

Это вспомогательная функция, которая создаёт курсор через gdk_cursor_new_from_name() и затем устанавливает его на widget с помощью gtk_widget_set_cursor(). Подробности см. в этих 2 функциях.

Кроме того, эта функция позволяет name быть NULL, что равносильно вызову gtk_widget_set_cursor() с курсором NULL.

gtk_widget_mnemonic_activate ()

gboolean
gtk_widget_mnemonic_activate (GtkWidget *widget,
                              gboolean group_cycling);

Выпускает сигнал “mnemonic-activate”.

gtk_widget_class_set_accessible_role ()

void
gtk_widget_class_set_accessible_role (GtkWidgetClass *widget_class,
                                      GtkAccessibleRole accessible_role);

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

Разные роли доступности имеют различные состояния и отображаются по-разному средствами вспомогательной технологии.

gtk_widget_class_get_accessible_role ()

GtkAccessibleRole
gtk_widget_class_get_accessible_role (GtkWidgetClass *widget_class);

Извлекает роль доступности, используемую данным классом GtkWidget.

Разные роли доступности имеют различные состояния и отображаются по-разному средствами вспомогательной технологии.

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

gtk_widget_child_focus ()

gboolean
gtk_widget_child_focus (GtkWidget *widget,
                        GtkDirectionType direction);

Эта функция используется реализациями пользовательских виджетов; если вы пишете приложение, используйте gtk_widget_grab_focus() для перемещения фокуса на конкретный виджет.

gtk_widget_child_focus() вызывается виджетами, когда пользователь перемещает фокус по окну с помощью комбинаций клавиш. direction указывает, какой тип движения происходит (вверх, вниз, влево, вправо, табуляция вперёд, табуляция назад). gtk_widget_child_focus() вызывает vfunc GtkWidgetClass.focus(); виджеты переопределяют этот vfunc для реализации соответствующего поведения фокуса.

По умолчанию focus() vfunc виджета должен возвращать TRUE если перемещение в direction оставило фокус на фокусируемом месте внутри этого виджета, и FALSE если перемещение в direction переместило фокус за пределы виджета. Если возвращается TRUE, виджеты обычно вызывают gtk_widget_grab_focus() для соответствующего размещения фокуса; если возвращается FALSE, они не изменяют текущее местоположение фокуса.

gtk_widget_get_child_visible ()

gboolean
gtk_widget_get_child_visible (GtkWidget *widget);

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

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

gtk_widget_get_parent ()

GtkWidget *
gtk_widget_get_parent (GtkWidget *widget);

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

gtk_widget_get_settings ()

GtkSettings *
gtk_widget_get_settings (GtkWidget *widget);

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

Обратите внимание, что этот метод можно вызвать только когда GtkWidget прикреплен к главному окну, поскольку объект настроек специфичен для конкретного GdkDisplay. Если вы хотите отслеживать изменения настроек виджета, подключитесь к событию notify::display.

gtk_widget_get_clipboard ()

GdkClipboard *
gtk_widget_get_clipboard (GtkWidget *widget);

Это вспомогательная функция для получения объекта буфера обмена для GdkDisplay, который использует widget.

Обратите внимание, что эта функция всегда работает, даже когда widget ещё не реализован.

gtk_widget_get_primary_clipboard ()

GdkClipboard *
gtk_widget_get_primary_clipboard (GtkWidget *widget);

Это вспомогательная функция для получения объекта первичного буфера обмена для GdkDisplay, который использует widget.

Обратите внимание, что эта функция всегда работает, даже когда widget ещё не реализован.

gtk_widget_get_display ()

GdkDisplay *
gtk_widget_get_display (GtkWidget *widget);

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

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

gtk_widget_get_size_request ()

void
gtk_widget_get_size_request (GtkWidget *widget,
                             int *width,
                             int *height);

Получение запрошенного размера виджета, явно заданного с помощью gtk_widget_set_size_request(). Значение -1 в width или height указывает, что эта размерность не была явно задана, и вместо этого будет использоваться естественный запрос виджета. См. gtk_widget_set_size_request(). Чтобы получить размер, который виджет фактически запросит, вызовите gtk_widget_measure() вместо этой функции.

gtk_widget_set_child_visible ()

void
gtk_widget_set_child_visible (GtkWidget *widget,
                              gboolean child_visible);

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

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

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

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

gtk_widget_set_size_request ()

void
gtk_widget_set_size_request (GtkWidget *widget,
                             int width,
                             int height);

Устанавливает минимальный размер виджета; то есть запрос на размер виджета будет по крайней мере width на height. Вы можете использовать эту функцию, чтобы принудительно сделать виджет больше, чем он обычно бы был.

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

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

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

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

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

Запрос размера, установленный здесь, не включает никакие отступы от свойств GtkWidget margin-left, margin-right, margin-top и margin-bottom, но включает в себя практически все другие отступы или свойства границы, установленные любым подклассом GtkWidget.

gtk_widget_list_mnemonic_labels ()

GList *
gtk_widget_list_mnemonic_labels (GtkWidget *widget);

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

Виджеты в списке не имеют отдельных ссылок. Если вы хотите перебрать список и выполнить действия, связанные с обратными вызовами, которые могут уничтожить виджеты, вы должны сначала вызвать g_list_foreach (result, (GFunc)g_object_ref, NULL), а затем освободить все виджеты после этого.

gtk_widget_add_mnemonic_label ()

void
gtk_widget_add_mnemonic_label (GtkWidget *widget,
                               GtkWidget *label);

Добавляет виджет в список мнемонических меток для этого виджета. (См. gtk_widget_list_mnemonic_labels()). Обратите внимание, что список мнемонических меток для виджета очищается при уничтожении виджета, поэтому вызывающий абонент должен убедиться, что также обновил свое внутреннее состояние в этот момент, используя подключение к сигналу “destroy” или слабое уведомление.

gtk_widget_remove_mnemonic_label ()

void
gtk_widget_remove_mnemonic_label (GtkWidget *widget,
                                  GtkWidget *label);

Удаляет виджет из списка мнемонических меток для этого виджета. (См. gtk_widget_list_mnemonic_labels()). Виджет должен был быть предварительно добавлен в список с помощью gtk_widget_add_mnemonic_label().

gtk_widget_error_bell ()

void
gtk_widget_error_bell (GtkWidget *widget);

Уведомляет пользователя об ошибке, связанной с вводом, в этом виджете. Если параметр “gtk-error-bell” равен TRUE, он вызывает gdk_surface_beep(), в противном случае он ничего не делает.

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

gtk_widget_keynav_failed ()

gboolean
gtk_widget_keynav_failed (GtkWidget *widget,
                          GtkDirectionType direction);

Эта функция должна вызываться всякий раз, когда навигация по клавиатуре в пределах одного виджета достигает границы. Функция излучает сигнал “keynav-failed” для виджета, и его возвращаемое значение должно интерпретироваться аналогично возвращаемому значению gtk_widget_child_focus():

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

Когда возвращается FALSE, вызывающий абонент должен продолжить навигацию по клавиатуре за пределами виджета, например, вызвав gtk_widget_child_focus() для верхнего уровня виджета.

Обработчик ::keynav-failed по умолчанию возвращает FALSE для GTK_DIR_TAB_FORWARD и GTK_DIR_TAB_BACKWARD. Для других значений GtkDirectionType он возвращает TRUE.

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

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

gtk_widget_get_tooltip_markup ()

const char *
gtk_widget_get_tooltip_markup (GtkWidget *widget);

Получает содержимое подсказки для widget, установленное с помощью gtk_widget_set_tooltip_markup().

gtk_widget_set_tooltip_markup ()

void
gtk_widget_set_tooltip_markup (GtkWidget *widget,
                               const char *markup);

Устанавливает markup как содержимое подсказки, которая размечена с помощью языка разметки текста Pango.

Эта функция позаботится об установке “has-tooltip” в качестве побочного эффекта и обработчика по умолчанию для сигнала “query-tooltip”.

См. также свойство “tooltip-markup” и gtk_tooltip_set_markup().

gtk_widget_get_tooltip_text ()

const char *
gtk_widget_get_tooltip_text (GtkWidget *widget);

Получает содержимое подсказки для widget .

Если подсказка для widget была установлена с помощью gtk_widget_set_tooltip_markup(), эта функция вернет экранированный текст.

gtk_widget_set_tooltip_text ()

void
gtk_widget_set_tooltip_text (GtkWidget *widget,
                             const char *text);

Устанавливает text в качестве содержимого всплывающей подсказки.

Если text содержит разметку, она будет экранирована.

Эта функция позаботится об установке “has-tooltip” в качестве побочного эффекта и о обработчике по умолчанию для сигнала “query-tooltip”.

См. также свойство “tooltip-text” и gtk_tooltip_set_text().

gtk_widget_get_has_tooltip ()

gboolean
gtk_widget_get_has_tooltip (GtkWidget *widget);

Возвращает текущее значение свойства has-tooltip. Подробнее см. “has-tooltip”.

gtk_widget_set_has_tooltip ()

void
gtk_widget_set_has_tooltip (GtkWidget *widget,
                            gboolean has_tooltip);

Устанавливает свойство has-tooltip для widget на значение has_tooltip . Подробнее см. “has-tooltip”.

gtk_widget_trigger_tooltip_query ()

void
gtk_widget_trigger_tooltip_query (GtkWidget *widget);

Вызывает запрос всплывающей подсказки на экране, где расположен toplevel окна widget.

gtk_widget_get_allocated_width ()

int
gtk_widget_get_allocated_width (GtkWidget *widget);

Возвращает ширину, которая в настоящее время выделена для widget .

gtk_widget_get_allocated_height ()

int
gtk_widget_get_allocated_height (GtkWidget *widget);

Возвращает высоту, которая в настоящее время выделена для widget .

gtk_widget_get_allocation ()

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

Возвращает выделение виджета.

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

Таким образом, контейнер макета гарантирует, что его дочерние элементы остаются внутри заданных границ, но не гарантирует, что они имеют ровно те границы, которые задал контейнер.

gtk_widget_get_allocated_baseline ()

int
gtk_widget_get_allocated_baseline (GtkWidget *widget);

Возвращает линию основания, которая в настоящее время выделена для widget . Эта функция предназначена для использования при реализации обработчиков для функции GtkWidgetClass.snapshot() и при выделении дочерних виджетов в GtkWidgetClass.size_allocate().

gtk_widget_get_width ()

int
gtk_widget_get_width (GtkWidget *widget);

Возвращает ширину содержимого виджета, переданную в его реализацию size-allocate. Это размер, который следует использовать в GtkWidgetClass.snapshot(). Для событий указателя см. gtk_widget_contains().

gtk_widget_get_height ()

int
gtk_widget_get_height (GtkWidget *widget);

Возвращает высоту содержимого виджета, переданную в его реализацию size-allocate. Это размер, который следует использовать в GtkWidgetClass.snapshot(). Для событий указателя см. gtk_widget_contains().

gtk_widget_get_size ()

int
gtk_widget_get_size (GtkWidget *widget,
                     GtkOrientation orientation);

Возвращает ширину или высоту содержимого виджета, в зависимости от orientation . Это эквивалентно вызову gtk_widget_get_width() для GTK_ORIENTATION_HORIZONTAL или gtk_widget_get_height() для GTK_ORIENTATION_VERTICAL, но может быть использован при написании ориентационно-независимого кода, например, при реализации виджетов GtkOrientable.

gtk_widget_compute_bounds ()

gboolean
gtk_widget_compute_bounds (GtkWidget *widget,
                           GtkWidget *target,
                           graphene_rect_t *out_bounds);

Вычисляет границы widget в системе координат target. ВНИМАНИЕ: Объясните, что такое «границы».

Если операция выполнена успешно, возвращается TRUE. Если у widget нет границ или границы не могут быть выражены в системе координат target (например, если оба виджета находятся в разных окнах), возвращается FALSE и bounds устанавливается в нулевой прямоугольник.

Допустимо, чтобы widget и target были одним и тем же виджетом.

gtk_widget_compute_transform ()

gboolean
gtk_widget_compute_transform (GtkWidget *widget,
                              GtkWidget *target,
                              graphene_matrix_t *out_transform);

Вычисляет матрицу, подходящую для описания преобразования из системы координат widget в систему координат target.

gtk_widget_compute_point ()

gboolean
gtk_widget_compute_point (GtkWidget *widget,
                          GtkWidget *target,
                          const graphene_point_t *point,
                          graphene_point_t *out_point);

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

gtk_widget_contains ()

gboolean
gtk_widget_contains (GtkWidget *widget,
                     double x,
                     double y);

Проверяет, содержится ли точка с координатами (x, y) в widget.

Координаты (x, y) должны быть в координатах виджета, поэтому (0, 0) предполагается как верхний левый угол области содержимого widget.

gtk_widget_pick ()

GtkWidget *
gtk_widget_pick (GtkWidget *widget,
                 double x,
                 double y,
                 GtkPickFlags flags);

Ищет потомка widget (включая сам widget), ближайшего к экрану в точке (x, y). Точка должна быть задана в координатах виджета, поэтому (0, 0) предполагается как верхний левый угол области содержимого widget.

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

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

gtk_widget_get_can_focus ()

gboolean
gtk_widget_get_can_focus (GtkWidget *widget);

Определяет, может ли фокус ввода войти в widget или в любой из его дочерних элементов.

См. gtk_widget_set_focusable().

gtk_widget_set_can_focus ()

void
gtk_widget_set_can_focus (GtkWidget *widget,
                          gboolean can_focus);

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

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

Обратите внимание, что can_focus имеет значение TRUE — это лишь одно из необходимых условий для получения фокуса. Виджет также должен быть чувствительным и фокусируемым, и не иметь предка, отмеченного как не фокусируемый, чтобы получить фокус ввода.

См. gtk_widget_grab_focus() для фактического установления фокуса ввода на виджете.

gtk_widget_get_focusable ()

gboolean
gtk_widget_get_focusable (GtkWidget *widget);

Определяет, может ли widget получить фокус ввода. См. gtk_widget_set_focusable().

gtk_widget_set_focusable ()

void
gtk_widget_set_focusable (GtkWidget *widget,
                          gboolean focusable);

Указывает, может ли widget получить фокус ввода.

Реализации виджетов должны установить focusable в TRUE в функции init(), если они хотят получать ввод с клавиатуры.

Обратите внимание, что focusable имеет значение TRUE — это лишь одно из необходимых условий для получения фокуса. Виджет также должен быть чувствительным и фокусируемым, и не иметь предка, отмеченного как не фокусируемый, чтобы получить фокус ввода.

См. gtk_widget_grab_focus() для фактического установления фокуса ввода на виджете.

gtk_widget_get_visible ()

gboolean
gtk_widget_get_visible (GtkWidget *widget);

Определяет, является ли виджет видимым. Если вы хотите учесть, является ли родительский виджет также видимым, используйте gtk_widget_is_visible() вместо этого.

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

См. gtk_widget_set_visible().

gtk_widget_is_visible ()

gboolean
gtk_widget_is_visible (GtkWidget *widget);

Определяет, отмечены ли виджет и все его родительские элементы как видимые.

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

См. также gtk_widget_get_visible() и gtk_widget_set_visible()

gtk_widget_set_visible ()

void
gtk_widget_set_visible (GtkWidget *widget,
                        gboolean visible);

Устанавливает состояние видимости widget. Обратите внимание, что установка в TRUE не означает, что виджет фактически отображается, см. gtk_widget_get_visible().

Эта функция просто вызывает gtk_widget_show() или gtk_widget_hide(), но удобнее использовать, когда видимость виджета зависит от какого-либо условия.

gtk_widget_set_state_flags ()

void
gtk_widget_set_state_flags (GtkWidget *widget,
                            GtkStateFlags flags,
                            gboolean clear);

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

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

gtk_widget_unset_state_flags ()

void
gtk_widget_unset_state_flags (GtkWidget *widget,
                              GtkStateFlags flags);

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

gtk_widget_get_state_flags ()

GtkStateFlags
gtk_widget_get_state_flags (GtkWidget *widget);

Возвращает состояние виджета в виде набора флагов. Стоит отметить, что возвращается эффективное состояние GTK_STATE_FLAG_INSENSITIVE, т. е. также на основе нечувствительности родителя, даже если widget сам по себе чувствителен.

Также обратите внимание, что если вам нужен способ получить GtkStateFlags для передачи методу GtkStyleContext, вы должны обратиться к gtk_style_context_get_state().

gtk_widget_has-default ()

gboolean
gtk_widget_has_default (GtkWidget *widget);

Определяет, является ли widget текущим виджетом по умолчанию в пределах его верхнего уровня.

gtk_widget_has_focus ()

gboolean
gtk_widget_has_focus (GtkWidget *widget);

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

gtk_widget_has-visible-focus ()

gboolean
gtk_widget_has_visible_focus (GtkWidget *widget);

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

Чтобы узнать, имеет ли виджет глобальный фокус ввода, используйте gtk_widget_has_focus().

gtk_widget_is-drawable ()

gboolean
gtk_widget_is_drawable (GtkWidget *widget);

Определяет, может ли к widget быть отрисовано. Виджет может быть отрисован, если он отображен и видим.

gtk_widget_set-receives-default ()

void
gtk_widget_set_receives_default (GtkWidget *widget,
                                 gboolean receives_default);

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

gtk_widget_get_receives_default ()

gboolean
gtk_widget_get_receives_default (GtkWidget *widget);

Определяет, является ли widget всегда виджетом по умолчанию в своем верхнем уровне, когда у него есть фокус, даже если другим виджетом является виджет по умолчанию.

См. gtk_widget_set_receives_default().

gtk_widget_get_realized ()

gboolean
gtk_widget_get_realized (GtkWidget *widget);

Определяет, реализован ли widget.

gtk_widget_get_mapped ()

gboolean
gtk_widget_get_mapped (GtkWidget *widget);

отображен ли виджет.

gtk_widget_get_opacity ()

double
gtk_widget_get_opacity (GtkWidget *widget);

Возвращает запрашиваемую непрозрачность для этого виджета. См. gtk_widget_set_opacity().

gtk_widget_set_opacity ()

void
gtk_widget_set_opacity (GtkWidget *widget,
                        double opacity);

Запрашивает, чтобы widget был отображен с частичной непрозрачностью, при этом значение непрозрачности 0 соответствует полной прозрачности, а 1 — полной непрозрачности. (Значения непрозрачности ограничиваются диапазоном [0, 1]).

Непрозрачность работает как для виджетов верхнего уровня, так и для дочерних виджетов, хотя есть некоторые ограничения: для виджетов верхнего уровня применение непрозрачности зависит от возможностей системы окон. В X11 это имеет какой-либо эффект только на X-дисплеях с диспетчером компоновки, см. gdk_display_is_composited(). На Windows и Wayland это должно всегда работать, хотя установка непрозрачности окна после отображения окна может привести к некоторым мерцаниям.

Обратите внимание, что непрозрачность наследуется через включение — если вы установите верхний уровень с частичной непрозрачностью, все его содержимое будет отображаться полупрозрачным, поскольку в конечном итоге он отображается на этом верхнем уровне. Само значение непрозрачности не наследуется дочерними виджетами (потому что это сделает виджеты глубже в иерархии всё более прозрачными). Вследствие этого, GtkPopovers и другие GtkNative виджеты со своим поверхностью будут использовать свое собственное значение непрозрачности, и, следовательно, по умолчанию будут отображаться непрозрачно, даже если они подключены к верхнему уровню, который полупрозрачный.

gtk_widget_get_overflow ()

GtkOverflow
gtk_widget_get_overflow (GtkWidget *widget);

Возвращает значение, установленное с помощью gtk_widget_set_overflow().

gtk_widget_set_overflow ()

void
gtk_widget_set_overflow (GtkWidget *widget,
                         GtkOverflow overflow);

Устанавливает, как widget обрабатывает содержимое, которое рисуется за пределами области содержимого виджета. Подробности см. в определении GtkOverflow.

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

Значение по умолчанию — GTK_OVERFLOW_VISIBLE.

gtk_widget_measure ()

void
gtk_widget_measure (GtkWidget *widget,
                    GtkOrientation orientation,
                    int for_size,
                    int *minimum,
                    int *natural,
                    int *minimum_baseline,
                    int *natural_baseline);

Измеряет widget в ориентации orientation и для заданного for_size . Например, если orientation — GTK_ORIENTATION_HORIZONTAL, а for_size — 300, эта функция вычислит минимальную и естественную ширину widget, если ей назначена высота 300 пикселей.

См. раздел управления геометрией GtkWidget для получения дополнительных сведений о реализации GtkWidgetClass.measure().

gtk_widget_snapshot_child ()

void
gtk_widget_snapshot_child (GtkWidget *widget,
                           GtkWidget *child,
                           GtkSnapshot *snapshot);

Когда виджет получает вызов функции снимка, он должен отправить синтетические вызовы GtkWidgetClass.snapshot() всем своим дочерним виджетам. Данная функция предоставляет удобный способ сделать это. Виджет, получив вызов своей функции GtkWidgetClass.snapshot(), вызывает gtk_widget_snapshot_child() для каждого дочернего виджета, передавая в него snapshot, полученное виджетом.

gtk_widget_snapshot_child() заботится о переводе происхождения snapshot и определении, нужно ли делать снимок дочернего виджета.

Для дочерних виджетов, реализующих GtkNative, эта функция ничего не делает.

gtk_widget_get_next_sibling ()

GtkWidget *
gtk_widget_get_next_sibling (GtkWidget *widget);

Возвращает следующего брата виджета.

Этот API предназначен в первую очередь для реализации виджетов.

gtk_widget_get_prev_sibling ()

GtkWidget *
gtk_widget_get_prev_sibling (GtkWidget *widget);

Возвращает предыдущего брата виджета.

Этот API предназначен в первую очередь для реализации виджетов.

gtk_widget_get_first_child ()

GtkWidget *
gtk_widget_get_first_child (GtkWidget *widget);

Возвращает первого дочернего виджета.

Этот API предназначен в первую очередь для реализации виджетов.

gtk_widget_get_last_child ()

GtkWidget *
gtk_widget_get_last_child (GtkWidget *widget);

Возвращает последний дочерний виджет.

Этот API предназначен в первую очередь для реализации виджетов.

gtk_widget_insert_before ()

void
gtk_widget_insert_before (GtkWidget *widget,
                          GtkWidget *parent,
                          GtkWidget *next_sibling);

Вставляет widget в список дочерних виджетов parent.

Он будет размещён перед next_sibling, или в конце, если next_sibling является NULL.

После вызова этой функции gtk_widget_get_next_sibling(widget) вернёт next_sibling.

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

Этот API предназначен в первую очередь для реализации виджетов; если вы просто используете виджет, вы *обязаны* использовать его собственный API для добавления дочерних элементов.

gtk_widget_insert_after ()

void
gtk_widget_insert_after (GtkWidget *widget,
                         GtkWidget *parent,
                         GtkWidget *previous_sibling);

Вставляет widget в список дочерних виджетов parent.

Он будет размещён после previous_sibling, или в начале, если previous_sibling является NULL.

После вызова этой функции gtk_widget_get_prev_sibling(widget) вернёт previous_sibling.

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

Этот API предназначен в первую очередь для реализации виджетов; если вы просто используете виджет, вы *обязаны* использовать его собственный API для добавления дочерних элементов.

gtk_widget_set_layout_manager ()

void
gtk_widget_set_layout_manager (GtkWidget *widget,
                               GtkLayoutManager *layout_manager);

Устанавливает делегат менеджера компоновки, который предоставляет реализацию для измерения и распределения дочерних элементов widget.

gtk_widget_get_layout_manager ()

GtkLayoutManager *
gtk_widget_get_layout_manager (GtkWidget *widget);

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

gtk_widget_should_layout ()

gboolean
gtk_widget_should_layout (GtkWidget *widget);

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

gtk_widget_get_css_name ()

const char *
gtk_widget_get_css_name (GtkWidget *self);

Возвращает имя CSS, используемое для self .

gtk_widget_add_css_class ()

void
gtk_widget_add_css_class (GtkWidget *widget,
                          const char *css_class);

Добавляет css_class к widget . После вызова этой функции, стиль widget будет соответствовать css_class в соответствии с правилами сопоставления CSS.

gtk_widget_remove_css_class ()

void
gtk_widget_remove_css_class (GtkWidget *widget,
                             const char *css_class);

Удаляет css_class из widget . После этого, стиль widget больше не будет соответствовать css_class .

gtk_widget_has_css_class ()

gboolean
gtk_widget_has_css_class (GtkWidget *widget,
                          const char *css_class);

Возвращает, применён ли в настоящее время css_class к widget .

gtk_widget_get_css_classes ()

char **
gtk_widget_get_css_classes (GtkWidget *widget);

Возвращает список классов CSS, применённых к widget .

gtk_widget_set_css_classes ()

void
gtk_widget_set_css_classes (GtkWidget *widget,
                            const char **classes);

Очищает все классы CSS, применённые к widget , и заменяет их на classes .

gtk_widget_get_style_context ()

GtkStyleContext *
gtk_widget_get_style_context (GtkWidget *widget);

Возвращает контекст стиля, связанный с widget . Гарантируется, что возвращаемый объект будет одинаковым в течение всего жизненного цикла widget .

gtk_widget_class_get_css_name ()

const char *
gtk_widget_class_get_css_name (GtkWidgetClass *widget_class);

Получает имя, используемое этим классом для сопоставления в коде CSS. Смотрите gtk_widget_class_set_css_name() для получения подробной информации.

gtk_widget_class_set_css-name ()

void
gtk_widget_class_set_css_name (GtkWidgetClass *widget_class,
                               const char *name);

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

Если эта функция не вызывается для данного класса, используется имя, установленное в родительском классе. По умолчанию GtkWidget использует имя "widget".

gtk_requisition_new ()

GtkRequisition *
gtk_requisition_new (void);

Выделяет новую структуру GtkRequisition и инициализирует её элементы нулями.

gtk_requisition_copy ()

GtkRequisition *
gtk_requisition_copy (const GtkRequisition *requisition);

Копирует GtkRequisition.

gtk_requisition_free ()

void
gtk_requisition_free (GtkRequisition *requisition);

Освобождает GtkRequisition.

gtk_widget_get_request_mode ()

GtkSizeRequestMode
gtk_widget_get_request_mode (GtkWidget *widget);

Получает, предпочитает ли виджет компоновку «высота по ширине» или «ширина по высоте».

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

gtk_widget_get_preferred_size ()

void
gtk_widget_get_preferred_size (GtkWidget *widget,
                               GtkRequisition *minimum_size,
                               GtkRequisition *natural_size);

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

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

Обращаться с осторожностью. Обратите внимание, что естественная высота виджета «высота по ширине» обычно будет меньше, чем минимальная высота, поскольку требуемая высота для естественной ширины обычно меньше, чем требуемая высота для минимальной ширины.

Используйте gtk_widget_measure(), если вы хотите поддерживать выравнивание по основанию.

gtk_distribute_natural_allocation ()

int
gtk_distribute_natural_allocation (int extra_space,
                                   guint n_requested_sizes,
                                   GtkRequestedSize *sizes);

Распределяет extra_space по дочерним sizes, сначала приводя меньшие дочерние элементы к естественному размеру.

Остальное пространство будет добавлено к члену minimum_size структуры GtkRequestedSize. Если все размеры достигнут своего естественного значения, то остальное пространство возвращается.

gtk_widget_get_halign ()

GtkAlign
gtk_widget_get_halign (GtkWidget *widget);

Получает значение свойства “halign”.

Из соображений обратной совместимости этот метод никогда не вернет GTK_ALIGN_BASELINE, а вместо этого преобразует его в GTK_ALIGN_FILL. Выравнивание по основанию не поддерживается для горизонтального выравнивания.

gtk_widget_set_halign ()

void
gtk_widget_set_halign (GtkWidget *widget,
                       GtkAlign align);