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

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

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

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

Свойства

Сигналы

Описание

Детали

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


	
gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE,
	FALSE) означает, что окно позволяет
	изменять размер пользователю
	(user-resizable). 
	
	
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 :
		
		

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