[ новости /+++ | форум | теги | ]

Каталог документации / Раздел "Программирование, языки" / Оглавление документа

Краткое описание

#include <gtk/gtk.h>


            GtkWindow;
GtkWidget*  gtk_window_new                  (GtkWindowType type);
void        gtk_window_set_title            (GtkWindow *window,
                                             const gchar *title);
void        gtk_window_set_wmclass          (GtkWindow *window,
                                             const gchar *wmclass_name,
                                             const gchar *wmclass_class);
void        gtk_window_set_policy           (GtkWindow *window,
                                             gint allow_shrink,
                                             gint allow_grow,
                                             gint auto_shrink);
void        gtk_window_set_resizable        (GtkWindow *window,
                                             gboolean resizable);
gboolean    gtk_window_get_resizable        (GtkWindow *window);
void        gtk_window_add_accel_group      (GtkWindow *window,
                                             GtkAccelGroup *accel_group);
void        gtk_window_remove_accel_group   (GtkWindow *window,
                                             GtkAccelGroup *accel_group);
#define     gtk_window_position
gboolean    gtk_window_activate_focus       (GtkWindow *window);
gboolean    gtk_window_activate_default     (GtkWindow *window);
void        gtk_window_set_modal            (GtkWindow *window,
                                             gboolean modal);
void        gtk_window_set_default_size     (GtkWindow *window,
                                             gint width,
                                             gint height);
void        gtk_window_set_geometry_hints   (GtkWindow *window,
                                             GtkWidget *geometry_widget,
                                             GdkGeometry *geometry,
                                             GdkWindowHints geom_mask);
void        gtk_window_set_gravity          (GtkWindow *window,
                                             GdkGravity gravity);
GdkGravity  gtk_window_get_gravity          (GtkWindow *window);
void        gtk_window_set_position         (GtkWindow *window,
                                             GtkWindowPosition position);
void        gtk_window_set_transient_for    (GtkWindow *window,
                                             GtkWindow *parent);
void        gtk_window_set_destroy_with_parent
                                            (GtkWindow *window,
                                             gboolean setting);
void        gtk_window_set_screen           (GtkWindow *window,
                                             GdkScreen *screen);
GdkScreen*  gtk_window_get_screen           (GtkWindow *window);
gboolean    gtk_window_is_active            (GtkWindow *window);
gboolean    gtk_window_has_toplevel_focus   (GtkWindow *window);
GList*      gtk_window_list_toplevels       (void);
void        gtk_window_add_mnemonic         (GtkWindow *window,
                                             guint keyval,
                                             GtkWidget *target);
void        gtk_window_remove_mnemonic      (GtkWindow *window,
                                             guint keyval,
                                             GtkWidget *target);
gboolean    gtk_window_mnemonic_activate    (GtkWindow *window,
                                             guint keyval,
                                             GdkModifierType modifier);
gboolean    gtk_window_activate_key         (GtkWindow *window,
                                             GdkEventKey *event);
gboolean    gtk_window_propagate_key_event  (GtkWindow *window,
                                             GdkEventKey *event);
GtkWidget*  gtk_window_get_focus            (GtkWindow *window);
void        gtk_window_set_focus            (GtkWindow *window,
                                             GtkWidget *focus);
void        gtk_window_set_default          (GtkWindow *window,
                                             GtkWidget *default_widget);
void        gtk_window_present              (GtkWindow *window);
void        gtk_window_present_with_time    (GtkWindow *window,
                                             guint32 timestamp);
void        gtk_window_iconify              (GtkWindow *window);
void        gtk_window_deiconify            (GtkWindow *window);
void        gtk_window_stick                (GtkWindow *window);
void        gtk_window_unstick              (GtkWindow *window);
void        gtk_window_maximize             (GtkWindow *window);
void        gtk_window_unmaximize           (GtkWindow *window);
void        gtk_window_fullscreen           (GtkWindow *window);
void        gtk_window_unfullscreen         (GtkWindow *window);
void        gtk_window_set_keep_above       (GtkWindow *window,
                                             gboolean setting);
void        gtk_window_set_keep_below       (GtkWindow *window,
                                             gboolean setting);
void        gtk_window_begin_resize_drag    (GtkWindow *window,
                                             GdkWindowEdge edge,
                                             gint button,
                                             gint root_x,
                                             gint root_y,
                                             guint32 timestamp);
void        gtk_window_begin_move_drag      (GtkWindow *window,
                                             gint button,
                                             gint root_x,
                                             gint root_y,
                                             guint32 timestamp);
void        gtk_window_set_decorated        (GtkWindow *window,
                                             gboolean setting);
void        gtk_window_set_deletable        (GtkWindow *window,
                                             gboolean setting);
void        gtk_window_set_frame_dimensions (GtkWindow *window,
                                             gint left,
                                             gint top,
                                             gint right,
                                             gint bottom);
void        gtk_window_set_has_frame        (GtkWindow *window,
                                             gboolean setting);
void        gtk_window_set_mnemonic_modifier
                                            (GtkWindow *window,
                                             GdkModifierType modifier);
void        gtk_window_set_role             (GtkWindow *window,
                                             const gchar *role);
void        gtk_window_set_type_hint        (GtkWindow *window,
                                             GdkWindowTypeHint hint);
void        gtk_window_set_skip_taskbar_hint
                                            (GtkWindow *window,
                                             gboolean setting);
void        gtk_window_set_skip_pager_hint  (GtkWindow *window,
                                             gboolean setting);
void        gtk_window_set_urgency_hint     (GtkWindow *window,
                                             gboolean setting);
void        gtk_window_set_accept_focus     (GtkWindow *window,
                                             gboolean setting);
void        gtk_window_set_focus_on_map     (GtkWindow *window,
                                             gboolean setting);
gboolean    gtk_window_get_decorated        (GtkWindow *window);
gboolean    gtk_window_get_deletable        (GtkWindow *window);
GList*      gtk_window_get_default_icon_list
                                            (void);
void        gtk_window_get_default_size     (GtkWindow *window,
                                             gint *width,
                                             gint *height);
gboolean    gtk_window_get_destroy_with_parent
                                            (GtkWindow *window);
void        gtk_window_get_frame_dimensions (GtkWindow *window,
                                             gint *left,
                                             gint *top,
                                             gint *right,
                                             gint *bottom);
gboolean    gtk_window_get_has_frame        (GtkWindow *window);
GdkPixbuf*  gtk_window_get_icon             (GtkWindow *window);
GList*      gtk_window_get_icon_list        (GtkWindow *window);
gchar*      gtk_window_get_icon_name        (GtkWindow *window);
GdkModifierType gtk_window_get_mnemonic_modifier
                                            (GtkWindow *window);
gboolean    gtk_window_get_modal            (GtkWindow *window);
void        gtk_window_get_position         (GtkWindow *window,
                                             gint *root_x,
                                             gint *root_y);
const gchar* gtk_window_get_role            (GtkWindow *window);
void        gtk_window_get_size             (GtkWindow *window,
                                             gint *width,
                                             gint *height);
const gchar* gtk_window_get_title           (GtkWindow *window);
GtkWindow*  gtk_window_get_transient_for    (GtkWindow *window);
GdkWindowTypeHint gtk_window_get_type_hint  (GtkWindow *window);
gboolean    gtk_window_get_skip_taskbar_hint
                                            (GtkWindow *window);
gboolean    gtk_window_get_skip_pager_hint  (GtkWindow *window);
gboolean    gtk_window_get_urgency_hint     (GtkWindow *window);
gboolean    gtk_window_get_accept_focus     (GtkWindow *window);
gboolean    gtk_window_get_focus_on_map     (GtkWindow *window);
GtkWindowGroup* gtk_window_get_group        (GtkWindow *window);
void        gtk_window_move                 (GtkWindow *window,
                                             gint x,
                                             gint y);
gboolean    gtk_window_parse_geometry       (GtkWindow *window,
                                             const gchar *geometry);
void        gtk_window_reshow_with_initial_size
                                            (GtkWindow *window);
void        gtk_window_resize               (GtkWindow *window,
                                             gint width,
                                             gint height);
void        gtk_window_set_default_icon_list
                                            (GList *list);
void        gtk_window_set_default_icon     (GdkPixbuf *icon);
gboolean    gtk_window_set_default_icon_from_file
                                            (const gchar *filename,
                                             GError **err);
void        gtk_window_set_default_icon_name
                                            (const gchar *name);
void        gtk_window_set_icon             (GtkWindow *window,
                                             GdkPixbuf *icon);
void        gtk_window_set_icon_list        (GtkWindow *window,
                                             GList *list);
gboolean    gtk_window_set_icon_from_file   (GtkWindow *window,
                                             const gchar *filename,
                                             GError **err);
void        gtk_window_set_icon_name        (GtkWindow *window,
                                             const gchar *name);
void        gtk_window_set_auto_startup_notification
                                            (gboolean setting);


void        gtk_decorated_window_init       (GtkWindow *window);
void        gtk_decorated_window_calculate_frame_size
                                            (GtkWindow *window);
void        gtk_decorated_window_set_title  (GtkWindow *window,
                                             const gchar *title);
void        gtk_decorated_window_move_resize_window
                                            (GtkWindow *window,
                                             gint x,
                                             gint y,
                                             gint width,
                                             gint height);

Иерархия объектов

  GObject
   +----GInitiallyUnowned
         +----GtkObject
               +----GtkWidget
                     +----GtkContainer
                           +----GtkBin
                                 +----GtkWindow
                                       +----GtkDialog
                                       +----GtkPlug

Обеспечивающие интерфейсы

GtkWindow обеспечивают AtkImplementorIface.

Свойства

  "accept-focus"         gboolean              : Read / Write
  "allow-grow"           gboolean              : Read / Write
  "allow-shrink"         gboolean              : Read / Write
  "decorated"            gboolean              : Read / Write
  "default-height"       gint                  : Read / Write
  "default-width"        gint                  : Read / Write
  "destroy-with-parent"  gboolean              : Read / Write
  "focus-on-map"         gboolean              : Read / Write
  "gravity"              GdkGravity            : Read / Write
  "has-toplevel-focus"   gboolean              : Read
  "icon"                 GdkPixbuf             : Read / Write
  "icon-name"            gchararray            : Read / Write
  "is-active"            gboolean              : Read
  "modal"                gboolean              : Read / Write
  "resizable"            gboolean              : Read / Write
  "role"                 gchararray            : Read / Write
  "screen"               GdkScreen             : Read / Write
  "skip-pager-hint"      gboolean              : Read / Write
  "skip-taskbar-hint"    gboolean              : Read / Write
  "title"                gchararray            : Read / Write
  "type"                 GtkWindowType         : Read / Write / Construct Only
  "type-hint"            GdkWindowTypeHint     : Read / Write
  "urgency-hint"         gboolean              : Read / Write
  "window-position"      GtkWindowPosition     : Read / Write

Сигналы

"activate-default"
            void        user_function      (GtkWindow *window,
                                            gpointer   user_data)      : Run last / Action
"activate-focus"
            void        user_function      (GtkWindow *window,
                                            gpointer   user_data)      : Run last / Action
"frame-event"
            gboolean    user_function      (GtkWindow *window,
                                            GdkEvent  *event,
                                            gpointer   user_data)      : Run last
"keys-changed"
            void        user_function      (GtkWindow *window,
                                            gpointer   user_data)      : Run first
"move-focus"
            void        user_function      (GtkWindow       *window,
                                            GtkDirectionType arg1,
                                            gpointer         user_data)      : Run last / Action
"set-focus" void        user_function      (GtkWindow *window,
                                            GtkWidget *widget,
                                            gpointer   user_data)      : Run last

Описание

Детали

GtkWindow

typedef struct _GtkWindow GtkWindow;

gtk_window_new ()

GtkWidget*  gtk_window_new                  (GtkWindowType type);

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

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

gtk_window_set_title ()

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

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

gtk_window_set_wmclass ()

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

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

gtk_window_set_policy ()

void        gtk_window_set_policy           (GtkWindow *window,
                                             gint allow_shrink,
                                             gint allow_grow,
                                             gint auto_shrink);

Внимание

gtk_window_set_policy устарела и не нужно её использовать во вновь создаваемом коде. Используйте вместо неё gtk_window_set_resizable().

Изменения размеров окна верхнего уровня и попытки пользователя изменять размер. В действительности есть только два способа вызова этой функции:

1. gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, FALSE) означает, что окно позволяет изменять размер пользователю (user-resizable).

2. gtk_window_set_policy (GTK_WINDOW (window), FALSE, FALSE, TRUE) означает, что размер окна управляется программой (program-controlled) и должно просто соответствовать текущемму размеру запроса дочерних окон.

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

Основная функции должна быть например: void gtk_window_set_resizable (GtkWindow* window, gboolean setting); ...почему GTK+ 2.0 и представляет gtk_window_set_resizable(), которую вы должны использовать вместо gtk_window_set_policy().

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

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

Заметьте, auto_shrink не делает ничего, если allow_shrink и allow_grow установлены в FALSE.

Не одна из двух предложенных политик поведения окна не устанавливает параметр allow_shrink в значение TRUE. Если allow_shrink равен TRUE, пользователь может уменьшать окно таким образом, что его дочерние виджеты не получат запрашиваемый размер полностью; по существу это плохая ситуация, потому что виджеты будут выглядеть неправильно если это случиться. Кроме того GTK+ имеет тенденцию повторно разворачивать окно если размер пересчитан по какой нибудь причине. Поэтому allow_shrink должен всегда быть установлен в FALSE.

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

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_position

#define gtk_window_position                     gtk_window_set_position

Внимание

gtk_window_position устарела и не нужно её использовать во вновь создаваемом коде.

Устаревший псевдоним для gtk_window_set_position().

gtk_window_activate_focus ()

gboolean    gtk_window_activate_focus       (GtkWindow *window);

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

gtk_window_activate_default ()

gboolean    gtk_window_activate_default     (GtkWindow *window);

Активирует виджет по умолчанию в данном окне, если текущий виджет находящийся в фокусе не был сконфигурирован получать действие по умолчанию (смотрите GTK_RECEIVES_DEFAULT в GtkWidgetFlags), когда виджет в фокусе активирован.

gtk_window_set_modal ()

void        gtk_window_set_modal            (GtkWindow *window,
                                             gboolean modal);

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

gtk_window_set_default_size ()

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

Устанавливает размер окна по умолчанию. Если окно "natural" размера (его запрашиваемый размер) будет больше чем значение по умолчанию, то значение по умолчанию игнорируется. Наиболее обычно, если размер по умолчанию не подчиняется подсказкам геометрии окна (gtk_window_set_geometry_hints() может использоваться для их явной установки), размер по умолчанию будет прикреплён к ближайшему допустимому размеру.

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

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

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

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

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

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

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

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

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

gtk_window_propagate_key_event ()

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

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

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

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

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

gtk_window_present ()

void        gtk_window_present              (GtkWindow *window);

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

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

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

Если вы вызываете эту функцию взаимодействуя с пользователем, предпочтительно использовать gdk_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_iconify ()

void        gtk_window_iconify              (GtkWindow *window);

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

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

Вы можете отслеживать минимизацию через сигнал "window_state_event" на GtkWidget.

gtk_window_deiconify ()

void        gtk_window_deiconify            (GtkWindow *window);

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

Вы можете отслеживать минимизацию через сигнал "window_state_event" на GtkWidget.

gtk_window_stick ()

void        gtk_window_stick                (GtkWindow *window);

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

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

Вы можете отслеживать прикрепления через сигнал "window_state_event" на GtkWidget.

gtk_window_unstick ()

void        gtk_window_unstick              (GtkWindow *window);

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

Вы можете отслеживать прикрепления через сигнал "window_state_event" на GtkWidget.

gtk_window_maximize ()

void        gtk_window_maximize             (GtkWindow *window);

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

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

Вы можете отслеживать максимизацию с помощью сигнала "window_state_event" на GtkWidget.

gtk_window_unmaximize ()

void        gtk_window_unmaximize           (GtkWindow *window);

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

Вы можете отслеживать максимизацию с помощью сигнала "window_state_event" на GtkWidget.

gtk_window_fullscreen ()

void        gtk_window_fullscreen           (GtkWindow *window);

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

Вы можете отслеживать полноэкранный режим через сигнал "window_state_event" на GtkWidget.

Начиная с версии 2.2

gtk_window_unfullscreen ()

void        gtk_window_unfullscreen         (GtkWindow *window);

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

Вы можете отслеживать полноэкранный режим через сигнал "window_state_event" на GtkWidget.

Начиная с версии 2.2

gtk_window_set_keep_above ()

void        gtk_window_set_keep_above       (GtkWindow *window,
                                             gboolean setting);

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

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

Вы можете отследить это состояние через сигнал "window_state_event" на GtkWidget.

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

Начиная с версии 2.4

gtk_window_set_keep_below ()

void        gtk_window_set_keep_below       (GtkWindow *window,
                                             gboolean setting);

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

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

Вы можете отследить это состояние через сигнал "window_state_event" на GtkWidget.

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

Начиная с версии 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 может поддерживать это, изменение размера будет выполнено используя стандартный механизм для window manager или оконной системы. Иначе, 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 может поддерживать это, перемещение будет выполнено используя стандартный механизм для window manager или оконной системы. Иначе, GDK попробует эмулировать перемещение окна.

gtk_window_set_decorated ()

void        gtk_window_set_decorated        (GtkWindow *window,
                                             gboolean setting);

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

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

gtk_window_set_deletable ()

void        gtk_window_set_deletable        (GtkWindow *window,
                                             gboolean setting);

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

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

Начиная с версии 2.10

gtk_window_set_frame_dimensions ()

void        gtk_window_set_frame_dimensions (GtkWindow *window,
                                             gint left,
                                             gint top,
                                             gint right,
                                             gint bottom);

(Примечание: эта специально-ориентированная функция предназначена для порта framebuffer; смотрите gtk_window_set_has_frame(). Она не имеет эффекта для отрисовки окна оконным менеджером, в случае обычного использования X Window system.)

Для окон с рамками (see gtk_window_set_has_frame()) эта функция используется для изменения размера окантовки рамки.

gtk_window_set_has_frame ()

void        gtk_window_set_has_frame        (GtkWindow *window,
                                             gboolean setting);

(Примечание: эта специально-ориентированная функция предназначена для порта framebuffer, она заставляет GTK+ отрисовывать собственную окантовку окна. Для большинства приложений, вы имеете вместо неё функцию gtk_window_set_decorated(), которая сообщает менеджеру окон нужно ли отрисовывать окантовку окна.)

Если эта функция вызвана с установкой TRUE, перед отображением окна, она получит "frame" вокруг окна window->window, доступный в window->frame. Используя сигнал frame_event вы можете получать все события предназначенные для рамки.

Эта функция используется портом linux-fb для осуществления управления окнами, но может использоваться X-программами которые хотят сделать собственную декорацию окна.

gtk_window_set_mnemonic_modifier ()

void        gtk_window_set_mnemonic_modifier
                                            (GtkWindow *window,
                                             GdkModifierType modifier);

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

gtk_window_set_role ()

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

Эта функция полезна только для X11.

В комбинации с заголовком окна, роль окна позволяет window manager идентифицировать ''то же самое" окно когда пере-запускает приложение. Так например, вы могли бы установить роль "toolbox" для окна инструментов вашего приложения, так, чтобы, когда пользователь пере-запускает сессию, менеджер окон мог поместить окно инструментов на тоже самое место.

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

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

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

Начиная с версии 2.2

gtk_window_set_skip_pager_hint ()

void        gtk_window_set_skip_pager_hint  (GtkWindow *window,
                                             gboolean setting);

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

Начиная с версии 2.2

gtk_window_set_urgency_hint ()

void        gtk_window_set_urgency_hint     (GtkWindow *window,
                                             gboolean setting);

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

Начиная с версии 2.8

gtk_window_set_accept_focus ()

void        gtk_window_set_accept_focus     (GtkWindow *window,
                                             gboolean setting);

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

Начиная с версии 2.4

gtk_window_set_focus_on_map ()

void        gtk_window_set_focus_on_map     (GtkWindow *window,
                                             gboolean setting);

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

Начиная с версии 2.6

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

Определяет была ли установлена кнопка «close button» с помощью 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_size ()

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

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

gtk_window_get_destroy_with_parent ()

gboolean    gtk_window_get_destroy_with_parent
                                            (GtkWindow *window);

Определяет будет ли окно закрыто с его переходным родителем. Смотрите gtk_window_set_destroy_with_parent().

gtk_window_get_frame_dimensions ()

void        gtk_window_get_frame_dimensions (GtkWindow *window,
                                             gint *left,
                                             gint *top,
                                             gint *right,
                                             gint *bottom);

(Примечание: эта специально-ориентированная функция предназначена для порта framebuffer; смотрите gtk_window_set_has_frame(). Она не будет возвращать размер окантовки окна нарисованную window manager, что было бы нормально при использовании оконной системы. Смотрите gdk_window_get_frame_extents() для получения стандарта окантовки окна.)

Получает размер рамки окна для верхнего уровня. Смотрите gtk_window_set_has_frame(), gtk_window_set_frame_dimensions().

gtk_window_get_has_frame ()

gboolean    gtk_window_get_has_frame        (GtkWindow *window);

Имеет ли окно внешнюю область рамки окна window->window. Получает значение установленное gtk_window_set_has_frame().

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

gchar*      gtk_window_get_icon_name        (GtkWindow *window);

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

Начиная с версии 2.6

gtk_window_get_mnemonic_modifier ()

GdkModifierType gtk_window_get_mnemonic_modifier
                                            (GtkWindow *window);

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

gtk_window_get_modal ()

gboolean    gtk_window_get_modal            (GtkWindow *window);

Определяет является ли окно модальным. Смотрите gtk_window_set_modal().

gtk_window_get_position ()

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

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

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

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

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

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

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

gtk_window_get_role ()

const gchar* gtk_window_get_role            (GtkWindow *window);

Возвращает роль окна. Детали смотрите в gtk_window_set_role().

gtk_window_get_size ()

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

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

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

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

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

В любом случае, если вы настоите на приложение-определяемом (application-specified) позиционировании окна, есть всё ещё лучший путь, чем непосредственное выполнение - 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_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_move ()

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

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

Помните: позиция это позиция определенная (gravity-determined) контрольной точкой притяжения для окна. Притяжение определяет две вещи: первое, размещение контрольной точки в главном координирующем окне; и второе, какая точка на окне является контрольной точкой.

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

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

Спецификация Extended Window Manager Hints на http://www.freedesktop.org/Standards/wm-spec имеет хорошую таблицу притяжений в разделе "implementation notes".

Документация по 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() должна вызываться когда окно имеет окончательный ("final") размер, например после вызова gtk_widget_show_all() для содержимого и gtk_window_set_geometry_hints() для окна.

include <gtk/gtk.h>
   
static void
fill_with_content (GtkWidget *vbox)
{
  /* заполняется содержимым... */
}
   
int
main (int argc, char *argv[])
{
  GtkWidget *window, *vbox;
  GdkGeometry size_hints = {
    100, 50, 0, 0, 100, 50, 10, 10, 0.0, 0.0, GDK_GRAVITY_NORTH_WEST  
  };
   
  gtk_init (&argc, &argv);
  
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  vbox = gtk_vbox_new (FALSE, 0);
  
  gtk_container_add (GTK_CONTAINER (window), vbox);
  fill_with_content (vbox);
  gtk_widget_show_all (vbox);
  
  gtk_window_set_geometry_hints (GTK_WINDOW (window),
                                    window,
                                    &size_hints,
                                    GDK_HINT_MIN_SIZE | 
                                    GDK_HINT_BASE_SIZE | 
                                    GDK_HINT_RESIZE_INC);
  
  if (argc > 1)
    {
      if (!gtk_window_parse_geometry (GTK_WINDOW (window), argv[1]))
        fprintf (stderr, "Failed to parse '%s'\n", argv[1]);
    }
   
  gtk_widget_show_all (window);
  gtk_main();
   
  return 0;
}

gtk_window_reshow_with_initial_size ()

void        gtk_window_reshow_with_initial_size
                                            (GtkWindow *window);

Скрывает window, затем повторно отображает, сбрасывая значение по умолчанию размера и позиции окна. Используется только сборщиками GUI.

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

void        gtk_window_set_default_icon_list
                                            (GList *list);

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

Подробности смотрите в gtk_window_set_icon_list().

gtk_window_set_default_icon ()

void        gtk_window_set_default_icon     (GdkPixbuf *icon);

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

Начиная с версии 2.4

gtk_window_set_default_icon_from_file ()

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

Устанавливает значок используемый как аварийный (fallback) для окон не имеющих файла на диске для вызова 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);

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

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

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, для каждого GdkScreen GTK+ вызывает gdk_screen_notify_startup_complete(). Вызовите эту функцию для отключения автоматического запуска уведомления. Вы можете сделать это, например, если ваше первое окно является заставкой и вы хотите задержать уведомление пока не покажется реальное основное окно.

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

Начиная с версии 2.2

gtk_decorated_window_init ()

void        gtk_decorated_window_init       (GtkWindow *window);

gtk_decorated_window_calculate_frame_size ()

void        gtk_decorated_window_calculate_frame_size
                                            (GtkWindow *window);

gtk_decorated_window_set_title ()

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

gtk_decorated_window_move_resize_window ()

void        gtk_decorated_window_move_resize_window
                                            (GtkWindow *window,
                                             gint x,
                                             gint y,
                                             gint width,
                                             gint height);

Детали свойств

Свойство "accept-focus"

  "accept-focus"         gboolean              : Read / Write

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

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

Свойство "allow-grow"

  "allow-grow"           gboolean              : Read / Write

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

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

Свойство "allow-shrink"

  "allow-shrink"         gboolean              : Read / Write

Если TRUE, окно не имеет минимального размера. Установка TRUE в 99% случаев плохая идея.

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

Свойство "decorated"

  "decorated"            gboolean              : Read / Write

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

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

Начиная с версии 2.4

Свойство "default-height"

  "default-height"       gint                  : Read / Write

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

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

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

Свойство "default-width"

  "default-width"        gint                  : Read / Write

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

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

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

Свойство "deletable"

  "deletable"            gboolean              : Read / Write

Имеет ли рамка окна кнопку «close button».

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

Начиная с версии 2.10

Свойство "destroy-with-parent"

  "destroy-with-parent"  gboolean              : Read / Write

Если это окно должно быть закрыто, когда закрывается его родительское окно.

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

Свойство "focus-on-map"

  "focus-on-map"         gboolean              : Read / Write

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

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

Свойство "gravity"

  "gravity"              GdkGravity            : Read / Write

Притяжение окна. Смотрите gtk_window_move() и GdkGravity для больших деталей о притяжении.

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

Начиная с версии 2.4

Свойство "has-toplevel-focus"

  "has-toplevel-focus"   gboolean              : Read

Является ли фокус ввода в пределах этого GtkWindow.

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

Свойство "icon"

  "icon"                 GdkPixbuf             : Read / Write

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

Свойство "icon-name"

  "icon-name"            gchararray            : Read / Write

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

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

Начиная с версии 2.6

Свойство "is-active"

  "is-active"            gboolean              : Read

Является ли верхний уровень текущим активным окном.

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

Свойство "modal"

  "modal"                gboolean              : Read / Write

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

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

Свойство "resizable"

  "resizable"            gboolean              : Read / Write

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

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

Свойство "role"

  "role"                 gchararray            : Read / Write

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

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

Свойство "screen"

  "screen"               GdkScreen             : Read / Write

Экран на котором отображается окно.

Свойство "skip-pager-hint"

  "skip-pager-hint"      gboolean              : Read / Write

TRUE если окно не должно появляться в пейджере.

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

Свойство "skip-taskbar-hint"

  "skip-taskbar-hint"    gboolean              : Read / Write

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

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

Свойство "title"

  "title"                gchararray            : Read / Write

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

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

Свойство "transient-for"

  "transient-for"        GtkWindow             : Read / Write / Construct

Переходный родитель для окна. Смотрите gtk_window_set_transient_for() для большей информации о переходных родителях.

Начиная с версии 2.10

Свойство "type"

  "type"                 GtkWindowType         : Read / Write / Construct Only

Тип окна.

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

Свойство "type-hint"

  "type-hint"            GdkWindowTypeHint     : Read / Write

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

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

Свойство "urgency-hint"

  "urgency-hint"         gboolean              : Read / Write

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

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

Свойство "window-position"

  "window-position"      GtkWindowPosition     : Read / Write

Инициализирует позицию окна.

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

Детали сигналов

Сигнал "activate-default"

void        user_function                  (GtkWindow *window,
                                            gpointer   user_data)      : Run last / Action

Сигнал "activate-focus"

void        user_function                  (GtkWindow *window,
                                            gpointer   user_data)      : Run last / Action

Сигнал "frame-event"

gboolean    user_function                  (GtkWindow *window,
                                            GdkEvent  *event,
                                            gpointer   user_data)      : Run last

Сигнал "keys-changed"

void        user_function                  (GtkWindow *window,
                                            gpointer   user_data)      : Run first

Сигнал "move-focus"

void        user_function                  (GtkWindow       *window,
                                            GtkDirectionType arg1,
                                            gpointer         user_data)      : Run last / Action

Сигнал "set-focus"

void        user_function                  (GtkWindow *window,
                                            GtkWidget *widget,
                                            gpointer   user_data)      : Run last

Партнёры:

Хостинг: