GtkWindow

gtk_window_new ()

GtkWidget *
gtk_window_new (GtkWindowType type);

Создаёт новую GtkWindow, которая является окном верхнего уровня, которое может содержать другие виджеты. Почти всегда тип окна должен быть GTK_WINDOW_TOPLEVEL. Если вы реализуете что-то вроде всплывающего меню с нуля (что не рекомендуется, просто используйте GtkMenu), вы можете использовать GTK_WINDOW_POPUP. GTK_WINDOW_POPUP не предназначен для диалоговых окон, хотя в некоторых других инструментальных наборах диалоговые окна называются «всплывающими». В GTK+ GTK_WINDOW_POPUP означает всплывающее меню или всплывающую подсказку. В X11 всплывающие окна не управляются менеджером окон.

Если вам нужно просто окно без оформления (без рамок окна), используйте gtk_window_set_decorated(), не используйте GTK_WINDOW_POPUP.

Все окна верхнего уровня, созданные с помощью gtk_window_new(), хранятся во внутреннем списке окон верхнего уровня. Этот список можно получить из gtk_window_list_toplevels(). Из-за того, что Gtk+ хранит ссылку на окно внутри, gtk_window_new() не возвращает ссылку вызывающему коду.

Чтобы удалить GtkWindow, вызовите gtk_widget_destroy().

gtk_window_set_title ()

void
gtk_window_set_title (GtkWindow *window,
                      const gchar *title);

Устанавливает заголовок GtkWindow. Заголовок окна будет отображаться в его строке заголовка; в X Window System строка заголовка отрисовывается менеджером окон, поэтому точный вид заголовка для пользователя может отличаться в зависимости от его конфигурации. Заголовок должен помочь пользователю отличить это окно от других открытых окон. Хороший заголовок может включать имя приложения и имя текущего файла документа, например.

gtk_window_set_wmclass ()

void
gtk_window_set_wmclass (GtkWindow *window,
                        const gchar *wmclass_name,
                        const gchar *wmclass_class);

Не используйте эту функцию. Она устанавливает подсказки «класс» и «имя» X Window System для окна. Согласно ICCCM, вы всегда должны устанавливать эти значения одинаковыми для всех окон в приложении, и GTK+ по умолчанию устанавливает их в это значение, поэтому вызов этой функции бесполезен. Однако вы можете вызвать gtk_window_set_role() для каждого окна в вашем приложении, для удобства менеджера сеанса. Установка роли позволяет менеджеру окон восстанавливать позиции окон при загрузке сохранённого сеанса.

gtk_window_set_resizable ()

void
gtk_window_set_resizable (GtkWindow *window,
                          gboolean resizable);

Устанавливает, можно ли пользователю изменять размер окна. Окна по умолчанию можно изменять в размерах.

gtk_window_get_resizable ()

gboolean
gtk_window_get_resizable (GtkWindow *window);

Получает значение, установленное функцией gtk_window_set_resizable().

gtk_window_add_accel_group ()

void
gtk_window_add_accel_group (GtkWindow *window,
                            GtkAccelGroup *accel_group);

Связывает accel_group с window, так что вызов gtk_accel_groups_activate() на window активирует ускорители в accel_group .

gtk_window_remove_accel_group ()

void
gtk_window_remove_accel_group (GtkWindow *window,
                               GtkAccelGroup *accel_group);

Отменяет эффект gtk_window_add_accel_group().

gtk_window_activate_focus ()

gboolean
gtk_window_activate_focus (GtkWindow *window);

Активирует текущий виджет, на котором сфокусирован курсор, внутри окна.

gtk_window_activate_default ()

gboolean
gtk_window_activate_default (GtkWindow *window);

Активирует виджет по умолчанию для окна, если текущий сфокусированный виджет не настроен на получение действия по умолчанию (см. gtk_widget_set_receives_default()), в этом случае активируется сфокусированный виджет.

gtk_window_set_modal ()

void
gtk_window_set_modal (GtkWindow *window,
                      gboolean modal);

Устанавливает режим окна: модальный или немодальный. Модальные окна препятствуют взаимодействию с другими окнами в том же приложении. Чтобы модальные диалоговые окна оставались сверху основных окон приложения, используйте gtk_window_set_transient_for(), чтобы сделать диалоговое окно дочерним для родительского окна; большинство менеджеров окон затем запретят перемещение диалогового окна ниже родительского.

gtk_window_set_default_size ()

void
gtk_window_set_default_size (GtkWindow *window,
                             gint width,
                             gint height);

Устанавливает размер по умолчанию для окна. Если «естественный» размер окна (запрос на размер) больше значения по умолчанию, значение по умолчанию будет проигнорировано. Более общим образом, если размер по умолчанию не соответствует геометрическим подсказкам для окна (gtk_window_set_geometry_hints() можно использовать для явного задания этих подсказок), размер по умолчанию будет ограничен ближайшим разрешенным размером.

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

Для большего контроля над начальным размером окна и способом изменения размера, обратитесь к gtk_window_set_geometry_hints().

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

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

Окна не могут иметь размер 0x0, они должны иметь размер как минимум 1x1, но передача 0 для width и height допустима, что приводит к размеру по умолчанию 1x1.

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

gtk_window_set_default_geometry ()

void
gtk_window_set_default_geometry (GtkWindow *window,
                                 gint width,
                                 gint height);

Подобно gtk_window_set_default_size(), но width и height интерпретируются в терминах базового размера и приращения, заданного gtk_window_set_geometry_hints.

С версии: 3.0

gtk_window_set_geometry_hints ()

void
gtk_window_set_geometry_hints (GtkWindow *window,
                               GtkWidget *geometry_widget,
                               GdkGeometry *geometry,
                               GdkWindowHints geom_mask);

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

gtk_window_set_gravity ()

void
gtk_window_set_gravity (GtkWindow *window,
                        GdkGravity gravity);

Направление тяжести окна определяет значение координат, передаваемых в gtk_window_move(). Подробнее см. gtk_window_move() и GdkGravity.

По умолчанию направление тяжести окна — GDK_GRAVITY_NORTH_WEST, что обычно соответствует ожиданиям.

gtk_window_get_gravity ()

GdkGravity
gtk_window_get_gravity (GtkWindow *window);

Возвращает значение, заданное функцией gtk_window_set_gravity().

gtk_window_set_position ()

void
gtk_window_set_position (GtkWindow *window,
                         GtkWindowPosition position);

Устанавливает ограничение положения для этого окна. Если старое или новое ограничение — GTK_WIN_POS_CENTER_ALWAYS, это также переместит окно для удовлетворения нового ограничения.

gtk_window_set_transient_for ()

void
gtk_window_set_transient_for (GtkWindow *window,
                              GtkWindow *parent);

Диалоговые окна должны быть установлены как дочерние для главного окна приложения, из которого они были вызваны. Это позволяет менеджерам окон, например, держать диалоговое окно поверх главного окна или центрировать диалоговое окно над главным окном. Функции gtk_dialog_new_with_buttons() и другие удобные функции в GTK+ иногда вызывают gtk_window_set_transient_for() от вашего имени.

Передача NULL для parent снимает текущее дочернее окно.

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

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

gtk_window_set_attached_to ()

void
gtk_window_set_attached_to (GtkWindow *window,
                            GtkWidget *attach_widget);

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

Примеры мест, где полезно указать эту связь, — это, например, GtkMenu, созданный GtkComboBox, всплывающее окно автодополнения, созданное GtkEntry, или окно поиска автозаполнения, созданное GtkTreeView.

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

Передача NULL для attach_widget отсоединяет окно.

С: 3.4

gtk_window_set_destroy_with_parent ()

void
gtk_window_set_destroy_with_parent (GtkWindow *window,
                                    gboolean setting);

Если setting равно TRUE, то уничтожение родительского окна-дочернего элемента window также уничтожит window. Это полезно для диалоговых окон, которые не должны сохраняться после окончания жизни главного окна, с которым они связаны, например.

gtk_window_set_hide_titlebar_when_maximized ()

void
gtk_window_set_hide_titlebar_when_maximized
                               (GtkWindow *window,
                                gboolean setting);

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

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

С: 3.4

gtk_window_set_screen ()

void
gtk_window_set_screen (GtkWindow *window,
                       GdkScreen *screen);

Устанавливает GdkScreen, на котором отображается window; если окно уже отображено, оно будет скрыто, а затем отображено на новом экране.

С: 2.2

gtk_window_get_screen ()

GdkScreen *
gtk_window_get_screen (GtkWindow *window);

Возвращает связанный с window GdkScreen.

С: 2.2

gtk_window_is_active ()

gboolean
gtk_window_is_active (GtkWindow *window);

Возвращает, является ли окно частью текущего активного окна верхнего уровня. (То есть, окно верхнего уровня, получающее нажатия клавиш.) Значение true возвращается, если окно само является активным окном верхнего уровня, а также, например, если это GtkPlug, вставленный в активное окно верхнего уровня. Вы можете использовать эту функцию, если хотите по-разному отобразить виджет в активном окне по сравнению с виджетом в неактивном окне. См. gtk_window_has_toplevel_focus()

С: 2.4

gtk_window_is_maximized ()

gboolean
gtk_window_is_maximized (GtkWindow *window);

Получает текущее состояние максимализации окна window.

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

С версии: 3.12

gtk_window_has_toplevel_focus ()

gboolean
gtk_window_has_toplevel_focus (GtkWindow *window);

Возвращает значение, указывающее, находится ли фокус ввода внутри этого GtkWindow. Для реальных окон верхнего уровня это идентично gtk_window_is_active(), но для встроенных окон, таких как GtkPlug, результаты будут отличаться.

С версии: 2.4

gtk_window_list_toplevels ()

GList *
gtk_window_list_toplevels (void);

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

gtk_window_add_mnemonic ()

void
gtk_window_add_mnemonic (GtkWindow *window,
                         guint keyval,
                         GtkWidget *target);

Добавляет мнемонику к этому окну.

gtk_window_remove_mnemonic ()

void
gtk_window_remove_mnemonic (GtkWindow *window,
                            guint keyval,
                            GtkWidget *target);

Удаляет мнемонику из этого окна.

gtk_window_mnemonic_activate ()

gboolean
gtk_window_mnemonic_activate (GtkWindow *window,
                              guint keyval,
                              GdkModifierType modifier);

Активирует цели, связанные с мнемоникой.

gtk_window_activate_key ()

gboolean
gtk_window_activate_key (GtkWindow *window,
                         GdkEventKey *event);

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

С версии: 2.4

gtk_window_propagate_key_event ()

gboolean
gtk_window_propagate_key_event (GtkWindow *window,
                                GdkEventKey *event);

Распространяет событие нажатия или отпуска клавиши на виджет фокуса и вверх по цепочке контейнера фокуса, пока виджет не обработает event. Обычно вызывается обработчиками ::key_press_event и ::key_release_event по умолчанию для окон верхнего уровня, но в некоторых случаях может быть полезно вызвать его напрямую при переопределении стандартной обработки клавиш для окна верхнего уровня.

С версии: 2.4

gtk_window_get_focus ()

GtkWidget *
gtk_window_get_focus (GtkWindow *window);

Получает текущий виджет, имеющий фокус, внутри окна. Обратите внимание, что это виджет, который получил бы фокус, если бы окно верхнего уровня получило фокус; если окно верхнего уровня не имеет фокуса, то gtk_widget_has_focus (widget) для виджета не будет TRUE.

gtk_window_set_focus ()

void
gtk_window_set_focus (GtkWindow *window,
                      GtkWidget *focus);

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

gtk_window_get_default_widget ()

GtkWidget *
gtk_window_get_default_widget (GtkWindow *window);

Возвращает виджет по умолчанию для window. Подробнее см. gtk_window_set_default().

С: 2.14

gtk_window_set_default ()

void
gtk_window_set_default (GtkWindow *window,
                        GtkWidget *default_widget);

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

gtk_window_present ()

void
gtk_window_present (GtkWindow *window);

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

Если window скрыто, эта функция также вызывает gtk_widget_show().

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

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

gtk_window_present_with_time ()

void
gtk_window_present_with_time (GtkWindow *window,
                              guint32 timestamp);

Предоставляет окно пользователю в ответ на взаимодействие с пользователем. Если вам нужно представить окно без отметки времени, используйте gtk_window_present(). Подробнее см. gtk_window_present().

С: 2.8

gtk_window_close ()

void
gtk_window_close (GtkWindow *window);

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

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

С: 3.10

gtk_window_iconify ()

void
gtk_window_iconify (GtkWindow *window);

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

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

Вы можете отслеживать сворачивание с помощью сигнала «window-state-event» на GtkWidget.

gtk_window_deiconify ()

void
gtk_window_deiconify (GtkWindow *window);

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

Вы можете отслеживать сворачивание с помощью сигнала «window-state-event» на GtkWidget.

gtk_window_stick ()

void
gtk_window_stick (GtkWindow *window);

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

Разрешается вызывать эту функцию до отображения окна.

Вы можете отслеживать закрепление с помощью сигнала «window-state-event» на GtkWidget.

gtk_window_unstick ()

void
gtk_window_unstick (GtkWindow *window);

Запрашивает открепление window, что означает, что оно будет отображаться только на одном из рабочих столов пользователя. Обратите внимание, что вы не должны предполагать, что окно наверняка будет откреплено после этого, поскольку другие сущности (например, пользователь или менеджер окон) могут снова закрепить его. Но обычно окно будет откреплено. Просто не пишите код, который вызовет ошибку, если этого не произойдёт.

Вы можете отслеживать закрепление с помощью сигнала «window-state-event» на GtkWidget.

gtk_window_maximize ()

void
gtk_window_maximize (GtkWindow *window);

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

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

Вы можете отслеживать максимализацию через сигнал «window-state-event» для GtkWidget или следя за уведомлениями о свойстве «is-maximized».

gtk_window_unmaximize ()

void
gtk_window_unmaximize (GtkWindow *window);

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

Вы можете отслеживать максимализацию через сигнал «window-state-event» для GtkWidget.

gtk_window_fullscreen ()

void
gtk_window_fullscreen (GtkWindow *window);

Запрашивает вывод window в полноэкранном режиме. Обратите внимание, что нельзя гарантировать, что окно действительно будет в полноэкранном режиме, поскольку другие сущности (например, пользователь или менеджер окон) могут снова переключиться на обычный режим, и не все менеджеры окон выполняют запросы на полноэкранный режим. Но обычно окно переключится на полноэкранный режим. Просто не пишите код, который аварийно завершается, если этого не произойдёт.

Вы можете отслеживать полноэкранный режим через сигнал «window-state-event» для GtkWidget.

С: 2.2

gtk_window_fullscreen_on_monitor ()

void
gtk_window_fullscreen_on_monitor (GtkWindow *window,
                                  GdkScreen *screen,
                                  gint monitor);

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

Вы можете отслеживать полноэкранный режим через сигнал "window-state-event" для GtkWidget.

С: 3.18

gtk_window_unfullscreen ()

void
gtk_window_unfullscreen (GtkWindow *window);

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

Вы можете отслеживать полноэкранный режим через сигнал «window-state-event» для GtkWidget.

С: 2.2

gtk_window_set_keep_above ()

void
gtk_window_set_keep_above (GtkWindow *window,
                           gboolean setting);

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

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

Вы можете отслеживать состояние отображения поверх других окон через сигнал «window-state-event» для GtkWidget.

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

С: 2.4

gtk_window_set_keep_below ()

void
gtk_window_set_keep_below (GtkWindow *window,
                           gboolean setting);

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

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

Вы можете отслеживать состояние расположения под другими окнами через сигнал «window-state-event» для GtkWidget.

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

С: 2.4

gtk_window_begin_resize_drag ()

void
gtk_window_begin_resize_drag (GtkWindow *window,
                              GdkWindowEdge edge,
                              gint button,
                              gint root_x,
                              gint root_y,
                              guint32 timestamp);

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

gtk_window_begin_move_drag ()

void
gtk_window_begin_move_drag (GtkWindow *window,
                            gint button,
                            gint root_x,
                            gint root_y,
                            guint32 timestamp);

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

gtk_window_set_decorated ()

void
gtk_window_set_decorated (GtkWindow *window,
                          gboolean setting);

По умолчанию окна украшены строкой заголовка, элементами управления изменением размера и т. д. Некоторые менеджеры окон позволяют GTK+ отключать эти украшения, создавая окно без границ. Если вы установите свойство decorated в FALSE с помощью этой функции, GTK+ сделает все возможное, чтобы убедить менеджер окон не украшать окно. В зависимости от системы эта функция может не оказывать никакого эффекта, когда вызывается для уже видимого окна, поэтому вы должны вызвать её перед вызовом gtk_widget_show().

В Windows эта функция всегда работает, так как нет политики менеджера окон.

gtk_window_set_deletable ()

void
gtk_window_set_deletable (GtkWindow *window,
                          gboolean setting);

По умолчанию окна имеют кнопку закрытия в рамке окна. Некоторые менеджеры окон позволяют GTK+ отключать эту кнопку. Если вы установите свойство deletable в FALSE с помощью этой функции, GTK+ сделает все возможное, чтобы убедить менеджер окон не показывать кнопку закрытия. В зависимости от системы эта функция может не оказывать никакого эффекта, когда вызывается для уже видимого окна, поэтому вы должны вызвать её перед вызовом gtk_widget_show().

В Windows эта функция всегда работает, так как нет политики менеджера окон.

С версии: 2.10

gtk_window_set_mnemonic_modifier ()

void
gtk_window_set_mnemonic_modifier (GtkWindow *window,
                                  GdkModifierType modifier);

Устанавливает модификатор мнемоники для этого окна.

gtk_window_set_type_hint ()

void
gtk_window_set_type_hint (GtkWindow *window,
                          GdkWindowTypeHint hint);

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

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

gtk_dialog_new_with_buttons() и другие вспомогательные функции в GTK+ иногда вызывают gtk_window_set_type_hint() от вашего имени.

gtk_window_set_skip_taskbar_hint ()

void
gtk_window_set_skip_taskbar_hint (GtkWindow *window,
                                  gboolean setting);

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

С версии: 2.2

gtk_window_set_skip_pager_hint ()

void
gtk_window_set_skip_pager_hint (GtkWindow *window,
                                gboolean setting);

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

С версии: 2.2

gtk_window_set_urgency_hint ()

void
gtk_window_set_urgency_hint (GtkWindow *window,
                             gboolean setting);

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

С версии: 2.8

gtk_window_set_accept_focus ()

void
gtk_window_set_accept_focus (GtkWindow *window,
                             gboolean setting);

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

С: 2.4

gtk_window_set_focus_on_map ()

void
gtk_window_set_focus_on_map (GtkWindow *window,
                             gboolean setting);

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

С: 2.6

gtk_window_set_startup_id ()

void
gtk_window_set_startup_id (GtkWindow *window,
                           const gchar *startup_id);

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

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

С: 2.12

gtk_window_set_role ()

void
gtk_window_set_role (GtkWindow *window,
                     const gchar *role);

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

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

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

gtk_window_get_decorated ()

gboolean
gtk_window_get_decorated (GtkWindow *window);

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

gtk_window_get_deletable ()

gboolean
gtk_window_get_deletable (GtkWindow *window);

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

С: 2.10

gtk_window_get_default_icon_list ()

GList *
gtk_window_get_default_icon_list (void);

Получает значение, установленное с помощью gtk_window_set_default_icon_list(). Список является копией и должен быть освобожден с помощью g_list_free(), но pixbuфы в списке не имели своего счетчика ссылок, увеличенного.

gtk_window_get_default_icon_name ()

const gchar *
gtk_window_get_default_icon_name (void);

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

С: 2.16

gtk_window_get_default_size ()

void
gtk_window_get_default_size (GtkWindow *window,
                             gint *width,
                             gint *height);

Получает размер окна по умолчанию. Значение -1 для ширины или высоты указывает, что размер по умолчанию для этого измерения явно не задан, поэтому будет использован «естественный» размер окна.

gtk_window_get_destroy_with_parent ()

gboolean
gtk_window_get_destroy_with_parent (GtkWindow *window);

Возвращает, будет ли окно уничтожено вместе со своим временным родителем. См. gtk_window_set_destroy_with_parent().

gtk_window_get_hide_titlebar_when_maximized ()

gboolean
gtk_window_get_hide_titlebar_when_maximized
                               (GtkWindow *window);

Возвращает, запрошено ли скрытие панели заголовков окна при максимизации. См. gtk_window_set_hide_titlebar_when_maximized().

С: 3.4

gtk_window_get_icon ()

GdkPixbuf *
gtk_window_get_icon (GtkWindow *window);

Получает значение, установленное с помощью gtk_window_set_icon() (или, если вы вызвали gtk_window_set_icon_list(), получает первый значок в списке значков).

gtk_window_get_icon_list ()

GList *
gtk_window_get_icon_list (GtkWindow *window);

Извлекает список значков, установленных с помощью gtk_window_set_icon_list(). Список копируется, но счетчик ссылок каждого элемента не увеличивается.

gtk_window_get_icon_name ()

const gchar *
gtk_window_get_icon_name (GtkWindow *window);

Возвращает имя тематического значка для окна, см. gtk_window_set_icon_name().

С: 2.6

gtk_window_get_mnemonic_modifier ()

GdkModifierType
gtk_window_get_mnemonic_modifier (GtkWindow *window);

Возвращает модификатор мнемоники для этого окна. См. gtk_window_set_mnemonic_modifier().

gtk_window_get_modal ()

gboolean
gtk_window_get_modal (GtkWindow *window);

Возвращает, является ли окно модальным. См. gtk_window_set_modal().

gtk_window_get_position ()

void
gtk_window_get_position (GtkWindow *window,
                         gint *root_x,
                         gint *root_y);

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

Если вы не изменили направление окна, его направление будет GDK_GRAVITY_NORTH_WEST. Это означает, что gtk_window_get_position() получает положение верхнего левого угла фрейма менеджера окон для окна. gtk_window_move() устанавливает положение этого же верхнего левого угла.

gtk_window_get_position() не является на 100% надежным, поскольку X Window System не определяет способ получения геометрии декораций, размещенных на окне менеджером окон. Таким образом, GTK+ использует «лучшее предположение», которое работает с большинством менеджеров окон.

Кроме того, практически все менеджеры окон исторически некорректно обрабатывают направление окна. Поэтому перемещение окна в его текущую позицию, как возвращается gtk_window_get_position(), имеет тенденцию слегка смещать окно. Менеджеры окон со временем постепенно улучшаются.

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

Если вы сохраняете и восстанавливаете позиции окон своего приложения, вы должны знать, что для приложений это невозможно сделать без некоторой ошибки, потому что приложения не имеют достаточного знания состояния менеджера окон. Правильный механизм заключается в поддержке протокола управления сеансами (см., например, объект «GnomeClient» в библиотеках GNOME) и разрешении менеджеру окон сохранять размеры и позиции ваших окон.

gtk_window_get_role ()

const gchar *
gtk_window_get_role (GtkWindow *window);

Возвращает роль окна. См. gtk_window_set_role() для получения дополнительной информации.

gtk_window_get_size ()

void
gtk_window_get_size (GtkWindow *window,
                     gint *width,
                     gint *height);

Получает текущий размер window. Если window не находится на экране, возвращает размер, который GTK+ предложит диспетчеру окон для начального размера окна (но это не гарантированно совпадает с размером, который диспетчер окон фактически выберет). Размер, полученный с помощью диспетчера окон gtk_window_get_size(), — это последний размер, полученный в событии GdkEventConfigure, то есть GTK+ использует локально сохранённый размер, а не запрашивает размер у сервера X. В результате, если вы вызываете gtk_window_resize(), а затем сразу же gtk_window_get_size(), размер ещё не примет нового значения. После обработки диспетчером окон запроса на изменение размера GTK+ получает уведомление о том, что размер изменился, через событие переконфигурации, и размер окна обновляется.

Примечание 1: Почти любое использование этой функции создаёт гонку, поскольку размер окна может измениться между моментом получения размера и моментом выполнения действия, предполагающего, что размер — текущий. Чтобы избежать гонок, подключайтесь к событию «configure-event» окна и корректируйте зависящие от размера состояния, чтобы соответствовать размеру, переданному в событии GdkEventConfigure.

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

Примечание 3: Если вы получаете размер окна для его позиционирования на экране, может быть лучший способ. Предпочтительный способ — просто установить семантический тип окна с помощью gtk_window_set_type_hint(), что позволяет диспетчеру окон, например, центрировать диалоговые окна. Также, если вы устанавливаете временного родителя диалоговых окон с помощью gtk_window_set_transient_for(), диспетчеры окон часто центрируют диалоговое окно над родительским окном. Гораздо предпочтительнее позволить диспетчеру окон обрабатывать эти вещи, а не делать это самостоятельно, поскольку все приложения будут вести себя согласованно и в соответствии с пользовательскими предпочтениями, если это обрабатывает диспетчер окон. Кроме того, диспетчер окон может учитывать размер декораций/границ окна, в то время как ваше приложение не может.

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

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

gtk_window_get_title ()

const gchar *
gtk_window_get_title (GtkWindow *window);

Получает заголовок окна. См. gtk_window_set_title().

gtk_window_get_transient_for ()

GtkWindow *
gtk_window_get_transient_for (GtkWindow *window);

Получает временного родителя для этого окна. См. gtk_window_set_transient_for().

gtk_window_get_attached_to ()

GtkWidget *
gtk_window_get_attached_to (GtkWindow *window);

Получает виджет, к которому прикреплено это окно. См. gtk_window_set_attached_to().

С: 3.4

gtk_window_get_type_hint ()

GdkWindowTypeHint
gtk_window_get_type_hint (GtkWindow *window);

Получает подсказку типа для этого окна. См. gtk_window_set_type_hint().

gtk_window_get_skip_taskbar_hint ()

gboolean
gtk_window_get_skip_taskbar_hint (GtkWindow *window);

Получает значение, заданное с помощью gtk_window_set_skip_taskbar_hint()

С: 2.2

gtk_window_get_skip_pager_hint ()

gboolean
gtk_window_get_skip_pager_hint (GtkWindow *window);

Получает значение, заданное с помощью gtk_window_set_skip_pager_hint().

С: 2.2

gtk_window_get_urgency_hint ()

gboolean
gtk_window_get_urgency_hint (GtkWindow *window);

Получает значение, установленное функцией gtk_window_set_urgency_hint()

С: 2.8

gtk_window_get_accept_focus ()

gboolean
gtk_window_get_accept_focus (GtkWindow *window);

Получает значение, установленное функцией gtk_window_set_accept_focus().

С: 2.4

gtk_window_get-focus-on-map ()

gboolean
gtk_window_get_focus_on_map (GtkWindow *window);

Получает значение, установленное функцией gtk_window_set_focus_on_map().

С: 2.6

gtk_window_get_group ()

GtkWindowGroup *
gtk_window_get_group (GtkWindow *window);

Возвращает группу для window или группу по умолчанию, если window равна NULL или если у window нет явной группы окон.

С: 2.10

gtk_window_has_group ()

gboolean
gtk_window_has_group (GtkWindow *window);

Возвращает, имеет ли window явную группу окон.

gtk_window_get_window_type ()

GtkWindowType
gtk_window_get_window_type (GtkWindow *window);

Получает тип окна. Смотрите GtkWindowType.

С: 2.20

gtk_window_move ()

void
gtk_window_move (GtkWindow *window,
                 gint x,
                 gint y);

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

Примечание: позиция — это позиция определяемой гравитацией опорной точки окна. Гравитация определяет два аспекта: во-первых, расположение опорной точки в координатах окна корня; во-вторых, какая точка на окне расположена в опорной точке.

По умолчанию гравитация — GDK_GRAVITY_NORTH_WEST, поэтому опорная точка — это просто x , y, переданные в gtk_window_move(). Левый верхний угол декораций окна (рамка или граница) будет расположен в x , y. Поэтому, чтобы расположить окно в левом верхнем углу экрана, необходимо использовать гравитацию по умолчанию (которая является GDK_GRAVITY_NORTH_WEST) и переместить окно в 0,0.

Чтобы расположить окно в правом нижнем углу экрана, необходимо установить GDK_GRAVITY_SOUTH_EAST, что означает, что опорная точка находится в x + ширина окна и y + высота окна, а правый нижний угол границы окна будет расположен в этой опорной точке. Таким образом, чтобы расположить окно в правом нижнем углу, сначала установите гравитацию на юго-восток, а затем напишите: gtk_window_move (window, gdk_screen_width() - window_width, gdk_screen_height() - window_height) (обратите внимание, что этот пример не учитывает многоголовые сценарии).

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

Документация gtk_window_get_position() также может быть полезной.

gtk_window_parse_geometry ()

gboolean
gtk_window_parse_geometry (GtkWindow *window,
                           const gchar *geometry);

Разбирает строку геометрии стандартной системы окон X Window System — см. руководство по X (наберите «man X») для получения подробной информации. gtk_window_parse_geometry() работает на всех портах GTK+, включая Win32, но предназначена в первую очередь для X-среды.

Если из строки геометрии можно извлечь размер или позицию, gtk_window_parse_geometry() возвращает TRUE и вызывает gtk_window_set_default_size() и/или gtk_window_move() для изменения размера/перемещения окна.

Если gtk_window_parse_geometry() возвращает TRUE, она также установит подсказки GDK_HINT_USER_POS и/или GDK_HINT_USER_SIZE, указывающие менеджеру окон, что размер/позиция окна были заданы пользователем. Это заставляет большинство менеджеров окон учитывать геометрию.

Обратите внимание, что для корректной работы gtk_window_parse_geometry() ее необходимо вызывать, когда у окна есть «окончательный» размер, т. е. после вызова gtk_widget_show_all() для содержимого и gtk_window_set_geometry_hints() для окна.

<object class="GtkWindow">
  <accel-groups>
    <group name="accelgroup1"/>
  </accel-groups>
  <initial-focus name="thunderclap"/>
</object>

...

<object class="GtkAccelGroup" id="accelgroup1"/>

gtk_window_reshow_with_initial_size ()

void
gtk_window_reshow_with_initial_size (GtkWindow *window);

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

gtk_window_resize ()

void
gtk_window_resize (GtkWindow *window,
                   gint width,
                   gint height);

Изменяет размер окна так, как если бы это сделал пользователь, учитывая ограничения геометрии. Ограничение геометрии по умолчанию состоит в том, что окна не могут быть меньше, чем запрашиваемый размер; чтобы изменить это ограничение, вызовите gtk_widget_set_size_request(), чтобы установить запрос на меньшее значение.

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

Окна не могут быть изменены меньше 1 на 1 пикселя.

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

Как правило, gtk_window_resize() будет компенсировать высоту GtkHeaderBar только в том случае, если она известна в момент выдачи конфигурации GtkWindow. Например, если после конфигурации GtkWindow добавляются новые виджеты и это приводит к увеличению высоты GtkHeaderBar, это приведет к содержимому окна меньше, чем указано в gtk_window_resize(), а не к большему окну.

gtk_window_resize_to_geometry ()

void
gtk_window_resize_to_geometry (GtkWindow *window,
                               gint width,
                               gint height);

Подобно gtk_window_resize(), но width и height интерпретируются относительно базового размера и приращения, установленных с помощью gtk_window_set_geometry_hints.

С версии: 3.0

gtk_window_set_default_icon_list ()

void
gtk_window_set_default_icon_list (GList *list);

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

См. gtk_window_set_icon_list() для получения более подробной информации.

gtk_window_set_default_icon ()

void
gtk_window_set_default_icon (GdkPixbuf *icon);

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

С версии: 2.4

gtk_window_set_default_icon_from_file ()

gboolean
gtk_window_set_default_icon_from_file (const gchar *filename,
                                       GError **err);

Устанавливает значок в качестве резервного для окон, для которых не был вызван gtk_window_set_icon_list() из файла на диске. Выводит предупреждение об ошибке, если err равен NULL.

С версии: 2.2

gtk_window_set_default_icon_name ()

void
gtk_window_set_default_icon_name (const gchar *name);

Устанавливает значок в качестве резервного для окон, для которых не был вызван gtk_window_set_icon_list() из именованного значка темы, см. gtk_window_set_icon_name().

С версии: 2.6

gtk_window_set_icon ()

void
gtk_window_set_icon (GtkWindow *window,
                     GdkPixbuf *icon);

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

Значок должен быть предоставлен в естественном размере; не масштабируйте изображение перед передачей его в GTK+. Масштабирование откладывается до последнего момента, когда известен желаемый окончательный размер, для обеспечения наилучшего качества.

Если ваш значок нарисован вручную в нескольких размерах, используйте gtk_window_set_icon_list(). Тогда будет использован наилучший размер.

Эта функция эквивалентна вызову gtk_window_set_icon_list() со списком из одного элемента.

См. также gtk_window_set_default_icon_list() для установки значка для всех окон вашего приложения за один раз.

gtk_window_set_icon_list ()

void
gtk_window_set_icon_list (GtkWindow *window,
                          GList *list);

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

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

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

Рекомендуемые размеры для предоставления: как минимум 16x16, 32x32, 48x48, а также более крупные изображения (64x64, 128x128), если они у вас есть.

См. также gtk_window_set_default_icon_list() для установки значка для всех окон вашего приложения за один раз.

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

gtk_window_set_icon_from_file ()

gboolean
gtk_window_set_icon_from_file (GtkWindow *window,
                               const gchar *filename,
                               GError **err);

Устанавливает значок для window. Выводит предупреждение об ошибке, если err равен NULL.

Эта функция эквивалентна вызову gtk_window_set_icon() с созданным pixbuf, загружая изображение из filename.

С версии: 2.2

gtk_window_set_icon_name ()

void
gtk_window_set_icon_name (GtkWindow *window,
                          const gchar *name);

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

Обратите внимание, что это не имеет ничего общего со свойством WM_ICON_NAME, упомянутым в ICCCM.

С версии: 2.6

gtk_window_set_auto_startup_notification ()

void
gtk_window_set_auto_startup_notification
                               (gboolean setting);

По умолчанию после показа первого окна GtkWindow GTK+ вызывает gdk_notify_startup_complete(). Используйте эту функцию для отключения автоматического уведомления о запуске. Вы можете сделать это, если ваше первое окно — это стартовое окно, и вы хотите отложить уведомление до тех пор, пока не будет показано ваше основное окно, например.

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

С версии: 2.2

gtk_window_get_opacity ()

gdouble
gtk_window_get_opacity (GtkWindow *window);

Извлекает запрошенную непрозрачность для этого окна. См. gtk_window_set_opacity().

С версии: 2.12

gtk_window_set_opacity ()

void
gtk_window_set_opacity (GtkWindow *window,
                        gdouble opacity);

Запрашивает у оконной системы сделать window частично прозрачным с непрозрачностью 0 (полностью прозрачный) и 1 (полностью непрозрачный). (Значения параметра непрозрачности ограничены диапазоном [0,1].) В X11 это имеет какой-либо эффект только на X-экранах с запущенным менеджером композиции. См. gtk_widget_is_composited(). На Windows это должно работать всегда.

Обратите внимание, что установка непрозрачности окна после того, как окно было показано, вызывает мерцание один раз в Windows.

С версии: 2.12

gtk_window_get_mnemonics_visible ()

gboolean
gtk_window_get_mnemonics_visible (GtkWindow *window);

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

С версии: 2.20

gtk_window_set_mnemonics_visible ()

void
gtk_window_set_mnemonics_visible (GtkWindow *window,
                                  gboolean setting);

Устанавливает свойство “mnemonics-visible”.

С версии: 2.20

gtk_window_get_focus-visible ()

gboolean
gtk_window_get_focus_visible (GtkWindow *window);

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

С версии: 3.2

gtk_window_set-focus-visible ()

void
gtk_window_set_focus_visible (GtkWindow *window,
                              gboolean setting);

Устанавливает свойство “focus-visible”.

С версии: 3.2

gtk_window_set_has-resize-grip ()

void
gtk_window_set_has_resize_grip (GtkWindow *window,
                                gboolean value);

Устанавливает, имеет ли window маркер изменения размера в углу.

Обратите внимание, что маркер изменения размера отображается только если окно на самом деле изменяет размер и не максимизировано. Используйте gtk_window_resize_grip_is_visible() для определения, отображается ли маркер изменения размера.

С версии: 3.0

gtk_window_get_has-resize-grip ()

gboolean
gtk_window_get_has_resize_grip (GtkWindow *window);

Определяет, может ли окно иметь маркер изменения размера.

С версии: 3.0

gtk_window_resize-grip-is-visible ()

gboolean
gtk_window_resize_grip_is_visible (GtkWindow *window);

Определяет, отображается ли маркер изменения размера для указанного окна.

С версии: 3.0

gtk_window_get-resize-grip-area ()

gboolean
gtk_window_get_resize_grip_area (GtkWindow *window,
                                 GdkRectangle *rect);

Если у окна есть маркер изменения размера, это позволит получить позицию, ширину и высоту маркера в указанный GdkRectangle.

С версии: 3.0

gtk_window_get_application ()

GtkApplication *
gtk_window_get_application (GtkWindow *window);

Получает связанное с окном (если есть) приложение GtkApplication.

С момента: 3.0

gtk_window_set_application ()

void
gtk_window_set_application (GtkWindow *window,
                            GtkApplication *application);

Устанавливает или сбрасывает связанное с окном приложение GtkApplication.

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

С момента: 3.0

gtk_window_set_has_user_ref_count ()

void
gtk_window_set_has_user_ref_count (GtkWindow *window,
                                   gboolean setting);

Сообщает GTK+, нужно ли снимать дополнительную ссылку на окно при вызове gtk_widget_destroy().

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

С момента: 3.0

gtk_window_set_titlebar ()

void
gtk_window_set_titlebar (GtkWindow *window,
                         GtkWidget *titlebar);

Устанавливает пользовательскую строку заголовка для window.

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

С момента: 3.10

gtk_window_get_titlebar ()

GtkWidget *
gtk_window_get_titlebar (GtkWindow *window);

Возвращает пользовательскую строку заголовка, установленную с помощью gtk_window_set_titlebar().

С момента: 3.16

gtk_window_set_interactive_debugging ()

void
gtk_window_set_interactive_debugging (gboolean enable);

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

С момента: 3.14

Свойство “accept-focus”

  “accept-focus”             gboolean

Должен ли получать фокус ввода.

Флаги: Чтение / Запись

Значение по умолчанию: TRUE

С версии: 2.4

Свойство “application”

  “application”              GtkApplication *

Ассоциированный с окном GtkApplication.

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

Обычно связь между приложением и окном сохраняется до закрытия окна, но вы можете её явно разорвать, установив свойство :application в NULL.

Флаги: Чтение / Запись

С версии: 3.0

Свойство “attached-to”

  “attached-to”              GtkWidget *

Виджет, к которому прикреплено это окно. См. gtk_window_set_attached_to().

Примеры, где полезно указать эту связь: GtkMenu, созданный GtkComboBox, всплывающее окно автодополнения, созданное GtkEntry, или окно поиска по автодополнению, созданное GtkTreeView.

Флаги: Чтение / Запись / Создание

С версии: 3.4

Свойство “decorated”

  “decorated”                gboolean

Должно ли окно иметь оформление от менеджера окон.

Флаги: Чтение / Запись

Значение по умолчанию: TRUE

С версии: 2.4

Свойство “default-height”

  “default-height”           gint

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

Флаги: Чтение / Запись

Допустимые значения: >= -1

Значение по умолчанию: -1

Свойство “default-width”

  “default-width”            gint

Ширина окна по умолчанию, используемая при первоначальном отображении окна.

Флаги: Чтение / Запись

Допустимые значения: >= -1

Значение по умолчанию: -1

Свойство “deletable”

  “deletable”                gboolean

Должен ли иметь кнопку закрытия.

Флаги: Чтение / Запись

Значение по умолчанию: TRUE

С версии: 2.10

Свойство “destroy-with-parent”

  “destroy-with-parent”      gboolean

Должно ли окно быть уничтожено при уничтожении родительского.

Флаги: Чтение / Запись

Значение по умолчанию: FALSE

Свойство “focus-on-map”

  “focus-on-map”             gboolean

Должно ли окно получить фокус ввода при отображении.

Флаги: Чтение / Запись

Значение по умолчанию: TRUE

С версии: 2.6

Свойство “focus-visible”

  “focus-visible”            gboolean

Видимость прямоугольников фокуса в этом окне.

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

Флаги: Чтение / Запись

Значение по умолчанию: TRUE

С версии: 2.20

Свойство “gravity”

  “gravity”                  GdkGravity

Направление тяготения окна. См. gtk_window_move() и GdkGravity для более подробной информации о направлении тяготения окна.

Флаги: Чтение / Запись

Значение по умолчанию: GDK_GRAVITY_NORTH_WEST

С версии: 2.4

Свойство “has-resize-grip”

  “has-resize-grip”          gboolean

Наличие угловой точки изменения размера.

Обратите внимание, что точка изменения размера отображается только если окно действительно изменяет размеры и не максимизировано. Используйте “resize-grip-visible”, чтобы узнать, отображается ли точка изменения размера в данный момент.

Флаги: Чтение / Запись

Значение по умолчанию: FALSE

С версии: 3.0

Свойство “has-toplevel-focus”

  “has-toplevel-focus”       gboolean

Находится ли фокус ввода внутри этого GtkWindow.

Флаги: Чтение

Значение по умолчанию: FALSE

Свойство “hide-titlebar-when-maximized”

  “hide-titlebar-when-maximized” gboolean

Должна ли строка заголовка скрываться при максимизации.

Флаги: Чтение / Запись

Значение по умолчанию: FALSE

С версии: 3.4

Свойство “icon”

  “icon”                     GdkPixbuf *

Иконка для этого окна.

Флаги: Чтение / Запись

Свойство “icon-name”

  “icon-name”                gchar *

Свойство :icon-name указывает имя тематической иконки, используемой в качестве значка окна. См. GtkIconTheme для более подробной информации.

Флаги: Чтение / Запись

Значение по умолчанию: NULL

С версии: 2.6

Свойство “is-active”

  “is-active”                gboolean

Является ли окно активным в данный момент.

Флаги: Чтение

Значение по умолчанию: FALSE

Свойство “is-maximized”

  “is-maximized”             gboolean

Максимизировано ли окно.

Флаги: Чтение

Значение по умолчанию: FALSE

Свойство “mnemonics-visible”

  “mnemonics-visible”        gboolean

Видимость мнемоник в этом окне.

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

Флаги: Чтение / Запись

Значение по умолчанию: TRUE

С версии: 2.20

Свойство “modal”

  “modal”                    gboolean

Если TRUE, окно модальное (другие окна недоступны, пока это окно открыто).

Флаги: Чтение / Запись

Значение по умолчанию: FALSE

Свойство “resizable”

  “resizable”                gboolean

Можно ли изменять размер окна.

Флаги: Чтение / Запись

Значение по умолчанию: TRUE

Свойство “resize-grip-visible”

  “resize-grip-visible”      gboolean

Видимость угловой точки изменения размера.

Флаги: Чтение

Значение по умолчанию: FALSE

С версии: 3.0

Свойство “role”

  “role”                     gchar *

Уникальный идентификатор окна для восстановления сеанса.

Флаги: Чтение / Запись

Значение по умолчанию: NULL

Свойство “screen”

  “screen”                   GdkScreen *

Экран, на котором будет отображаться это окно.

Флаги: Чтение / Запись

Свойство “skip-pager-hint”

  “skip-pager-hint”          gboolean

TRUE, если окно не должно быть в просмотре страниц.

Флаги: Чтение / Запись

Значение по умолчанию: FALSE

Свойство “skip-taskbar-hint”

  “skip-taskbar-hint”        gboolean

TRUE, если окно не должно быть в панели задач.

Флаги: Чтение / Запись

Значение по умолчанию: FALSE

Свойство “startup-id”

  “startup-id”               gchar *

Свойство :startup-id — это свойство только для записи, используемое для установки идентификатора уведомления о запуске окна. См. gtk_window_set_startup_id() для более подробной информации.

Флаги: Запись

Значение по умолчанию: NULL

С версии: 2.12

Свойство “title”

  “title”                    gchar *

Заголовок окна.

Флаги: Чтение / Запись

Значение по умолчанию: NULL

Свойство “transient-for”

  “transient-for”            GtkWindow *

Родительское окно-запрос. См. gtk_window_set_transient_for() для более подробной информации о запросах.

Флаги: Чтение / Запись / Создание

С версии: 2.10

Свойство “type”

  “type”                     GtkWindowType

Тип окна.

Флаги: Чтение / Запись / Создание

Значение по умолчанию: GTK_WINDOW_TOPLEVEL

Свойство “type-hint”

  “type-hint”                GdkWindowTypeHint

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

Флаги: Чтение / Запись

Значение по умолчанию: GDK_WINDOW_TYPE_HINT_NORMAL

Свойство “urgency-hint”

  “urgency-hint”             gboolean

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

Флаги: Чтение / Запись

Значение по умолчанию: ЛОЖЬ

Свойство “window-position”

  “window-position”          GtkWindowPosition

Начальное положение окна.

Флаги: Чтение / Запись

Значение по умолчанию: GTK_WIN_POS_NONE