------------------------------------------------------------------------------ -- -- -- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet -- -- Copyright (C) 2000-2014, AdaCore -- -- -- -- This library is free software; you can redistribute it and/or modify it -- -- under terms of the GNU General Public License as published by the Free -- -- Software Foundation; either version 3, or (at your option) any later -- -- version. This library is distributed in the hope that it will be useful, -- -- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- -- -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. -- -- -- -- As a special exception under Section 7 of GPL version 3, you are granted -- -- additional permissions described in the GCC Runtime Library Exception, -- -- version 3.1, as published by the Free Software Foundation. -- -- -- -- You should have received a copy of the GNU General Public License and -- -- a copy of the GCC Runtime Library Exception along with this program; -- -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- -- <http://www.gnu.org/licenses/>. -- -- -- ------------------------------------------------------------------------------ -- <description> -- A GtkWindow is a toplevel window which can contain other widgets. Windows -- normally have decorations that are under the control of the windowing -- system and allow the user to manipulate the window (resize it, move it, -- close it,...). -- -- GTK+ also allows windows to have a resize grip (a small area in the lower -- right or left corner) which can be clicked to reszie the window. To control -- whether a window has a resize grip, use Gtk.Window.Set_Has_Resize_Grip. -- -- == GtkWindow as GtkBuildable == -- -- The GtkWindow implementation of the GtkBuildable interface supports a -- custom <tag class="starttag">accel-groups</tag> element, which supports any -- number of <tag class="starttag">group</tag> elements representing the -- Gtk.Accel_Group.Gtk_Accel_Group objects you want to add to your window -- (synonymous with Gtk.Window.Add_Accel_Group. -- -- == A UI definition fragment with accel groups == -- -- <object class="GtkWindow"> -- <accel-groups> -- <group name="accelgroup1"/> -- </accel-groups> -- </object> -- <!-- --> -- ... -- <!-- --> -- <object class="GtkAccelGroup" id="accelgroup1"/> -- </description> pragma Ada_2005; pragma Warnings (Off, "*is already use-visible*");
with Gdk.Device; use Gdk.Device;
with Gdk.Event; use Gdk.Event;
with Gdk.Pixbuf; use Gdk.Pixbuf;
with Gdk.Rectangle; use Gdk.Rectangle;
with Gdk.Screen; use Gdk.Screen;
with Gdk.Types; use Gdk.Types;
with Gdk.Window; use Gdk.Window;
with Glib; use Glib;
with Glib.Object; use Glib.Object;
with Glib.Properties; use Glib.Properties;
with Glib.Types; use Glib.Types;
with Gtk.Accel_Group; use Gtk.Accel_Group;
with Gtk.Bin; use Gtk.Bin;
with Gtk.Buildable; use Gtk.Buildable;
with Gtk.Enums; use Gtk.Enums;
with Gtk.Widget; use Gtk.Widget;
package Gtk.Window is
type Gtk_Window_Record is new Gtk_Bin_Record with null record;
type Gtk_Window is access all Gtk_Window_Record'Class;
type Gtk_Window_Group_Record is new GObject_Record with null record;
type Gtk_Window_Group is access all Gtk_Window_Group_Record'Class;
------------------ -- Constructors -- ------------------ procedure Gtk_New
(Window : out Gtk_Window;
The_Type : Gtk.Enums.Gtk_Window_Type := Gtk.Enums.Window_Toplevel);
procedure Initialize
(Window : not null access Gtk_Window_Record'Class;
The_Type : Gtk.Enums.Gtk_Window_Type := Gtk.Enums.Window_Toplevel);
-- Creates a new Gtk.Window.Gtk_Window, which is a toplevel window that -- can contain other widgets. Nearly always, the type of the window should -- be GTK_WINDOW_TOPLEVEL. If you're implementing something like a popup -- menu from scratch (which is a bad idea, just use Gtk.Menu.Gtk_Menu), you -- might use GTK_WINDOW_POPUP. GTK_WINDOW_POPUP is not for dialogs, though -- in some other toolkits dialogs are called "popups". In GTK+, -- GTK_WINDOW_POPUP means a pop-up menu or pop-up tooltip. On X11, popup -- windows are not controlled by the <link linkend="gtk-X11-arch">window -- manager</link>. -- If you simply want an undecorated window (no window borders), use -- Gtk.Window.Set_Decorated, don't use GTK_WINDOW_POPUP. -- "type": type of window function Gtk_Window_New
(The_Type : Gtk.Enums.Gtk_Window_Type := Gtk.Enums.Window_Toplevel)
return Gtk_Window;
-- Creates a new Gtk.Window.Gtk_Window, which is a toplevel window that -- can contain other widgets. Nearly always, the type of the window should -- be GTK_WINDOW_TOPLEVEL. If you're implementing something like a popup -- menu from scratch (which is a bad idea, just use Gtk.Menu.Gtk_Menu), you -- might use GTK_WINDOW_POPUP. GTK_WINDOW_POPUP is not for dialogs, though -- in some other toolkits dialogs are called "popups". In GTK+, -- GTK_WINDOW_POPUP means a pop-up menu or pop-up tooltip. On X11, popup -- windows are not controlled by the <link linkend="gtk-X11-arch">window -- manager</link>. -- If you simply want an undecorated window (no window borders), use -- Gtk.Window.Set_Decorated, don't use GTK_WINDOW_POPUP. -- "type": type of window function Get_Type return Glib.GType;
pragma Import (C, Get_Type, "gtk_window_get_type");
procedure Gtk_New (Window_Group : out Gtk_Window_Group);
procedure Initialize
(Window_Group : not null access Gtk_Window_Group_Record'Class);
-- Creates a new Gtk.Window.Gtk_Window_Group object. Grabs added with -- Gtk.Widget.Grab_Add only affect windows within the same -- Gtk.Window.Gtk_Window_Group. function Gtk_Window_Group_New return Gtk_Window_Group;
-- Creates a new Gtk.Window.Gtk_Window_Group object. Grabs added with -- Gtk.Widget.Grab_Add only affect windows within the same -- Gtk.Window.Gtk_Window_Group. function Group_Get_Type return Glib.GType;
pragma Import (C, Group_Get_Type, "gtk_window_group_get_type");
------------- -- Methods -- ------------- function Activate_Default
(Window : not null access Gtk_Window_Record) return Boolean;
-- Activates the default widget for the window, unless the current focused -- widget has been configured to receive the default action (see -- Gtk.Widget.Set_Receives_Default), in which case the focused widget is -- activated. function Activate_Focus
(Window : not null access Gtk_Window_Record) return Boolean;
-- Activates the current focused widget within the window. function Activate_Key
(Window : not null access Gtk_Window_Record;
Event : Gdk.Event.Gdk_Event_Key) return Boolean;
-- Activates mnemonics and accelerators for this Gtk.Window.Gtk_Window. -- This is normally called by the default ::key_press_event handler for -- toplevel windows, however in some cases it may be useful to call this -- directly when overriding the standard key handling for a toplevel -- window. -- Since: gtk+ 2.4 -- "event": a Gdk.Event.Gdk_Event_Key procedure Add_Accel_Group
(Window : not null access Gtk_Window_Record;
Accel_Group : not null access Gtk.Accel_Group.Gtk_Accel_Group_Record'Class);
-- Associate Accel_Group with Window, such that calling -- Gtk.Accel_Group.Accel_Groups_Activate on Window will activate -- accelerators in Accel_Group. -- "accel_group": a Gtk.Accel_Group.Gtk_Accel_Group procedure Add_Mnemonic
(Window : not null access Gtk_Window_Record;
Keyval : Gdk.Types.Gdk_Key_Type;
Target : not null access Gtk.Widget.Gtk_Widget_Record'Class);
-- Adds a mnemonic to this window. -- "keyval": the mnemonic -- "target": the widget that gets activated by the mnemonic procedure Begin_Move_Drag
(Window : not null access Gtk_Window_Record;
Button : Gint;
Root_X : Gint;
Root_Y : Gint;
Timestamp : Guint32);
-- Starts moving a window. This function is used if an application has -- window movement grips. When GDK can support it, the window movement will -- be done using the standard mechanism for the <link -- linkend="gtk-X11-arch">window manager</link> or windowing system. -- Otherwise, GDK will try to emulate window movement, potentially not all -- that well, depending on the windowing system. -- "button": mouse button that initiated the drag -- "root_x": X position where the user clicked to initiate the drag, in -- root window coordinates -- "root_y": Y position where the user clicked to initiate the drag -- "timestamp": timestamp from the click event that initiated the drag procedure Begin_Resize_Drag
(Window : not null access Gtk_Window_Record;
Edge : Gdk.Window.Gdk_Window_Edge;
Button : Gint;
Root_X : Gint;
Root_Y : Gint;
Timestamp : Guint32);
-- Starts resizing a window. This function is used if an application has -- window resizing controls. When GDK can support it, the resize will be -- done using the standard mechanism for the <link -- linkend="gtk-X11-arch">window manager</link> or windowing system. -- Otherwise, GDK will try to emulate window resizing, potentially not all -- that well, depending on the windowing system. -- "edge": position of the resize control -- "button": mouse button that initiated the drag -- "root_x": X position where the user clicked to initiate the drag, in -- root window coordinates -- "root_y": Y position where the user clicked to initiate the drag -- "timestamp": timestamp from the click event that initiated the drag procedure Deiconify (Window : not null access Gtk_Window_Record);
-- Asks to deiconify (i.e. unminimize) the specified Window. Note that you -- shouldn't assume the window is definitely deiconified afterward, because -- other entities (e.g. the user or <link linkend="gtk-X11-arch">window -- manager</link>) could iconify it again before your code which assumes -- deiconification gets to run. -- You can track iconification via the "window-state-event" signal on -- Gtk.Widget.Gtk_Widget. procedure Fullscreen (Window : not null access Gtk_Window_Record);
-- Asks to place Window in the fullscreen state. Note that you shouldn't -- assume the window is definitely full screen afterward, because other -- entities (e.g. the user or <link linkend="gtk-X11-arch">window -- manager</link>) could unfullscreen it again, and not all window managers -- honor requests to fullscreen windows. But normally the window will end -- up fullscreen. Just don't write code that crashes if not. -- You can track the fullscreen state via the "window-state-event" signal -- on Gtk.Widget.Gtk_Widget. -- Since: gtk+ 2.2 function Get_Accept_Focus
(Window : not null access Gtk_Window_Record) return Boolean;
-- Gets the value set by Gtk.Window.Set_Accept_Focus. -- Since: gtk+ 2.4 procedure Set_Accept_Focus
(Window : not null access Gtk_Window_Record;
Setting : Boolean);
-- Windows may set a hint asking the desktop environment not to receive -- the input focus. This function sets this hint. -- Since: gtk+ 2.4 -- "setting": True to let this window receive input focus function Get_Attached_To
(Window : not null access Gtk_Window_Record)
return Gtk.Widget.Gtk_Widget;
-- Fetches the attach widget for this window. See -- Gtk.Window.Set_Attached_To. -- Since: gtk+ 3.4 procedure Set_Attached_To
(Window : not null access Gtk_Window_Record;
Attach_Widget : access Gtk.Widget.Gtk_Widget_Record'Class);
-- Marks Window as attached to Attach_Widget. This creates a logical -- binding between the window and the widget it belongs to, which is used -- by GTK+ to propagate information such as styling or accessibility to -- Window as if it was a children of Attach_Widget. -- Examples of places where specifying this relation is useful are for -- instance a Gtk.Menu.Gtk_Menu created by a Gtk.Combo_Box.Gtk_Combo_Box, a -- completion popup window created by Gtk.GEntry.Gtk_Entry or a typeahead -- search entry created by Gtk.Tree_View.Gtk_Tree_View. -- Note that this function should not be confused with -- Gtk.Window.Set_Transient_For, which specifies a window manager relation -- between two toplevels instead. -- Passing null for Attach_Widget detaches the window. -- Since: gtk+ 3.4 -- "attach_widget": a Gtk.Widget.Gtk_Widget, or null function Get_Decorated
(Window : not null access Gtk_Window_Record) return Boolean;
-- Returns whether the window has been set to have decorations such as a -- title bar via Gtk.Window.Set_Decorated. procedure Set_Decorated
(Window : not null access Gtk_Window_Record;
Setting : Boolean);
-- By default, windows are decorated with a title bar, resize controls, -- etc. Some <link linkend="gtk-X11-arch">window managers</link> allow GTK+ -- to disable these decorations, creating a borderless window. If you set -- the decorated property to False using this function, GTK+ will do its -- best to convince the window manager not to decorate the window. -- Depending on the system, this function may not have any effect when -- called on a window that is already visible, so you should call it before -- calling Gtk.Widget.Show. -- On Windows, this function always works, since there's no window manager -- policy involved. -- "setting": True to decorate the window procedure Get_Default_Size
(Window : not null access Gtk_Window_Record;
Width : out Gint;
Height : out Gint);
-- Gets the default size of the window. A value of -1 for the width or -- height indicates that a default size has not been explicitly set for -- that dimension, so the "natural" size of the window will be used. -- "width": location to store the default width, or null -- "height": location to store the default height, or null procedure Set_Default_Size
(Window : not null access Gtk_Window_Record;
Width : Gint;
Height : Gint);
-- Sets the default size of a window. If the window's "natural" size (its -- size request) is larger than the default, the default will be ignored. -- More generally, if the default size does not obey the geometry hints for -- the window (gtk_window_set_geometry_hints can be used to set these -- explicitly), the default size will be clamped to the nearest permitted -- size. -- Unlike Gtk.Widget.Set_Size_Request, which sets a size request for a -- widget and thus would keep users from shrinking the window, this -- function only sets the initial size, just as if the user had resized the -- window themselves. Users can still shrink the window again as they -- normally would. Setting a default size of -1 means to use the "natural" -- default size (the size request of the window). -- For more control over a window's initial size and how resizing works, -- investigate Gtk.Window.Set_Geometry_Hints. -- For some uses, Gtk.Window.Resize is a more appropriate function. -- Gtk.Window.Resize changes the current size of the window, rather than -- the size to be used on initial display. Gtk.Window.Resize always affects -- the window itself, not the geometry widget. -- The default size of a window only affects the first time a window is -- shown; if a window is hidden and re-shown, it will remember the size it -- had prior to hiding, rather than using the default size. -- Windows can't actually be 0x0 in size, they must be at least 1x1, but -- passing 0 for Width and Height is OK, resulting in a 1x1 default size. -- "width": width in pixels, or -1 to unset the default width -- "height": height in pixels, or -1 to unset the default height function Get_Default_Widget
(Window : not null access Gtk_Window_Record)
return Gtk.Widget.Gtk_Widget;
-- Returns the default widget for Window. See Gtk.Window.Set_Default for -- more details. -- Since: gtk+ 2.14 function Get_Deletable
(Window : not null access Gtk_Window_Record) return Boolean;
-- Returns whether the window has been set to have a close button via -- Gtk.Window.Set_Deletable. -- Since: gtk+ 2.10 procedure Set_Deletable
(Window : not null access Gtk_Window_Record;
Setting : Boolean);
-- By default, windows have a close button in the window frame. Some <link -- linkend="gtk-X11-arch">window managers</link> allow GTK+ to disable this -- button. If you set the deletable property to False using this function, -- GTK+ will do its best to convince the window manager not to show a close -- button. Depending on the system, this function may not have any effect -- when called on a window that is already visible, so you should call it -- before calling Gtk.Widget.Show. -- On Windows, this function always works, since there's no window manager -- policy involved. -- Since: gtk+ 2.10 -- "setting": True to decorate the window as deletable function Get_Destroy_With_Parent
(Window : not null access Gtk_Window_Record) return Boolean;
-- Returns whether the window will be destroyed with its transient parent. -- See gtk_window_set_destroy_with_parent (). procedure Set_Destroy_With_Parent
(Window : not null access Gtk_Window_Record;
Setting : Boolean);
-- If Setting is True, then destroying the transient parent of Window will -- also destroy Window itself. This is useful for dialogs that shouldn't -- persist beyond the lifetime of the main window they're associated with, -- for example. -- "setting": whether to destroy Window with its transient parent function Get_Focus
(Window : not null access Gtk_Window_Record)
return Gtk.Widget.Gtk_Widget;
-- Retrieves the current focused widget within the window. Note that this -- is the widget that would have the focus if the toplevel window focused; -- if the toplevel window is not focused then 'gtk_widget_has_focus -- (widget)' will not be True for the widget. procedure Set_Focus
(Window : not null access Gtk_Window_Record;
Focus : access Gtk.Widget.Gtk_Widget_Record'Class);
-- If Focus is not the current focus widget, and is focusable, sets it as -- the focus widget for the window. If Focus is null, unsets the focus -- widget for this window. To set the focus to a particular widget in the -- toplevel, it is usually more convenient to use Gtk.Widget.Grab_Focus -- instead of this function. -- "focus": widget to be the new focus widget, or null to unset any focus -- widget for the toplevel window. function Get_Focus_On_Map
(Window : not null access Gtk_Window_Record) return Boolean;
-- Gets the value set by Gtk.Window.Set_Focus_On_Map. -- Since: gtk+ 2.6 procedure Set_Focus_On_Map
(Window : not null access Gtk_Window_Record;
Setting : Boolean);
-- Windows may set a hint asking the desktop environment not to receive -- the input focus when the window is mapped. This function sets this hint. -- Since: gtk+ 2.6 -- "setting": True to let this window receive input focus on map function Get_Focus_Visible
(Window : not null access Gtk_Window_Record) return Boolean;
-- Gets the value of the Gtk.Window.Gtk_Window:focus-visible property. -- Since: gtk+ 3.2 procedure Set_Focus_Visible
(Window : not null access Gtk_Window_Record;
Setting : Boolean);
-- Sets the Gtk.Window.Gtk_Window:focus-visible property. -- Since: gtk+ 3.2 -- "setting": the new value function Get_Gravity
(Window : not null access Gtk_Window_Record)
return Gdk.Window.Gdk_Gravity;
-- Gets the value set by Gtk.Window.Set_Gravity. procedure Set_Gravity
(Window : not null access Gtk_Window_Record;
Gravity : Gdk.Window.Gdk_Gravity);
-- Window gravity defines the meaning of coordinates passed to -- Gtk.Window.Move. See Gtk.Window.Move and Gdk.Window.Gdk_Gravity for more -- details. -- The default window gravity is GDK_GRAVITY_NORTH_WEST which will -- typically "do what you mean." -- "gravity": window gravity function Get_Group
(Window : not null access Gtk_Window_Record) return Gtk_Window_Group;
-- Returns the group for Window or the default group, if Window is null or -- if Window does not have an explicit window group. -- Since: gtk+ 2.10 function Get_Has_Resize_Grip
(Window : not null access Gtk_Window_Record) return Boolean;
-- Determines whether the window may have a resize grip. -- Since: gtk+ 3.0 procedure Set_Has_Resize_Grip
(Window : not null access Gtk_Window_Record;
Value : Boolean);
-- Sets whether Window has a corner resize grip. -- Note that the resize grip is only shown if the window is actually -- resizable and not maximized. Use Gtk.Window.Resize_Grip_Is_Visible to -- find out if the resize grip is currently shown. -- Since: gtk+ 3.0 -- "value": True to allow a resize grip function Get_Hide_Titlebar_When_Maximized
(Window : not null access Gtk_Window_Record) return Boolean;
-- Returns whether the window has requested to have its titlebar hidden -- when maximized. See gtk_window_set_hide_titlebar_when_maximized (). -- Since: gtk+ 3.4 procedure Set_Hide_Titlebar_When_Maximized
(Window : not null access Gtk_Window_Record;
Setting : Boolean);
-- If Setting is True, then Window will request that it's titlebar should -- be hidden when maximized. This is useful for windows that don't convey -- any information other than the application name in the titlebar, to put -- the available screen space to better use. If the underlying window -- system does not support the request, the setting will not have any -- effect. -- Since: gtk+ 3.4 -- "setting": whether to hide the titlebar when Window is maximized function Get_Icon
(Window : not null access Gtk_Window_Record)
return Gdk.Pixbuf.Gdk_Pixbuf;
-- Gets the value set by Gtk.Window.Set_Icon (or if you've called -- Gtk.Window.Set_Icon_List, gets the first icon in the icon list). procedure Set_Icon
(Window : not null access Gtk_Window_Record;
Icon : access Gdk.Pixbuf.Gdk_Pixbuf_Record'Class);
-- Sets up the icon representing a Gtk.Window.Gtk_Window. This icon is -- used when the window is minimized (also known as iconified). Some window -- managers or desktop environments may also place it in the window frame, -- or display it in other contexts. -- The icon should be provided in whatever size it was naturally drawn; -- that is, don't scale the image before passing it to GTK+. Scaling is -- postponed until the last minute, when the desired final size is known, -- to allow best quality. -- If you have your icon hand-drawn in multiple sizes, use -- Gtk.Window.Set_Icon_List. Then the best size will be used. -- This function is equivalent to calling Gtk.Window.Set_Icon_List with a -- 1-element list. -- See also Gtk.Window.Set_Default_Icon_List to set the icon for all -- windows in your application in one go. -- "icon": icon image, or null function Get_Icon_List
(Window : not null access Gtk_Window_Record)
return Glib.Object.Object_Simple_List.Glist;
-- Retrieves the list of icons set by Gtk.Window.Set_Icon_List. The list -- is copied, but the reference count on each member won't be incremented. procedure Set_Icon_List
(Window : not null access Gtk_Window_Record;
List : Glib.Object.Object_Simple_List.Glist);
-- Sets up the icon representing a Gtk.Window.Gtk_Window. The icon is used -- when the window is minimized (also known as iconified). Some window -- managers or desktop environments may also place it in the window frame, -- or display it in other contexts. -- Gtk.Window.Set_Icon_List allows you to pass in the same icon in several -- hand-drawn sizes. The list should contain the natural sizes your icon is -- available in; that is, don't scale the image before passing it to GTK+. -- Scaling is postponed until the last minute, when the desired final size -- is known, to allow best quality. -- By passing several sizes, you may improve the final image quality of -- the icon, by reducing or eliminating automatic image scaling. -- Recommended sizes to provide: 16x16, 32x32, 48x48 at minimum, and -- larger images (64x64, 128x128) if you have them. -- See also Gtk.Window.Set_Default_Icon_List to set the icon for all -- windows in your application in one go. -- Note that transient windows (those who have been set transient for -- another window using Gtk.Window.Set_Transient_For) will inherit their -- icon from their transient parent. So there's no need to explicitly set -- the icon on transient windows. -- "list": list of Gdk.Pixbuf.Gdk_Pixbuf function Get_Icon_Name
(Window : not null access Gtk_Window_Record) return UTF8_String;
-- Returns the name of the themed icon for the window, see -- Gtk.Window.Set_Icon_Name. -- Since: gtk+ 2.6 procedure Set_Icon_Name
(Window : not null access Gtk_Window_Record;
Name : UTF8_String := "");
-- Sets the icon for the window from a named themed icon. See the docs for -- Gtk.Icon_Theme.Gtk_Icon_Theme for more details. -- Note that this has nothing to do with the WM_ICON_NAME property which -- is mentioned in the ICCCM. -- Since: gtk+ 2.6 -- "name": the name of the themed icon function Get_Mnemonic_Modifier
(Window : not null access Gtk_Window_Record)
return Gdk.Types.Gdk_Modifier_Type;
-- Returns the mnemonic modifier for this window. See -- Gtk.Window.Set_Mnemonic_Modifier. procedure Set_Mnemonic_Modifier
(Window : not null access Gtk_Window_Record;
Modifier : Gdk.Types.Gdk_Modifier_Type);
-- Sets the mnemonic modifier for this window. -- "modifier": the modifier mask used to activate mnemonics on this -- window. function Get_Mnemonics_Visible
(Window : not null access Gtk_Window_Record) return Boolean;
-- Gets the value of the Gtk.Window.Gtk_Window:mnemonics-visible property. -- Since: gtk+ 2.20 procedure Set_Mnemonics_Visible
(Window : not null access Gtk_Window_Record;
Setting : Boolean);
-- Sets the Gtk.Window.Gtk_Window:mnemonics-visible property. -- Since: gtk+ 2.20 -- "setting": the new value function Get_Modal
(Window : not null access Gtk_Window_Record) return Boolean;
-- Returns whether the window is modal. See Gtk.Window.Set_Modal. procedure Set_Modal
(Window : not null access Gtk_Window_Record;
Modal : Boolean := True);
-- Sets a window modal or non-modal. Modal windows prevent interaction -- with other windows in the same application. To keep modal dialogs on top -- of main application windows, use Gtk.Window.Set_Transient_For to make -- the dialog transient for the parent; most <link -- linkend="gtk-X11-arch">window managers</link> will then disallow -- lowering the dialog below the parent. -- "modal": whether the window is modal procedure Get_Position
(Window : not null access Gtk_Window_Record;
Root_X : out Gint;
Root_Y : out Gint);
-- This function returns the position you need to pass to Gtk.Window.Move -- to keep Window in its current position. This means that the meaning of -- the returned value varies with window gravity. See Gtk.Window.Move for -- more details. -- If you haven't changed the window gravity, its gravity will be -- GDK_GRAVITY_NORTH_WEST. This means that Gtk.Window.Get_Position gets the -- position of the top-left corner of the window manager frame for the -- window. Gtk.Window.Move sets the position of this same top-left corner. -- Gtk.Window.Get_Position is not 100% reliable because the X Window -- System does not specify a way to obtain the geometry of the decorations -- placed on a window by the window manager. Thus GTK+ is using a "best -- guess" that works with most window managers. -- Moreover, nearly all window managers are historically broken with -- respect to their handling of window gravity. So moving a window to its -- current position as returned by Gtk.Window.Get_Position tends to result -- in moving the window slightly. Window managers are slowly getting better -- over time. -- If a window has gravity GDK_GRAVITY_STATIC the window manager frame is -- not relevant, and thus Gtk.Window.Get_Position will always produce -- accurate results. However you can't use static gravity to do things like -- place a window in a corner of the screen, because static gravity ignores -- the window manager decorations. -- If you are saving and restoring your application's window positions, -- you should know that it's impossible for applications to do this without -- getting it somewhat wrong because applications do not have sufficient -- knowledge of window manager state. The Correct Mechanism is to support -- the session management protocol (see the "GnomeClient" object in the -- GNOME libraries for example) and allow the window manager to save your -- window sizes and positions. -- "root_x": return location for X coordinate of gravity-determined -- reference point, or null -- "root_y": return location for Y coordinate of gravity-determined -- reference point, or null procedure Set_Position
(Window : not null access Gtk_Window_Record;
Position : Gtk.Enums.Gtk_Window_Position);
-- Sets a position constraint for this window. If the old or new -- constraint is Gtk.Enums.Win_Pos_Center_Always, this will also cause the -- window to be repositioned to satisfy the new constraint. -- "position": a position constraint. function Get_Resizable
(Window : not null access Gtk_Window_Record) return Boolean;
-- Gets the value set by Gtk.Window.Set_Resizable. procedure Set_Resizable
(Window : not null access Gtk_Window_Record;
Resizable : Boolean);
-- Sets whether the user can resize a window. Windows are user resizable -- by default. -- "resizable": True if the user can resize this window procedure Get_Resize_Grip_Area
(Window : not null access Gtk_Window_Record;
Rect : out Gdk.Rectangle.Gdk_Rectangle;
retrieved : out Boolean);
-- If a window has a resize grip, this will retrieve the grip position, -- width and height into the specified Gdk.Rectangle.Gdk_Rectangle. -- Since: gtk+ 3.0 -- "rect": a pointer to a Gdk.Rectangle.Gdk_Rectangle which we should -- store the resize grip area function Get_Role
(Window : not null access Gtk_Window_Record) return UTF8_String;
-- Returns the role of the window. See Gtk.Window.Set_Role for further -- explanation. procedure Set_Role
(Window : not null access Gtk_Window_Record;
Role : UTF8_String);
-- This function is only useful on X11, not with other GTK+ targets. -- In combination with the window title, the window role allows a <link -- linkend="gtk-X11-arch">window manager</link> to identify "the same" -- window when an application is restarted. So for example you might set -- the "toolbox" role on your app's toolbox window, so that when the user -- restarts their session, the window manager can put the toolbox back in -- the same place. -- If a window already has a unique title, you don't need to set the role, -- since the WM can use the title to identify the window when restoring the -- session. -- "role": unique identifier for the window to be used when restoring a -- session function Get_Screen
(Window : not null access Gtk_Window_Record)
return Gdk.Screen.Gdk_Screen;
-- Returns the Gdk.Screen.Gdk_Screen associated with Window. -- Since: gtk+ 2.2 procedure Set_Screen
(Window : not null access Gtk_Window_Record;
Screen : not null access Gdk.Screen.Gdk_Screen_Record'Class);
-- Sets the Gdk.Screen.Gdk_Screen where the Window is displayed; if the -- window is already mapped, it will be unmapped, and then remapped on the -- new screen. -- Since: gtk+ 2.2 -- "screen": a Gdk.Screen.Gdk_Screen. procedure Get_Size
(Window : not null access Gtk_Window_Record;
Width : out Gint;
Height : out Gint);
-- Obtains the current size of Window. If Window is not onscreen, it -- returns the size GTK+ will suggest to the <link -- linkend="gtk-X11-arch">window manager</link> for the initial window size -- (but this is not reliably the same as the size the window manager will -- actually select). The size obtained by Gtk.Window.Get_Size is the last -- size received in a Gdk.Event.Gdk_Event_Configure, that is, GTK+ uses its -- locally-stored size, rather than querying the X server for the size. As -- a result, if you call Gtk.Window.Resize then immediately call -- Gtk.Window.Get_Size, the size won't have taken effect yet. After the -- window manager processes the resize request, GTK+ receives notification -- that the size has changed via a configure event, and the size of the -- window gets updated. -- Note 1: Nearly any use of this function creates a race condition, -- because the size of the window may change between the time that you get -- the size and the time that you perform some action assuming that size is -- the current size. To avoid race conditions, connect to "configure-event" -- on the window and adjust your size-dependent state to match the size -- delivered in the Gdk.Event.Gdk_Event_Configure. -- Note 2: The returned size does *not* include the size of the window -- manager decorations (aka the window frame or border). Those are not -- drawn by GTK+ and GTK+ has no reliable method of determining their size. -- Note 3: If you are getting a window size in order to position the -- window onscreen, there may be a better way. The preferred way is to -- simply set the window's semantic type with Gtk.Window.Set_Type_Hint, -- which allows the window manager to e.g. center dialogs. Also, if you set -- the transient parent of dialogs with Gtk.Window.Set_Transient_For window -- managers will often center the dialog over its parent window. It's much -- preferred to let the window manager handle these things rather than -- doing it yourself, because all apps will behave consistently and -- according to user prefs if the window manager handles it. Also, the -- window manager can take the size of the window decorations/border into -- account, while your application cannot. -- In any case, if you insist on application-specified window positioning, -- there's *still* a better way than doing it yourself - -- Gtk.Window.Set_Position will frequently handle the details for you. -- "width": return location for width, or null -- "height": return location for height, or null function Get_Skip_Pager_Hint
(Window : not null access Gtk_Window_Record) return Boolean;
-- Gets the value set by Gtk.Window.Set_Skip_Pager_Hint. -- Since: gtk+ 2.2 procedure Set_Skip_Pager_Hint
(Window : not null access Gtk_Window_Record;
Setting : Boolean);
-- Windows may set a hint asking the desktop environment not to display -- the window in the pager. This function sets this hint. (A "pager" is any -- desktop navigation tool such as a workspace switcher that displays a -- thumbnail representation of the windows on the screen.) -- Since: gtk+ 2.2 -- "setting": True to keep this window from appearing in the pager function Get_Skip_Taskbar_Hint
(Window : not null access Gtk_Window_Record) return Boolean;
-- Gets the value set by Gtk.Window.Set_Skip_Taskbar_Hint -- Since: gtk+ 2.2 procedure Set_Skip_Taskbar_Hint
(Window : not null access Gtk_Window_Record;
Setting : Boolean);
-- Windows may set a hint asking the desktop environment not to display -- the window in the task bar. This function sets this hint. -- Since: gtk+ 2.2 -- "setting": True to keep this window from appearing in the task bar function Get_Title
(Window : not null access Gtk_Window_Record) return UTF8_String;
-- Retrieves the title of the window. See Gtk.Window.Set_Title. procedure Set_Title
(Window : not null access Gtk_Window_Record;
Title : UTF8_String);
-- Sets the title of the Gtk.Window.Gtk_Window. The title of a window will -- be displayed in its title bar; on the X Window System, the title bar is -- rendered by the <link linkend="gtk-X11-arch">window manager</link>, so -- exactly how the title appears to users may vary according to a user's -- exact configuration. The title should help a user distinguish this -- window from other windows they may have open. A good title might include -- the application name and current document filename, for example. -- "title": title of the window function Get_Transient_For
(Window : not null access Gtk_Window_Record) return Gtk_Window;
-- Fetches the transient parent for this window. See -- Gtk.Window.Set_Transient_For. procedure Set_Transient_For
(Window : not null access Gtk_Window_Record;
Parent : access Gtk_Window_Record'Class);
-- Dialog windows should be set transient for the main application window -- they were spawned from. This allows <link linkend="gtk-X11-arch">window -- managers</link> to e.g. keep the dialog on top of the main window, or -- center the dialog over the main window. gtk_dialog_new_with_buttons and -- other convenience functions in GTK+ will sometimes call -- Gtk.Window.Set_Transient_For on your behalf. -- Passing null for Parent unsets the current transient window. -- On Windows, this function puts the child window on top of the parent, -- much as the window manager would have done on X. -- "parent": parent window, or null function Get_Type_Hint
(Window : not null access Gtk_Window_Record)
return Gdk.Window.Gdk_Window_Type_Hint;
-- Gets the type hint for this window. See Gtk.Window.Set_Type_Hint. procedure Set_Type_Hint
(Window : not null access Gtk_Window_Record;
Hint : Gdk.Window.Gdk_Window_Type_Hint);
-- By setting the type hint for the window, you allow the window manager -- to decorate and handle the window in a way which is suitable to the -- function of the window in your application. -- This function should be called before the window becomes visible. -- gtk_dialog_new_with_buttons and other convenience functions in GTK+ -- will sometimes call Gtk.Window.Set_Type_Hint on your behalf. -- "hint": the window type function Get_Urgency_Hint
(Window : not null access Gtk_Window_Record) return Boolean;
-- Gets the value set by Gtk.Window.Set_Urgency_Hint -- Since: gtk+ 2.8 procedure Set_Urgency_Hint
(Window : not null access Gtk_Window_Record;
Setting : Boolean);
-- Windows may set a hint asking the desktop environment to draw the users -- attention to the window. This function sets this hint. -- Since: gtk+ 2.8 -- "setting": True to mark this window as urgent function Get_Window_Type
(Window : not null access Gtk_Window_Record)
return Gtk.Enums.Gtk_Window_Type;
-- Gets the type of the window. See Gtk.Enums.Gtk_Window_Type. -- Since: gtk+ 2.20 function Has_Group
(Window : not null access Gtk_Window_Record) return Boolean;
-- Returns whether Window has an explicit window group. function Has_Toplevel_Focus
(Window : not null access Gtk_Window_Record) return Boolean;
-- Returns whether the input focus is within this GtkWindow. For real -- toplevel windows, this is identical to Gtk.Window.Is_Active, but for -- embedded windows, like Gtk_Plug, the results will differ. -- Since: gtk+ 2.4 procedure Iconify (Window : not null access Gtk_Window_Record);
-- Asks to iconify (i.e. minimize) the specified Window. Note that you -- shouldn't assume the window is definitely iconified afterward, because -- other entities (e.g. the user or <link linkend="gtk-X11-arch">window -- manager</link>) could deiconify it again, or there may not be a window -- manager in which case iconification isn't possible, etc. But normally -- the window will end up iconified. Just don't write code that crashes if -- not. -- It's permitted to call this function before showing a window, in which -- case the window will be iconified before it ever appears onscreen. -- You can track iconification via the "window-state-event" signal on -- Gtk.Widget.Gtk_Widget. function Is_Active
(Window : not null access Gtk_Window_Record) return Boolean;
-- Returns whether the window is part of the current active toplevel. -- (That is, the toplevel window receiving keystrokes.) The return value is -- True if the window is active toplevel itself, but also if it is, say, a -- Gtk_Plug embedded in the active toplevel. You might use this function if -- you wanted to draw a widget differently in an active window from a -- widget in an inactive window. See Gtk.Window.Has_Toplevel_Focus -- Since: gtk+ 2.4 procedure Maximize (Window : not null access Gtk_Window_Record);
-- Asks to maximize Window, so that it becomes full-screen. Note that you -- shouldn't assume the window is definitely maximized afterward, because -- other entities (e.g. the user or <link linkend="gtk-X11-arch">window -- manager</link>) could unmaximize it again, and not all window managers -- support maximization. But normally the window will end up maximized. -- Just don't write code that crashes if not. -- It's permitted to call this function before showing a window, in which -- case the window will be maximized when it appears onscreen initially. -- You can track maximization via the "window-state-event" signal on -- Gtk.Widget.Gtk_Widget. function Mnemonic_Activate
(Window : not null access Gtk_Window_Record;
Keyval : Gdk.Types.Gdk_Key_Type;
Modifier : Gdk.Types.Gdk_Modifier_Type) return Boolean;
-- Activates the targets associated with the mnemonic. -- "keyval": the mnemonic -- "modifier": the modifiers procedure Move
(Window : not null access Gtk_Window_Record;
X : Gint;
Y : Gint);
-- Asks the <link linkend="gtk-X11-arch">window manager</link> to move -- Window to the given position. Window managers are free to ignore this; -- most window managers ignore requests for initial window positions -- (instead using a user-defined placement algorithm) and honor requests -- after the window has already been shown. -- Note: the position is the position of the gravity-determined reference -- point for the window. The gravity determines two things: first, the -- location of the reference point in root window coordinates; and second, -- which point on the window is positioned at the reference point. -- By default the gravity is GDK_GRAVITY_NORTH_WEST, so the reference -- point is simply the X, Y supplied to Gtk.Window.Move. The top-left -- corner of the window decorations (aka window frame or border) will be -- placed at X, Y. Therefore, to position a window at the top left of the -- screen, you want to use the default gravity (which is -- GDK_GRAVITY_NORTH_WEST) and move the window to 0,0. -- To position a window at the bottom right corner of the screen, you -- would set GDK_GRAVITY_SOUTH_EAST, which means that the reference point -- is at X + the window width and Y + the window height, and the -- bottom-right corner of the window border will be placed at that -- reference point. So, to place a window in the bottom right corner you -- would first set gravity to south east, then write: 'gtk_window_move -- (window, gdk_screen_width () - window_width, gdk_screen_height () - -- window_height)' (note that this example does not take multi-head -- scenarios into account). -- The Extended Window Manager Hints specification at <ulink -- url="http://www.freedesktop.org/Standards/wm-spec"> -- http://www.freedesktop.org/Standards/wm-spec</ulink> has a nice table of -- gravities in the "implementation notes" section. -- The Gtk.Window.Get_Position documentation may also be relevant. -- "x": X coordinate to move window to -- "y": Y coordinate to move window to function Parse_Geometry
(Window : not null access Gtk_Window_Record;
Geometry : UTF8_String) return Boolean;
-- Parses a standard X Window System geometry string - see the manual page -- for X (type 'man X') for details on this. Gtk.Window.Parse_Geometry does -- work on all GTK+ ports including Win32 but is primarily intended for an -- X environment. -- If either a size or a position can be extracted from the geometry -- string, Gtk.Window.Parse_Geometry returns True and calls -- Gtk.Window.Set_Default_Size and/or Gtk.Window.Move to resize/move the -- window. -- If Gtk.Window.Parse_Geometry returns True, it will also set the -- GDK_HINT_USER_POS and/or GDK_HINT_USER_SIZE hints indicating to the -- window manager that the size/position of the window was user-specified. -- This causes most window managers to honor the geometry. -- Note that for Gtk.Window.Parse_Geometry to work as expected, it has to -- be called when the window has its "final" size, i.e. after calling -- Gtk.Widget.Show_All on the contents and Gtk.Window.Set_Geometry_Hints on -- the window. |[ include <gtk/gtk.h> static void fill_with_content -- (GtkWidget *vbox) { /* fill with content... */ } 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_box_new (GTK_ORIENTATION_VERTICAL, 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; } ]| -- "geometry": geometry string procedure Present (Window : not null access Gtk_Window_Record);
-- Presents a window to the user. This may mean raising the window in the -- stacking order, deiconifying it, moving it to the current desktop, -- and/or giving it the keyboard focus, possibly dependent on the user's -- platform, window manager, and preferences. -- If Window is hidden, this function calls Gtk.Widget.Show as well. -- This function should be used when the user tries to open a window -- that's already open. Say for example the preferences dialog is currently -- open, and the user chooses Preferences from the menu a second time; use -- Gtk.Window.Present to move the already-open dialog where the user can -- see it. -- If you are calling this function in response to a user interaction, it -- is preferable to use Gtk.Window.Present_With_Time. procedure Present_With_Time
(Window : not null access Gtk_Window_Record;
Timestamp : Guint32);
-- Presents a window to the user in response to a user interaction. If you -- need to present a window without a timestamp, use Gtk.Window.Present. -- See Gtk.Window.Present for details. -- Since: gtk+ 2.8 -- "timestamp": the timestamp of the user interaction (typically a button -- or key press event) which triggered this call function Propagate_Key_Event
(Window : not null access Gtk_Window_Record;
Event : Gdk.Event.Gdk_Event_Key) return Boolean;
-- Propagate a key press or release event to the focus widget and up the -- focus container chain until a widget handles Event. This is normally -- called by the default ::key_press_event and ::key_release_event handlers -- for toplevel windows, however in some cases it may be useful to call -- this directly when overriding the standard key handling for a toplevel -- window. -- Since: gtk+ 2.4 -- "event": a Gdk.Event.Gdk_Event_Key procedure Remove_Accel_Group
(Window : not null access Gtk_Window_Record;
Accel_Group : not null access Gtk.Accel_Group.Gtk_Accel_Group_Record'Class);
-- Reverses the effects of Gtk.Window.Add_Accel_Group. -- "accel_group": a Gtk.Accel_Group.Gtk_Accel_Group procedure Remove_Mnemonic
(Window : not null access Gtk_Window_Record;
Keyval : Gdk.Types.Gdk_Key_Type;
Target : not null access Gtk.Widget.Gtk_Widget_Record'Class);
-- Removes a mnemonic from this window. -- "keyval": the mnemonic -- "target": the widget that gets activated by the mnemonic procedure Reshow_With_Initial_Size
(Window : not null access Gtk_Window_Record);
-- Hides Window, then reshows it, resetting the default size and position -- of the window. Used by GUI builders only. procedure Resize
(Window : not null access Gtk_Window_Record;
Width : Gint;
Height : Gint);
-- Resizes the window as if the user had done so, obeying geometry -- constraints. The default geometry constraint is that windows may not be -- smaller than their size request; to override this constraint, call -- Gtk.Widget.Set_Size_Request to set the window's request to a smaller -- value. -- If Gtk.Window.Resize is called before showing a window for the first -- time, it overrides any default size set with -- Gtk.Window.Set_Default_Size. -- Windows may not be resized smaller than 1 by 1 pixels. -- "width": width in pixels to resize the window to -- "height": height in pixels to resize the window to function Resize_Grip_Is_Visible
(Window : not null access Gtk_Window_Record) return Boolean;
-- Determines whether a resize grip is visible for the specified window. -- Since: gtk+ 3.0 procedure Resize_To_Geometry
(Window : not null access Gtk_Window_Record;
Width : Gint;
Height : Gint);
-- Like Gtk.Window.Resize, but Width and Height are interpreted in terms -- of the base size and increment set with gtk_window_set_geometry_hints. -- Since: gtk+ 3.0 -- "width": width in resize increments to resize the window to -- "height": height in resize increments to resize the window to procedure Set_Default
(Window : not null access Gtk_Window_Record;
Default_Widget : access Gtk.Widget.Gtk_Widget_Record'Class);
-- The default widget is the widget that's activated when the user presses -- Enter in a dialog (for example). This function sets or unsets the -- default widget for a Gtk.Window.Gtk_Window about. When setting (rather -- than unsetting) the default widget it's generally easier to call -- Gtk.Widget.Grab_Focus on the widget. Before making a widget the default -- widget, you must call Gtk.Widget.Set_Can_Default on the widget you'd -- like to make the default. -- "default_widget": widget to be the default, or null to unset the -- default widget for the toplevel. procedure Set_Default_Geometry
(Window : not null access Gtk_Window_Record;
Width : Gint;
Height : Gint);
-- Like Gtk.Window.Set_Default_Size, but Width and Height are interpreted -- in terms of the base size and increment set with -- gtk_window_set_geometry_hints. -- Since: gtk+ 3.0 -- "width": width in resize increments, or -1 to unset the default width -- "height": height in resize increments, or -1 to unset the default -- height procedure Set_Geometry_Hints
(Window : not null access Gtk_Window_Record;
Geometry_Widget : access Gtk.Widget.Gtk_Widget_Record'Class;
Geometry : Gdk.Window.Gdk_Geometry;
Geom_Mask : Gdk.Window.Gdk_Window_Hints);
-- This function sets up hints about how a window can be resized by the -- user. You can set a minimum and maximum size; allowed resize increments -- (e.g. for xterm, you can only resize by the size of a character); aspect -- ratios; and more. See the Gdk.Window.Gdk_Geometry struct. -- "geometry_widget": widget the geometry hints will be applied to or null -- "geometry": struct containing geometry information or null -- "geom_mask": mask indicating which struct fields should be paid -- attention to procedure Set_Has_User_Ref_Count
(Window : not null access Gtk_Window_Record;
Setting : Boolean);
-- Tells GTK+ whether to drop its extra reference to the window when -- Gtk.Widget.Destroy is called. -- This function is only exported for the benefit of language bindings -- which may need to keep the window alive until their wrapper object is -- garbage collected. There is no justification for ever calling this -- function in an application. -- Since: gtk+ 3.0 -- "setting": the new value function Set_Icon_From_File
(Window : not null access Gtk_Window_Record;
Filename : UTF8_String) return Boolean;
-- Sets the icon for Window. Warns on failure if Err is null. -- This function is equivalent to calling Gtk.Window.Set_Icon with a -- pixbuf created by loading the image from Filename. -- Since: gtk+ 2.2 -- "filename": location of icon file procedure Set_Keep_Above
(Window : not null access Gtk_Window_Record;
Setting : Boolean);
-- Asks to keep Window above, so that it stays on top. Note that you -- shouldn't assume the window is definitely above afterward, because other -- entities (e.g. the user or <link linkend="gtk-X11-arch">window -- manager</link>) could not keep it above, and not all window managers -- support keeping windows above. But normally the window will end kept -- above. Just don't write code that crashes if not. -- It's permitted to call this function before showing a window, in which -- case the window will be kept above when it appears onscreen initially. -- You can track the above state via the "window-state-event" signal on -- Gtk.Widget.Gtk_Widget. -- Note that, according to the <ulink -- url="http://www.freedesktop.org/Standards/wm-spec">Extended Window -- Manager Hints</ulink> specification, the above state is mainly meant for -- user preferences and should not be used by applications e.g. for drawing -- attention to their dialogs. -- Since: gtk+ 2.4 -- "setting": whether to keep Window above other windows procedure Set_Keep_Below
(Window : not null access Gtk_Window_Record;
Setting : Boolean);
-- Asks to keep Window below, so that it stays in bottom. Note that you -- shouldn't assume the window is definitely below afterward, because other -- entities (e.g. the user or <link linkend="gtk-X11-arch">window -- manager</link>) could not keep it below, and not all window managers -- support putting windows below. But normally the window will be kept -- below. Just don't write code that crashes if not. -- It's permitted to call this function before showing a window, in which -- case the window will be kept below when it appears onscreen initially. -- You can track the below state via the "window-state-event" signal on -- Gtk.Widget.Gtk_Widget. -- Note that, according to the <ulink -- url="http://www.freedesktop.org/Standards/wm-spec">Extended Window -- Manager Hints</ulink> specification, the above state is mainly meant for -- user preferences and should not be used by applications e.g. for drawing -- attention to their dialogs. -- Since: gtk+ 2.4 -- "setting": whether to keep Window below other windows procedure Set_Startup_Id
(Window : not null access Gtk_Window_Record;
Startup_Id : UTF8_String);
-- Startup notification identifiers are used by desktop environment to -- track application startup, to provide user feedback and other features. -- This function changes the corresponding property on the underlying -- GdkWindow. Normally, startup identifier is managed automatically and you -- should only use this function in special cases like transferring focus -- from other processes. You should use this function before calling -- Gtk.Window.Present or any equivalent function generating a window map -- event. -- This function is only useful on X11, not with other GTK+ targets. -- Since: gtk+ 2.12 -- "startup_id": a string with startup-notification identifier procedure Set_Wmclass
(Window : not null access Gtk_Window_Record;
Wmclass_Name : UTF8_String;
Wmclass_Class : UTF8_String);
-- Don't use this function. It sets the X Window System "class" and "name" -- hints for a window. According to the ICCCM, you should always set these -- to the same value for all windows in an application, and GTK+ sets them -- to that value by default, so calling this function is sort of pointless. -- However, you may want to call Gtk.Window.Set_Role on each window in your -- application, for the benefit of the session manager. Setting the role -- allows the window manager to restore window positions when loading a -- saved session. -- "wmclass_name": window name hint -- "wmclass_class": window class hint procedure Stick (Window : not null access Gtk_Window_Record);
-- Asks to stick Window, which means that it will appear on all user -- desktops. Note that you shouldn't assume the window is definitely stuck -- afterward, because other entities (e.g. the user or <link -- linkend="gtk-X11-arch">window manager</link>) could unstick it again, -- and some window managers do not support sticking windows. But normally -- the window will end up stuck. Just don't write code that crashes if not. -- It's permitted to call this function before showing a window. -- You can track stickiness via the "window-state-event" signal on -- Gtk.Widget.Gtk_Widget. procedure Unfullscreen (Window : not null access Gtk_Window_Record);
-- Asks to toggle off the fullscreen state for Window. Note that you -- shouldn't assume the window is definitely not full screen afterward, -- because other entities (e.g. the user or <link -- linkend="gtk-X11-arch">window manager</link>) could fullscreen it again, -- and not all window managers honor requests to unfullscreen windows. But -- normally the window will end up restored to its normal state. Just don't -- write code that crashes if not. -- You can track the fullscreen state via the "window-state-event" signal -- on Gtk.Widget.Gtk_Widget. -- Since: gtk+ 2.2 procedure Unmaximize (Window : not null access Gtk_Window_Record);
-- Asks to unmaximize Window. Note that you shouldn't assume the window is -- definitely unmaximized afterward, because other entities (e.g. the user -- or <link linkend="gtk-X11-arch">window manager</link>) could maximize it -- again, and not all window managers honor requests to unmaximize. But -- normally the window will end up unmaximized. Just don't write code that -- crashes if not. -- You can track maximization via the "window-state-event" signal on -- Gtk.Widget.Gtk_Widget. procedure Unstick (Window : not null access Gtk_Window_Record);
-- Asks to unstick Window, which means that it will appear on only one of -- the user's desktops. Note that you shouldn't assume the window is -- definitely unstuck afterward, because other entities (e.g. the user or -- <link linkend="gtk-X11-arch">window manager</link>) could stick it -- again. But normally the window will end up stuck. Just don't write code -- that crashes if not. -- You can track stickiness via the "window-state-event" signal on -- Gtk.Widget.Gtk_Widget. procedure Add_Window
(Window_Group : not null access Gtk_Window_Group_Record;
Window : not null access Gtk_Window_Record'Class);
-- Adds a window to a Gtk.Window.Gtk_Window_Group. -- "window": the Gtk.Window.Gtk_Window to add function Get_Current_Device_Grab
(Window_Group : not null access Gtk_Window_Group_Record;
Device : not null access Gdk.Device.Gdk_Device_Record'Class)
return Gtk.Widget.Gtk_Widget;
-- Returns the current grab widget for Device, or null if none. -- Since: gtk+ 3.0 -- "device": a Gdk.Device.Gdk_Device function Get_Current_Grab
(Window_Group : not null access Gtk_Window_Group_Record)
return Gtk.Widget.Gtk_Widget;
-- Gets the current grab widget of the given group, see -- Gtk.Widget.Grab_Add. -- Since: gtk+ 2.22 function List_Windows
(Window_Group : not null access Gtk_Window_Group_Record)
return Gtk.Widget.Widget_List.Glist;
-- Returns a list of the Gtk_Windows that belong to Window_Group. -- Since: gtk+ 2.14 procedure Remove_Window
(Window_Group : not null access Gtk_Window_Group_Record;
Window : not null access Gtk_Window_Record'Class);
-- Removes a window from a Gtk.Window.Gtk_Window_Group. -- "window": the Gtk.Window.Gtk_Window to remove --------------- -- Functions -- --------------- function Get_Default_Icon_List return Glib.Object.Object_Simple_List.Glist;
-- Gets the value set by Gtk.Window.Set_Default_Icon_List. The list is a -- copy and should be freed with g_list_free, but the pixbufs in the list -- have not had their reference count incremented. procedure Set_Default_Icon_List
(List : Glib.Object.Object_Simple_List.Glist);
-- Sets an icon list to be used as fallback for windows that haven't had -- Gtk.Window.Set_Icon_List called on them to set up a window-specific icon -- list. This function allows you to set up the icon for all windows in -- your app at once. -- See Gtk.Window.Set_Icon_List for more details. -- "list": a list of Gdk.Pixbuf.Gdk_Pixbuf function Get_Default_Icon_Name return UTF8_String;
-- Returns the fallback icon name for windows that has been set with -- Gtk.Window.Set_Default_Icon_Name. The returned string is owned by GTK+ -- and should not be modified. It is only valid until the next call to -- Gtk.Window.Set_Default_Icon_Name. -- Since: gtk+ 2.16 procedure Set_Default_Icon_Name (Name : UTF8_String);
-- Sets an icon to be used as fallback for windows that haven't had -- Gtk.Window.Set_Icon_List called on them from a named themed icon, see -- Gtk.Window.Set_Icon_Name. -- Since: gtk+ 2.6 -- "name": the name of the themed icon function List_Toplevels return Gtk.Widget.Widget_List.Glist;
-- Returns a list of all existing toplevel windows. The widgets in the -- list are not individually referenced. If you want to iterate through the -- list and perform actions involving callbacks that might destroy the -- widgets, you *must* call 'g_list_foreach (result, (GFunc)g_object_ref, -- NULL)' first, and then unref all the widgets afterwards. procedure Set_Auto_Startup_Notification (Setting : Boolean);
-- By default, after showing the first Gtk.Window.Gtk_Window, GTK+ calls -- gdk_notify_startup_complete. Call this function to disable the automatic -- startup notification. You might do this if your first window is a splash -- screen, and you want to delay notification until after your real main -- window has been shown, for example. -- In that example, you would disable startup notification temporarily, -- show your splash screen, then re-enable it so that showing the main -- window would automatically result in notification. -- Since: gtk+ 2.2 -- "setting": True to automatically do startup notification procedure Set_Default_Icon
(Icon : not null access Gdk.Pixbuf.Gdk_Pixbuf_Record'Class);
-- Sets an icon to be used as fallback for windows that haven't had -- Gtk.Window.Set_Icon called on them from a pixbuf. -- Since: gtk+ 2.4 -- "icon": the icon function Set_Default_Icon_From_File
(Filename : UTF8_String) return Boolean;
-- Sets an icon to be used as fallback for windows that haven't had -- Gtk.Window.Set_Icon_List called on them from a file on disk. Warns on -- failure if Err is null. -- Since: gtk+ 2.2 -- "filename": location of icon file ---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Accept_Focus_Property : constant Glib.Properties.Property_Boolean;
-- Whether the window should receive the input focus. Application_Property : constant Glib.Properties.Property_Object;
-- Type: Gtk.Application.Gtk_Application -- The Gtk.Application.Gtk_Application associated with the window. -- -- The application will be kept alive for at least as long as it has any -- windows associated with it (see Glib.Application.Hold for a way to keep -- it alive without windows). -- -- Normally, the connection between the application and the window will -- remain until the window is destroyed, but you can explicitly remove it -- by setting the ::application property to null. Attached_To_Property : constant Glib.Properties.Property_Object;
-- Type: Gtk.Widget.Gtk_Widget -- The widget to which this window is attached. See -- Gtk.Window.Set_Attached_To. -- -- Examples of places where specifying this relation is useful are for -- instance a Gtk.Menu.Gtk_Menu created by a Gtk.Combo_Box.Gtk_Combo_Box, a -- completion popup window created by Gtk.GEntry.Gtk_Entry or a typeahead -- search entry created by Gtk.Tree_View.Gtk_Tree_View. Decorated_Property : constant Glib.Properties.Property_Boolean;
-- Whether the window should be decorated by the window manager. Default_Height_Property : constant Glib.Properties.Property_Int;
Default_Width_Property : constant Glib.Properties.Property_Int;
Deletable_Property : constant Glib.Properties.Property_Boolean;
-- Whether the window frame should have a close button. Destroy_With_Parent_Property : constant Glib.Properties.Property_Boolean;
Focus_On_Map_Property : constant Glib.Properties.Property_Boolean;
-- Whether the window should receive the input focus when mapped. Focus_Visible_Property : constant Glib.Properties.Property_Boolean;
-- Whether 'focus rectangles' are currently visible in this window. -- -- This property is maintained by GTK+ based on the -- Gtk.Settings.Gtk_Settings:gtk-visible-focus setting and user input and -- should not be set by applications. Gravity_Property : constant Gdk.Window.Property_Gdk_Gravity;
-- Type: Gdk.Window.Gdk_Gravity -- The window gravity of the window. See Gtk.Window.Move and -- Gdk.Window.Gdk_Gravity for more details about window gravity. Has_Resize_Grip_Property : constant Glib.Properties.Property_Boolean;
-- Whether the window has a corner resize grip. -- -- Note that the resize grip is only shown if the window is actually -- resizable and not maximized. Use -- Gtk.Window.Gtk_Window:resize-grip-visible to find out if the resize grip -- is currently shown. Has_Toplevel_Focus_Property : constant Glib.Properties.Property_Boolean;
Hide_Titlebar_When_Maximized_Property : constant Glib.Properties.Property_Boolean;
-- Whether the titlebar should be hidden during maximization. Icon_Property : constant Glib.Properties.Property_Object;
-- Type: Gdk.Pixbuf.Gdk_Pixbuf Icon_Name_Property : constant Glib.Properties.Property_String;
-- The :icon-name property specifies the name of the themed icon to use as -- the window icon. See Gtk.Icon_Theme.Gtk_Icon_Theme for more details. Is_Active_Property : constant Glib.Properties.Property_Boolean;
Mnemonics_Visible_Property : constant Glib.Properties.Property_Boolean;
-- Whether mnemonics are currently visible in this window. -- -- This property is maintained by GTK+ based on the -- Gtk.Settings.Gtk_Settings:gtk-auto-mnemonics setting and user input, and -- should not be set by applications. Modal_Property : constant Glib.Properties.Property_Boolean;
Resizable_Property : constant Glib.Properties.Property_Boolean;
Resize_Grip_Visible_Property : constant Glib.Properties.Property_Boolean;
-- Whether a corner resize grip is currently shown. Role_Property : constant Glib.Properties.Property_String;
Screen_Property : constant Glib.Properties.Property_Object;
-- Type: Gdk.Screen.Gdk_Screen Skip_Pager_Hint_Property : constant Glib.Properties.Property_Boolean;
Skip_Taskbar_Hint_Property : constant Glib.Properties.Property_Boolean;
Startup_Id_Property : constant Glib.Properties.Property_String;
-- Flags: write -- The :startup-id is a write-only property for setting window's startup -- notification identifier. See Gtk.Window.Set_Startup_Id for more details. Title_Property : constant Glib.Properties.Property_String;
Transient_For_Property : constant Glib.Properties.Property_Object;
-- Type: Gtk_Window -- The transient parent of the window. See Gtk.Window.Set_Transient_For -- for more details about transient windows. The_Type_Property : constant Gtk.Enums.Property_Gtk_Window_Type;
Type_Hint_Property : constant Gdk.Window.Property_Gdk_Window_Type_Hint;
-- Type: Gdk.Window.Gdk_Window_Type_Hint Urgency_Hint_Property : constant Glib.Properties.Property_Boolean;
Window_Position_Property : constant Gtk.Enums.Property_Gtk_Window_Position;
------------- -- Signals -- ------------- type Cb_Gtk_Window_Void is not null access procedure (Self : access Gtk_Window_Record'Class);
type Cb_GObject_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class);
Signal_Activate_Default : constant Glib.Signal_Name := "activate-default";
procedure On_Activate_Default
(Self : not null access Gtk_Window_Record;
Call : Cb_Gtk_Window_Void;
After : Boolean := False);
procedure On_Activate_Default
(Self : not null access Gtk_Window_Record;
Call : Cb_GObject_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The ::activate-default signal is a <link -- linkend="keybinding-signals">keybinding signal</link> which gets emitted -- when the user activates the default widget of Window. Signal_Activate_Focus : constant Glib.Signal_Name := "activate-focus";
procedure On_Activate_Focus
(Self : not null access Gtk_Window_Record;
Call : Cb_Gtk_Window_Void;
After : Boolean := False);
procedure On_Activate_Focus
(Self : not null access Gtk_Window_Record;
Call : Cb_GObject_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The ::activate-focus signal is a <link -- linkend="keybinding-signals">keybinding signal</link> which gets emitted -- when the user activates the currently focused widget of Window. Signal_Keys_Changed : constant Glib.Signal_Name := "keys-changed";
procedure On_Keys_Changed
(Self : not null access Gtk_Window_Record;
Call : Cb_Gtk_Window_Void;
After : Boolean := False);
procedure On_Keys_Changed
(Self : not null access Gtk_Window_Record;
Call : Cb_GObject_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The ::keys-changed signal gets emitted when the set of accelerators or -- mnemonics that are associated with Window changes. type Cb_Gtk_Window_Gtk_Widget_Void is not null access procedure
(Self : access Gtk_Window_Record'Class;
Object : access Gtk.Widget.Gtk_Widget_Record'Class);
type Cb_GObject_Gtk_Widget_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
Object : access Gtk.Widget.Gtk_Widget_Record'Class);
Signal_Set_Focus : constant Glib.Signal_Name := "set-focus";
procedure On_Set_Focus
(Self : not null access Gtk_Window_Record;
Call : Cb_Gtk_Window_Gtk_Widget_Void;
After : Boolean := False);
procedure On_Set_Focus
(Self : not null access Gtk_Window_Record;
Call : Cb_GObject_Gtk_Widget_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "Buildable" package Implements_Gtk_Buildable is new Glib.Types.Implements
(Gtk.Buildable.Gtk_Buildable, Gtk_Window_Record, Gtk_Window);
function "+"
(Widget : access Gtk_Window_Record'Class)
return Gtk.Buildable.Gtk_Buildable
renames Implements_Gtk_Buildable.To_Interface;
function "-"
(Interf : Gtk.Buildable.Gtk_Buildable)
return Gtk_Window
renames Implements_Gtk_Buildable.To_Object;
private Window_Position_Property : constant Gtk.Enums.Property_Gtk_Window_Position :=
Gtk.Enums.Build ("window-position");
Urgency_Hint_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("urgency-hint");
Type_Hint_Property : constant Gdk.Window.Property_Gdk_Window_Type_Hint :=
Gdk.Window.Build ("type-hint");
The_Type_Property : constant Gtk.Enums.Property_Gtk_Window_Type :=
Gtk.Enums.Build ("type");
Transient_For_Property : constant Glib.Properties.Property_Object :=
Glib.Properties.Build ("transient-for");
Title_Property : constant Glib.Properties.Property_String :=
Glib.Properties.Build ("title");
Startup_Id_Property : constant Glib.Properties.Property_String :=
Glib.Properties.Build ("startup-id");
Skip_Taskbar_Hint_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("skip-taskbar-hint");
Skip_Pager_Hint_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("skip-pager-hint");
Screen_Property : constant Glib.Properties.Property_Object :=
Glib.Properties.Build ("screen");
Role_Property : constant Glib.Properties.Property_String :=
Glib.Properties.Build ("role");
Resize_Grip_Visible_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("resize-grip-visible");
Resizable_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("resizable");
Modal_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("modal");
Mnemonics_Visible_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("mnemonics-visible");
Is_Active_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("is-active");
Icon_Name_Property : constant Glib.Properties.Property_String :=
Glib.Properties.Build ("icon-name");
Icon_Property : constant Glib.Properties.Property_Object :=
Glib.Properties.Build ("icon");
Hide_Titlebar_When_Maximized_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("hide-titlebar-when-maximized");
Has_Toplevel_Focus_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("has-toplevel-focus");
Has_Resize_Grip_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("has-resize-grip");
Gravity_Property : constant Gdk.Window.Property_Gdk_Gravity :=
Gdk.Window.Build ("gravity");
Focus_Visible_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("focus-visible");
Focus_On_Map_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("focus-on-map");
Destroy_With_Parent_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("destroy-with-parent");
Deletable_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("deletable");
Default_Width_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("default-width");
Default_Height_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("default-height");
Decorated_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("decorated");
Attached_To_Property : constant Glib.Properties.Property_Object :=
Glib.Properties.Build ("attached-to");
Application_Property : constant Glib.Properties.Property_Object :=
Glib.Properties.Build ("application");
Accept_Focus_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("accept-focus");
end Gtk.Window;