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.

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

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

gtk_window_present_with_time ()

void
gtk_window_present_with_time (GtkWindow *window,
                              guint32 timestamp);

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

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

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

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

Since: 2.4

gtk_window_set_focus_on_map ()

void
gtk_window_set_focus_on_map (GtkWindow *window,
                             gboolean setting);

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

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

Since: 2.12

gtk_window_set_role ()

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

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

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

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

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

Since: 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(), но пиксы в списке не увеличили свой счётчик ссылок.

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

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

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

Since: 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() для получения более подробной информации.

Надёжность этой функции зависит от используемой в настоящее время системы окон. Некоторые системы окон, такие как Wayland, не поддерживают глобальную систему координат, и поэтому положение окна всегда будет (0, 0). Другие, такие как X11, не имеют надёжного способа получения геометрии декораций окна, если они предоставляются менеджером окон. Кроме того, на X11 менеджеры окон известны тем, что неправильно обрабатывают гравитацию окон, что приводит к перемещению окон, даже если вы используете координаты текущего положения, возвращаемые этой функцией.

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

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

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

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

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

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

приведёт к тому, что new_width и new_height соответствуют width и height, соответственно.

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

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

Чтобы избежать потенциальных гонок, вы должны вызывать эту функцию только в ответ на уведомление о изменении размера, например, внутри обработчика сигнала “size-allocate” или внутри обработчика сигнала “configure-event”:

Обратите внимание, что если вы подключаетесь к сигналу “size-allocate”, вам не следует использовать размеры GtkAllocation, передаваемые обработчику сигнала, так как выделение может содержать декорации клиентской стороны, добавленные GTK+, в зависимости от используемой системного интерфейса окон.

Если вы получаете размер окна для позиционирования окна на экране, вы должны просто установить семантический тип окна с помощью gtk_window_set_type_hint(), что позволяет менеджеру окон, например, центрировать диалоговые окна. Кроме того, если вы устанавливаете транзиентного родителя диалоговых окон с помощью gtk_window_set_transient_for(), менеджеры окон часто центрируют диалоговое окно над его родительским окном. Намного предпочтительнее позволить менеджеру окон обрабатывать эти случаи, а не делать это самостоятельно, потому что все приложения будут вести себя последовательно и в соответствии с пользовательскими или системными предпочтениями, если менеджер окон обрабатывает это. Кроме того, менеджер окон может учитывать размер декораций и рамки окна, которые он может добавить, и о которых GTK+ не знает. Кроме того, позиционирование окон в глобальных координатах экрана может быть запрещено системным интерфейсом окон. Более подробная информация: 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().

Если у GtkWindow есть виджет панели заголовка (см. gtk_window_set_titlebar()), то обычно gtk_window_resize() будет компенсировать только высоту виджета панели заголовка, только если высота известна, когда выдаётся конфигурация GtkWindow. Например, если после конфигурации GtkWindow будут добавлены новые виджеты, которые приведут к увеличению высоты виджета панели заголовка, это приведёт к содержанию окна, меньшему, чем указано в 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.

Since: 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() из pixbuf.

Since: 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() с пиксел-буфером, созданным путём загрузки изображения из 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 с окном.

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

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

Это эквивалентно вызову gtk_application_remove_window() и/или gtk_application_add_window() для старого/нового приложения, по необходимости.

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

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

С: 3.0

gtk_window_set_titlebar ()

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

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

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

Если вы устанавливаете пользовательскую панель заголовка, 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

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

Владелец: GtkWindow

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

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

С версии: 2.4

Свойство “application”

  “application”              GtkApplication *

Объект GtkApplication, связанный с окном.

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

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

Владелец: GtkWindow

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

С версии: 3.0

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

  “attached-to”              GtkWidget *

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

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

Владелец: GtkWindow

Флаги: Чтение / Запись / Конструктор

С версии: 3.4

Свойство “decorated”

  “decorated”                gboolean

Должно ли окно быть декорировано менеджером окон.

Владелец: GtkWindow

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

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

С версии: 2.4

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

  “default-height”           int

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

Владелец: GtkWindow

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

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

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

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

  “default-width”            int

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

Владелец: GtkWindow

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

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

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

Свойство “deletable”

  “deletable”                gboolean

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

Владелец: GtkWindow

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

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

С версии: 2.10

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

  “destroy-with-parent”      gboolean

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

Владелец: GtkWindow

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

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

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

  “focus-on-map”             gboolean

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

Владелец: GtkWindow

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

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

С версии: 2.6

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

  “focus-visible”            gboolean

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

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

Владелец: GtkWindow

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

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

С версии: 2.20

Свойство “gravity”

  “gravity”                  GdkGravity

Сила тяжести окна. См. gtk_window_move() и GdkGravity для получения дополнительной информации о силе тяжести окна.

Владелец: GtkWindow

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

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

С версии: 2.4

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

  “has-resize-grip”          gboolean

Есть ли у окна зацеп для изменения размера в углу.

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

Владелец: GtkWindow

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

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

С версии: 3.0

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

  “has-toplevel-focus”       gboolean

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

Владелец: GtkWindow

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

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

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

  “hide-titlebar-when-maximized” gboolean

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

Владелец: GtkWindow

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

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

С версии: 3.4

Свойство “icon”

  “icon”                     GdkPixbuf *

Значок для этого окна.

Владелец: GtkWindow

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

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

  “icon-name”                char *

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

Владелец: GtkWindow

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

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

С версии: 2.6

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

  “is-active”                gboolean

Является ли это окно текущим активным окном.

Владелец: GtkWindow

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

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

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

  “is-maximized”             gboolean

Развернуто ли окно на весь экран.

Владелец: GtkWindow

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

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

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

  “mnemonics-visible”        gboolean

Видимы ли в данный момент мнемоники в этом окне.

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

Владелец: GtkWindow

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

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

С версии: 2.20

Свойство “modal”

  “modal”                    gboolean

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

Владелец: GtkWindow

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

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

Свойство “resizable”

  “resizable”                gboolean

Если TRUE, пользователи могут изменять размер окна.

Владелец: GtkWindow

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

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

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

  “resize-grip-visible”      gboolean

Отображается ли в данный момент зацеп для изменения размера в углу.

Владелец: GtkWindow

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

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

С версии: 3.0

Свойство “role”

  “role”                     char *

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

Владелец: GtkWindow

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

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

Свойство “screen”

  “screen”                   GdkScreen *

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

Владелец: GtkWindow

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

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

  “skip-pager-hint”          gboolean

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

Владелец: GtkWindow

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

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

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

  “skip-taskbar-hint”        gboolean

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

Владелец: GtkWindow

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

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

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

  “startup-id”               char *

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

Владелец: GtkWindow

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

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

С версии: 2.12

Свойство “title”

  “title”                    char *

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

Владелец: GtkWindow

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

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

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

  “transient-for”            GtkWindow *

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

Владелец: GtkWindow

Флаги: Чтение / Запись / Конструктор

С версии: 2.10

Свойство “type”

  “type”                     GtkWindowType

Тип окна.

Владелец: GtkWindow

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

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

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

  “type-hint”                GdkWindowTypeHint

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

Владелец: GtkWindow

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

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

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

  “urgency-hint”             gboolean

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

Владелец: GtkWindow

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

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

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

  “window-position”          GtkWindowPosition

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

Владелец: GtkWindow

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

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