The OpenNET Project / Index page

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

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

Prev

Up

Home

GTK+ Reference Manual

Next

Top  |  Description  |  Object Hierarchy  |  Properties  |  Signals

GtkWindow

GtkWindow Окно верхнего уровня, которое может содержать другие виджеты

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

#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.

type :

тип окна

Возвращает :

новый GtkWindow.


gtk_window_set_title ()

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

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

window :

GtkWindow

title :

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


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

window :

GtkWindow

wmclass_name :

Подсказка имени окна

wmclass_class :

Подсказка класса окна


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

window :

окно

allow_shrink :

Может ли пользователь уменьшать окно сверх размера запроса

allow_grow :

Может ли пользователь увеличивать окно сверх размера запроса

auto_shrink :

Возвращать ли автоматически размер окна к запрашиваемому если оно является большим


gtk_window_set_resizable ()

void        gtk_window_set_resizable        (GtkWindow *window,
                                             gboolean resizable);

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

window :

GtkWindow

resizable :

TRUE если пользователь может изменять размер этого окна


gtk_window_get_resizable ()

gboolean    gtk_window_get_resizable        (GtkWindow *window);

Получает значение установленное gtk_window_set_resizable().

window :

GtkWindow

Возвращает :

TRUE если пользователь может изменять размер этого окна


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.

window :

Окно к которому прикрепляется акселератор

accel_group :

GtkAccelGroup


gtk_window_remove_accel_group ()

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

Обратный эффект от gtk_window_add_accel_group().

window :

GtkWindow

accel_group :

GtkAccelGroup


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

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

window :

GtkWindow

Возвращает :

TRUE если данный виджет активирован.


gtk_window_activate_default ()

gboolean    gtk_window_activate_default     (GtkWindow *window);

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

window :

GtkWindow

Возвращает :

TRUE если данный виджет активирован.


gtk_window_set_modal ()

void        gtk_window_set_modal            (GtkWindow *window,
                                             gboolean modal);

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

window :

GtkWindow

modal :

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


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.

window :

GtkWindow

width :

Ширина в пикселах, или -1 для сброса ширины по умолчанию

height :

Высота в пикселах, или -1 для сброса высоты по умолчанию


gtk_window_set_geometry_hints ()

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

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

window :

GtkWindow

geometry_widget :

Подсказки геометрии применяемые к виджету

geometry :

Структура содержащая информацию о геометрии

geom_mask :

Маска указывающая на какое поле структуры должно быть обращено внимание


gtk_window_set_gravity ()

void        gtk_window_set_gravity          (GtkWindow *window,
                                             GdkGravity gravity);

Уравновешенность окна определяют координаты помещенные в gtk_window_move(). Смотрите gtk_window_move() и GdkGravity для более подробной информации.

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

window :

GtkWindow

gravity :

Уравновешивание окна


gtk_window_get_gravity ()

GdkGravity  gtk_window_get_gravity          (GtkWindow *window);

Получает значение установленное gtk_window_set_gravity().

window :

GtkWindow

Возвращает :

Уравновешивание окна


gtk_window_set_position ()

void        gtk_window_set_position         (GtkWindow *window,
                                             GtkWindowPosition position);

Устанавливает ограничения позиции окна. Если старое или новое ограничение равно GTK_WIN_POS_CENTER_ALWAYS, то это будет причиной перестановки окна для удовлетворения нового ограничения.

window :

GtkWindow.

position :

Ограничение позиции.


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.

window :

GtkWindow

parent :

Родительское окно


gtk_window_set_destroy_with_parent ()

void        gtk_window_set_destroy_with_parent
                                            (GtkWindow *window,
                                             gboolean setting);

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

window :

GtkWindow

setting :

Закрыть ли window с его переходным родителем


gtk_window_set_screen ()

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

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

window :

GtkWindow.

screen :

GdkScreen.

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


gtk_window_get_screen ()

GdkScreen*  gtk_window_get_screen           (GtkWindow *window);

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

window :

GtkWindow.

Возвращает :

GdkScreen.

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


gtk_window_is_active ()

gboolean    gtk_window_is_active            (GtkWindow *window);

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

window :

GtkWindow

Возвращает :

TRUE если окно - часть текущемго активного окна.

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


gtk_window_has_toplevel_focus ()

gboolean    gtk_window_has_toplevel_focus   (GtkWindow *window);

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

window :

GtkWindow

Возвращает :

TRUE если ввод сфокусирован в пределах данного GtkWindow

Начиная с версии 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);

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

window :

GtkWindow

keyval :

мнемоник

target :

Виджет который активизируется мнемоником


gtk_window_remove_mnemonic ()

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

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

window :

GtkWindow

keyval :

мнемоник

target :

Виджет который активизируется мнемоником


gtk_window_mnemonic_activate ()

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

Активизирует цель ассоциированную с мнемоником.

window :

GtkWindow

keyval :

мнемоник

modifier :

модификаторы

Возвращает :

TRUE если активация выполнена.


gtk_window_activate_key ()

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

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

window :

GtkWindow

event :

GdkEventKey

Возвращает :

TRUE если мнемоник или акселератор был найден и активирован.


gtk_window_propagate_key_event ()

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

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

window :

GtkWindow

event :

GdkEventKey

Возвращает :

TRUE если виджет в сфокусированной цепочке обработал событие.


gtk_window_get_focus ()

GtkWidget*  gtk_window_get_focus            (GtkWindow *window);

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

window :

GtkWindow

Возвращает :

Текущий сфокусированный виджет, или NULL если его нет.


gtk_window_set_focus ()

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

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

window :

GtkWindow

focus :

Новый сфокусированный виджет, или NULL для сброса всех сфокусированных виджетов для окна верхнего уровня.


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

window :

GtkWindow

default_widget :

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


gtk_window_present ()

void        gtk_window_present              (GtkWindow *window);

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

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

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

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

window :

GtkWindow


gtk_window_present_with_time ()

void        gtk_window_present_with_time    (GtkWindow *window,
                                             guint32 timestamp);

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

window :

GtkWindow

timestamp :

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

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


gtk_window_iconify ()

void        gtk_window_iconify              (GtkWindow *window);

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

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

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

window :

GtkWindow


gtk_window_deiconify ()

void        gtk_window_deiconify            (GtkWindow *window);

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

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

window :

GtkWindow


gtk_window_stick ()

void        gtk_window_stick                (GtkWindow *window);

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

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

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

window :

GtkWindow


gtk_window_unstick ()

void        gtk_window_unstick              (GtkWindow *window);

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

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

window :

GtkWindow


gtk_window_maximize ()

void        gtk_window_maximize             (GtkWindow *window);

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

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

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

window :

GtkWindow


gtk_window_unmaximize ()

void        gtk_window_unmaximize           (GtkWindow *window);

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

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

window :

GtkWindow


gtk_window_fullscreen ()

void        gtk_window_fullscreen           (GtkWindow *window);

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

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

window :

GtkWindow

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


gtk_window_unfullscreen ()

void        gtk_window_unfullscreen         (GtkWindow *window);

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

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

window :

GtkWindow

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

window :

GtkWindow

setting :

Установлен ли режим переднего плана для window

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

window :

GtkWindow

setting :

Сворачивать ли window

Начиная с версии 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 попробует эмулировать изменение размера окна.

window :

GtkWindow

edge :

Позиция изменяющего размер управления

button :

Кнопка мыши которая инициировала перетаскивание

root_x :

X позиция нажатия пользователем для инициирования перетаскивания, в координатах главного окна

root_y :

Y позиция нажатия пользователем для инициирования перетаскивания

timestamp :

Ограничение времени щелчка инициировавшего перетаскивание


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 попробует эмулировать перемещение окна.

window :

GtkWindow

button :

Кнопка мыши инициировавшая перемещение

root_x :

X позиция нажатия пользователем для инициирования перемещения, в координатах главного окна

root_y :

Y позиция нажатия пользователем для инициирования перемещения

timestamp :

Ограничение времени щелчка инициировавшего перемещение


gtk_window_set_decorated ()

void        gtk_window_set_decorated        (GtkWindow *window,
                                             gboolean setting);

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

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

window :

GtkWindow

setting :

TRUE для декорирования окна


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

window :

GtkWindow

setting :

TRUE декорирует окно как закрываемое (deletable)

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

window :

GtkWindow который имеет рамку

left :

Ширина левой окантовки

top :

Высота верхней окантовки

right :

Ширина правой окантовки

bottom :

Высота нижней окантовки


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-программами которые хотят сделать собственную декорацию окна.

window :

GtkWindow

setting :

Булево (TRUE или FALSE)


gtk_window_set_mnemonic_modifier ()

void        gtk_window_set_mnemonic_modifier
                                            (GtkWindow *window,
                                             GdkModifierType modifier);

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

window :

GtkWindow

modifier :

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


gtk_window_set_role ()

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

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

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

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

window :

GtkWindow

role :

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


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() от вашего имени.

window :

GtkWindow

hint :

Тип окна


gtk_window_set_skip_taskbar_hint ()

void        gtk_window_set_skip_taskbar_hint
                                            (GtkWindow *window,
                                             gboolean setting);

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

window :

GtkWindow

setting :

TRUE чтобы запретить окну появление в панели задач

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


gtk_window_set_skip_pager_hint ()

void        gtk_window_set_skip_pager_hint  (GtkWindow *window,
                                             gboolean setting);

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

window :

GtkWindow

setting :

TRUE чтобы запретить окну появление в пейджере

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


gtk_window_set_urgency_hint ()

void        gtk_window_set_urgency_hint     (GtkWindow *window,
                                             gboolean setting);

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

window :

GtkWindow

setting :

TRUE пометить это окно как срочное

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


gtk_window_set_accept_focus ()

void        gtk_window_set_accept_focus     (GtkWindow *window,
                                             gboolean setting);

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

window :

GtkWindow

setting :

TRUE позволяет окну получение фокуса ввода

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


gtk_window_set_focus_on_map ()

void        gtk_window_set_focus_on_map     (GtkWindow *window,
                                             gboolean setting);

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

window :

GtkWindow

setting :

TRUE позволяет получить фокус отображённому окну

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


gtk_window_get_decorated ()

gboolean    gtk_window_get_decorated        (GtkWindow *window);

Определяет собирается ли окно иметь декорации, например заголовок окна через gtk_window_set_decorated().

window :

GtkWindow

Возвращает :

TRUE если окно собирается иметь декорацию


gtk_window_get_deletable ()

gboolean    gtk_window_get_deletable        (GtkWindow *window);

Определяет была ли установлена кнопка «close button» с помощью gtk_window_set_deletable().

window :

GtkWindow

Returns :

TRUE если окно имеет установленную кнопку «close button»

Начиная с версии 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" размер окна.

window :

GtkWindow

width :

Размещение значения по умолчанию ширины, или NULL

height :

Размещение значения по умолчанию высоты, или NULL


gtk_window_get_destroy_with_parent ()

gboolean    gtk_window_get_destroy_with_parent
                                            (GtkWindow *window);

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

window :

GtkWindow

Возвращает :

TRUE если окно будет закрыто с его переходным родителем.


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

window :

GtkWindow

left :

Размещение ширины рамки слева, или NULL

top :

Размещение высоты рамки сверху, или NULL

right :

Размещение ширины рамки справа, или NULL

bottom :

Размещение высоты рамки снизу, или NULL


gtk_window_get_has_frame ()

gboolean    gtk_window_get_has_frame        (GtkWindow *window);

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

window :

GtkWindow

Возвращает :

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

window :

GtkWindow

Возвращает :

Значок для окна window


gtk_window_get_icon_list ()

GList*      gtk_window_get_icon_list        (GtkWindow *window);

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

window :

GtkWindow

Возвращает :

Копия списка значков окна


gtk_window_get_icon_name ()

gchar*      gtk_window_get_icon_name        (GtkWindow *window);

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

window :

GtkWindow

Возвращает :

Имя значка, или NULL если окно не имеет темы значков

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


gtk_window_get_mnemonic_modifier ()

GdkModifierType gtk_window_get_mnemonic_modifier
                                            (GtkWindow *window);

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

window :

GtkWindow

Возвращает :

Модифицирующая маска используемая для активации мнемоника на этом окне.


gtk_window_get_modal ()

gboolean    gtk_window_get_modal            (GtkWindow *window);

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

window :

GtkWindow

Возвращает :

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


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) и позволять оконному менеджеру сохранять размер окна и его позицию.

window :

GtkWindow

root_x :

Расположение возвращаемой X координаты точки указателя определенного притяжения

root_y :

Расположение возвращаемой Y координаты точки указателя определенного притяжения


gtk_window_get_role ()

const gchar* gtk_window_get_role            (GtkWindow *window);

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

window :

GtkWindow

Возвращает :

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


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() обрабатывает детали для вас.

window :

GtkWindow

width :

Расположение возвращаемой ширины, или NULL

height :

Расположение возвращаемой высоты, или NULL


gtk_window_get_title ()

const gchar* gtk_window_get_title           (GtkWindow *window);

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

window :

GtkWindow

Возвращает :

Заголовок окна, или NULL если не один не установлен явно. Возвращаемой строкой владеет виджет и она не должна освобождаться или изменяться.


gtk_window_get_transient_for ()

GtkWindow*  gtk_window_get_transient_for    (GtkWindow *window);

Даёт переходящего родителя для окна. Смотрите gtk_window_set_transient_for().

window :

GtkWindow

Возвращает :

Переходящий родитель для этого окна, или NULL если переходящий родитель не был установлен.


gtk_window_get_type_hint ()

GdkWindowTypeHint gtk_window_get_type_hint  (GtkWindow *window);

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

window :

GtkWindow

Возвращает :

Тип подсказки для window.


gtk_window_get_skip_taskbar_hint ()

gboolean    gtk_window_get_skip_taskbar_hint
                                            (GtkWindow *window);

Получает значение установленное gtk_window_set_skip_taskbar_hint()

window :

GtkWindow

Возвращает :

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

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


gtk_window_get_skip_pager_hint ()

gboolean    gtk_window_get_skip_pager_hint  (GtkWindow *window);

Получает значение установленное gtk_window_set_skip_pager_hint().

window :

GtkWindow

Возвращает :

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

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


gtk_window_get_urgency_hint ()

gboolean    gtk_window_get_urgency_hint     (GtkWindow *window);

Получает значение полученное gtk_window_set_urgency_hint()

window :

GtkWindow

Возвращает :

TRUE если окно срочное

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


gtk_window_get_accept_focus ()

gboolean    gtk_window_get_accept_focus     (GtkWindow *window);

Получает значение полученное gtk_window_set_accept_focus().

window :

GtkWindow

Возвращает :

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

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


gtk_window_get_focus_on_map ()

gboolean    gtk_window_get_focus_on_map     (GtkWindow *window);

Получает значение полученное gtk_window_set_focus_on_map().

window :

GtkWindow

Возвращает :

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

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


gtk_window_get_group ()

GtkWindowGroup* gtk_window_get_group        (GtkWindow *window);

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

window :

GtkWindow, или NULL

Возвращает :

GtkWindowGroup для окна или группу по умолчанию

Начиная с версии 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() может тоже быть полезной.

window :

GtkWindow

x :

X координаты для перемещения окна

y :

Y координаты для перемещения окна


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

window :

GtkWindow

geometry :

Строка геометрии

Возвращает :

TRUE если строка полностью проанализирована


gtk_window_reshow_with_initial_size ()

void        gtk_window_reshow_with_initial_size
                                            (GtkWindow *window);

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

window :

GtkWindow


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 пиксел.

window :

GtkWindow

width :

Ширина в пикселах для изменения размера

height :

Высота в пикселах для изменения размера


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

list :

Список GdkPixbuf


gtk_window_set_default_icon ()

void        gtk_window_set_default_icon     (GdkPixbuf *icon);

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

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.

filename :

Размещение файла значка

err :

Размещение сохранения ошибки, или NULL.

Возвращает :

TRUE если установка значка выполнена.

Начиная с версии 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().

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() для установки значка для всех окон в вашем приложении.

window :

GtkWindow

icon :

Значок изображение, или NULL


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

window :

GtkWindow

list :

список GdkPixbuf


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.

window :

GtkWindow

filename :

Размещение файла значка

err :

Размещение ошибки, или NULL.

Возвращает :

TRUE если установка значка выполнена.

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


gtk_window_set_icon_name ()

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

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

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

window :

GtkWindow

name :

Имя тематического значка

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

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

setting :

TRUE для автоматического запуска уведомления

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


gtk_decorated_window_init ()

void        gtk_decorated_window_init       (GtkWindow *window);

window :


gtk_decorated_window_calculate_frame_size ()

void        gtk_decorated_window_calculate_frame_size
                                            (GtkWindow *window);

window :


gtk_decorated_window_set_title ()

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

window :

title :


gtk_decorated_window_move_resize_window ()

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

window :

x :

y :

width :

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

window :

объект который получает сигнал.

user_data :

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


Сигнал "activate-focus"

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

window :

объект который получает сигнал.

user_data :

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


Сигнал "frame-event"

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

window :

объект который получает сигнал.

event :

user_data :

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

Возвращает :


Сигнал "keys-changed"

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

window :

объект который получает сигнал.

user_data :

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


Сигнал "move-focus"

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

window :

объект который получает сигнал.

arg1 :

user_data :

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


Сигнал "set-focus"

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

window :

объект который получает сигнал.

widget :

user_data :

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






Партнёры:
PostgresPro
Inferno Solutions
Hosting by Hoster.ru
Хостинг:

Закладки на сайте
Проследить за страницей
Created 1996-2024 by Maxim Chirkov
Добавить, Поддержать, Вебмастеру