GtkWindow

gtk_window_new ()

GtkWidget *
gtk_window_new (void);

Создаёт новый GtkWindow, который является главным окном, содержащим другие виджеты.

Чтобы получить окно без оформления (без рамок окна), используйте gtk_window_set_decorated().

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

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

gtk_window_destroy ()

void
gtk_window_destroy (GtkWindow *window);

Освобождает внутреннюю ссылку GTK на главные окна.

gtk_window_get_child ()

GtkWidget *
gtk_window_get_child (GtkWindow *window);

Получает дочерний виджет window.

gtk_window_set_child ()

void
gtk_window_set_child (GtkWindow *window,
                      GtkWidget *child);

Устанавливает дочерний виджет window.

gtk_window_set_title ()

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

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

Передача NULL эквивалентна установке пустой строки в качестве заголовка.

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_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,
                             int width,
                             int height);

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

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

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

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

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

gtk_window_set_hide_on_close ()

void
gtk_window_set_hide_on_close (GtkWindow *window,
                              gboolean setting);

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

gtk_window_get_hide_on_close ()

gboolean
gtk_window_get_hide_on_close (GtkWindow *window);

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

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 сбрасывает текущее транзитивное окно.

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

gtk_window_set_destroy_with_parent ()

void
gtk_window_set_destroy_with_parent (GtkWindow *window,
                                    gboolean setting);

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

gtk_window_set_display ()

void
gtk_window_set_display (GtkWindow *window,
                        GdkDisplay *display);

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

gtk_window_is_active ()

gboolean
gtk_window_is_active (GtkWindow *window);

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

gtk_window_is_maximized ()

gboolean
gtk_window_is_maximized (GtkWindow *window);

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

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

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

gtk_window_is_fullscreen ()

gboolean
gtk_window_is_fullscreen (GtkWindow *window);

Получает текущее состояние полноэкранного режима window.

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

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

gtk_window_get_toplevels ()

GListModel *
gtk_window_get_toplevels (void);

Возвращает список всех существующих окон верхнего уровня.

Если вы хотите перебирать список и выполнять действия, связанные с обратными вызовами, которые могут уничтожать виджеты или добавлять новые, имейте в виду, что список окон верхнего уровня будет меняться и будет испускаться сигнал "items-changed".

gtk_window_list_toplevels ()

GList *
gtk_window_list_toplevels (void);

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

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

gtk_window_set_default_widget ()

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

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

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

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

gtk_window_close ()

void
gtk_window_close (GtkWindow *window);

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

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

gtk_window_minimize ()

void
gtk_window_minimize (GtkWindow *window);

Запрашивает сворачивание указанного window .

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

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

Вы можете отслеживать результат этой операции с помощью свойства “state”.

gtk_window_unminimize ()

void
gtk_window_unminimize (GtkWindow *window);

Запрашивает разворачивание указанного window .

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

Вы можете отслеживать результат этой операции с помощью свойства “state”.

gtk_window_maximize ()

void
gtk_window_maximize (GtkWindow *window);

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

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

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

Вы можете отслеживать результат этой операции с помощью свойства “state” или прослушивая уведомления о свойстве “maximized”.

gtk_window_unmaximize ()

void
gtk_window_unmaximize (GtkWindow *window);

Запрашивает размаксимизацию window .

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

Вы можете отслеживать результат этой операции с помощью свойства “state” или прослушивая уведомления о свойстве “maximized”.

gtk_window_fullscreen ()

void
gtk_window_fullscreen (GtkWindow *window);

Запрашивает перевод window в полноэкранный режим.

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

Вы можете отслеживать результат этой операции с помощью свойства “state” или прослушивая уведомления о свойстве “fullscreened”.

gtk_window_fullscreen_on_monitor ()

void
gtk_window_fullscreen_on_monitor (GtkWindow *window,
                                  GdkMonitor *monitor);

Запрашивает размещение window в полноэкранном режиме на указанном monitor.

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

Вы можете отслеживать результат этой операции с помощью свойства “state” или прослушивая уведомления о свойстве “fullscreened”.

gtk_window_unfullscreen ()

void
gtk_window_unfullscreen (GtkWindow *window);

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

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

Вы можете отслеживать результат этой операции с помощью свойства “state” или прослушивая уведомления о свойстве “fullscreened”.

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

gtk_window_set_startup_id ()

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

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

Эта функция полезна только в 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().

gtk_window_get_default_icon_name ()

const char *
gtk_window_get_default_icon_name (void);

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

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

gtk_window_get_default_size ()

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

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

gtk_window_get_destroy_with_parent ()

gboolean
gtk_window_get_destroy_with_parent (GtkWindow *window);

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

gtk_window_get_icon_name ()

const char *
gtk_window_get_icon_name (GtkWindow *window);

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

gtk_window_get_modal ()

gboolean
gtk_window_get_modal (GtkWindow *window);

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

gtk_window_get_title ()

const char *
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_group ()

GtkWindowGroup *
gtk_window_get_group (GtkWindow *window);

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

gtk_window_has-group ()

gboolean
gtk_window_has_group (GtkWindow *window);

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

gtk_window_set-default-icon-name ()

void
gtk_window_set_default_icon_name (const char *name);

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

gtk_window_set_icon_name ()

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

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

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

gtk_window_set_auto_startup_notification ()

void
gtk_window_set_auto_startup_notification
                               (gboolean setting);

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

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

gtk_window_get_mnemonics_visible ()

gboolean
gtk_window_get_mnemonics_visible (GtkWindow *window);

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

gtk_window_set-mnemonics-visible ()

void
gtk_window_set_mnemonics_visible (GtkWindow *window,
                                  gboolean setting);

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

gtk_window_get_focus-visible ()

gboolean
gtk_window_get_focus_visible (GtkWindow *window);

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

gtk_window_set-focus-visible ()

void
gtk_window_set_focus_visible (GtkWindow *window,
                              gboolean setting);

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

gtk_window_get_application ()

GtkApplication *
gtk_window_get_application (GtkWindow *window);

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

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() для старого/нового приложения, соответственно.

gtk_window_set_titlebar ()

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

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

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

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

gtk_window_get_titlebar ()

GtkWidget *
gtk_window_get_titlebar (GtkWindow *window);

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

gtk_window_set_interactive_debugging ()

void
gtk_window_set_interactive_debugging (gboolean enable);

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