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

Не используйте эту функцию. Она устанавливает подсказки «class» и «name» системы 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);

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

С момента: 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), а затем unref все виджеты после этого.

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.

Since: 2.2

gtk_window_fullscreen_on_monitor ()

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

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

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

Since: 3.18

gtk_window_unfullscreen ()

void
gtk_window_unfullscreen (GtkWindow *window);

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

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

Since: 2.2

gtk_window_set_keep_above ()

void
gtk_window_set_keep_above (GtkWindow *window,
                           gboolean setting);

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

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

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

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

Since: 2.4

gtk_window_set_keep_below ()

void
gtk_window_set_keep_below (GtkWindow *window,
                           gboolean setting);

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

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

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

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

Since: 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 эта функция всегда работает, так как нет политики менеджера окон.

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

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

Since: 2.2

gtk_window_set_skip_pager_hint ()

void
gtk_window_set_skip_pager_hint (GtkWindow *window,
                                gboolean setting);

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

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

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

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

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(), но пикбуферы в списке не имели увеличенного счётчика ссылок.

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

Надёжность этой функции зависит от используемой в данный момент системы окон. Некоторые системы окон, такие как 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().

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

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

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

С: 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