Index

Package: Window

Description

package Gdk.Window is
---------------------------------------------------------------------------- -- 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/>. -- -- ----------------------------------------------------------------------------

Packages

Gdk_Window_List (new Glib.Glist.Generic_List)

package Gdk_Window_List is new Generic_List (Gdk.Gdk_Window);

Gdk_Window_Class_Properties (new Glib.Generic_Properties.Generic_Internal_Discrete_Property)

package Gdk_Window_Class_Properties is
      new Generic_Internal_Discrete_Property (Gdk_Window_Class);

Gdk_Window_Edge_Properties (new Glib.Generic_Properties.Generic_Internal_Discrete_Property)

package Gdk_Window_Edge_Properties is
      new Generic_Internal_Discrete_Property (Gdk_Window_Edge);

Gdk_Window_Type_Properties (new Glib.Generic_Properties.Generic_Internal_Discrete_Property)

package Gdk_Window_Type_Properties is
      new Generic_Internal_Discrete_Property (Gdk_Window_Type);

Gdk_Window_Attributes_Type_Properties (new Glib.Generic_Properties.Generic_Internal_Discrete_Property)

package Gdk_Window_Attributes_Type_Properties is
      new Generic_Internal_Discrete_Property (Gdk_Window_Attributes_Type);

Gdk_Window_Hints_Properties (new Glib.Generic_Properties.Generic_Internal_Discrete_Property)

package Gdk_Window_Hints_Properties is
      new Generic_Internal_Discrete_Property (Gdk_Window_Hints);

Gdk_Window_Type_Hint_Properties (new Glib.Generic_Properties.Generic_Internal_Discrete_Property)

package Gdk_Window_Type_Hint_Properties is
      new Generic_Internal_Discrete_Property (Gdk_Window_Type_Hint);

Gdk_WMDecoration_Properties (new Glib.Generic_Properties.Generic_Internal_Discrete_Property)

package Gdk_WMDecoration_Properties is
      new Generic_Internal_Discrete_Property (Gdk_WMDecoration);

Gdk_WMFunction_Properties (new Glib.Generic_Properties.Generic_Internal_Discrete_Property)

package Gdk_WMFunction_Properties is
      new Generic_Internal_Discrete_Property (Gdk_WMFunction);

Gdk_Gravity_Properties (new Glib.Generic_Properties.Generic_Internal_Discrete_Property)

package Gdk_Gravity_Properties is
      new Generic_Internal_Discrete_Property (Gdk_Gravity);

Gdk_Fullscreen_Mode_Properties (new Glib.Generic_Properties.Generic_Internal_Discrete_Property)

package Gdk_Fullscreen_Mode_Properties is
      new Generic_Internal_Discrete_Property (Gdk_Fullscreen_Mode);

Invalidate_Maybe_Recurse_User_Data (generic)

Types

Gdk_Window_Class

type Gdk_Window_Class is (
      Input_Output,
      Input_Only);

Gdk_Window_Edge

type Gdk_Window_Edge is (
      Window_Edge_North_West,
      Window_Edge_North,
      Window_Edge_North_East,
      Window_Edge_West,
      Window_Edge_East,
      Window_Edge_South_West,
      Window_Edge_South,
      Window_Edge_South_East);

Gdk_Window_Type

type Gdk_Window_Type is (
      Window_Root,
      Window_Toplevel,
      Window_Child,
      Window_Temp,
      Window_Foreign,
      Window_Offscreen);

Gdk_Window_Attributes_Type

type Gdk_Window_Attributes_Type is mod 2 ** Integer'Size;

Gdk_Window_Hints

type Gdk_Window_Hints is mod 2 ** Integer'Size;

Gdk_Window_Type_Hint

type Gdk_Window_Type_Hint is (
      Window_Type_Hint_Normal,
      Window_Type_Hint_Dialog,
      Window_Type_Hint_Menu,
      Window_Type_Hint_Toolbar,
      Window_Type_Hint_Splashscreen,
      Window_Type_Hint_Utility,
      Window_Type_Hint_Dock,
      Window_Type_Hint_Desktop,
      Window_Type_Hint_Dropdown_Menu,
      Window_Type_Hint_Popup_Menu,
      Window_Type_Hint_Tooltip,
      Window_Type_Hint_Notification,
      Window_Type_Hint_Combo,
      Window_Type_Hint_Dnd);

Gdk_WMDecoration

type Gdk_WMDecoration is mod 2 ** Integer'Size;

Gdk_WMFunction

type Gdk_WMFunction is mod 2 ** Integer'Size;

Gdk_Gravity

type Gdk_Gravity is (
      Gravity_North_West,
      Gravity_North,
      Gravity_North_East,
      Gravity_West,
      Gravity_Center,
      Gravity_East,
      Gravity_South_West,
      Gravity_South,
      Gravity_South_East,
      Gravity_Static);

Gdk_Fullscreen_Mode

type Gdk_Fullscreen_Mode is (
      On_Current_Monitor,
      On_All_Monitors);

Gdk_Geometry

type Gdk_Geometry is record
      Min_Width : Gint;
      Min_Height : Gint;
      Max_Width : Gint;
      Max_Height : Gint;
      Base_Width : Gint;
      Base_Height : Gint;
      Width_Inc : Gint;
      Height_Inc : Gint;
      Min_Aspect : Gdouble;
      Max_Aspect : Gdouble;
      Win_Gravity : Gdk_Gravity;
   end record;

Gdk_Window_Child_Func

type Gdk_Window_Child_Func is access function (Window : Gdk.Gdk_Window) return Boolean;
A function of this type is passed to Gdk.Window.Invalidate_Maybe_Recurse. It gets called for each child of the window to determine whether to recursively invalidate it or now. "window": a Gdk.Gdk_Window

Property_Gdk_Window_Class

type Property_Gdk_Window_Class is new Gdk_Window_Class_Properties.Property;

Property_Gdk_Window_Edge

type Property_Gdk_Window_Edge is new Gdk_Window_Edge_Properties.Property;

Property_Gdk_Window_Type

type Property_Gdk_Window_Type is new Gdk_Window_Type_Properties.Property;

Property_Gdk_Window_Attributes_Type

type Property_Gdk_Window_Attributes_Type is new Gdk_Window_Attributes_Type_Properties.Property;

Property_Gdk_Window_Hints

type Property_Gdk_Window_Hints is new Gdk_Window_Hints_Properties.Property;

Property_Gdk_Window_Type_Hint

type Property_Gdk_Window_Type_Hint is new Gdk_Window_Type_Hint_Properties.Property;

Property_Gdk_WMDecoration

type Property_Gdk_WMDecoration is new Gdk_WMDecoration_Properties.Property;

Property_Gdk_WMFunction

type Property_Gdk_WMFunction is new Gdk_WMFunction_Properties.Property;

Property_Gdk_Gravity

type Property_Gdk_Gravity is new Gdk_Gravity_Properties.Property;

Property_Gdk_Fullscreen_Mode

type Property_Gdk_Fullscreen_Mode is new Gdk_Fullscreen_Mode_Properties.Property;

Constants & Global variables

Hint_Pos (Gdk_Window_Hints)

Hint_Pos : constant Gdk_Window_Hints := 1;

Hint_Min_Size (Gdk_Window_Hints)

Hint_Min_Size : constant Gdk_Window_Hints := 2;

Hint_Max_Size (Gdk_Window_Hints)

Hint_Max_Size : constant Gdk_Window_Hints := 4;

Hint_Base_Size (Gdk_Window_Hints)

Hint_Base_Size : constant Gdk_Window_Hints := 8;

Hint_Aspect (Gdk_Window_Hints)

Hint_Aspect : constant Gdk_Window_Hints := 16;

Hint_Resize_Inc (Gdk_Window_Hints)

Hint_Resize_Inc : constant Gdk_Window_Hints := 32;

Hint_Win_Gravity (Gdk_Window_Hints)

Hint_Win_Gravity : constant Gdk_Window_Hints := 64;

Hint_User_Pos (Gdk_Window_Hints)

Hint_User_Pos : constant Gdk_Window_Hints := 128;

Hint_User_Size (Gdk_Window_Hints)

Hint_User_Size : constant Gdk_Window_Hints := 256;

Decor_All (Gdk_WMDecoration)

Decor_All : constant Gdk_WMDecoration := 1;

Decor_Border (Gdk_WMDecoration)

Decor_Border : constant Gdk_WMDecoration := 2;

Decor_Resizeh (Gdk_WMDecoration)

Decor_Resizeh : constant Gdk_WMDecoration := 4;

Decor_Title (Gdk_WMDecoration)

Decor_Title : constant Gdk_WMDecoration := 8;

Decor_Menu (Gdk_WMDecoration)

Decor_Menu : constant Gdk_WMDecoration := 16;

Decor_Minimize (Gdk_WMDecoration)

Decor_Minimize : constant Gdk_WMDecoration := 32;

Decor_Maximize (Gdk_WMDecoration)

Decor_Maximize : constant Gdk_WMDecoration := 64;

Func_All (Gdk_WMFunction)

Func_All : constant Gdk_WMFunction := 1;

Func_Resize (Gdk_WMFunction)

Func_Resize : constant Gdk_WMFunction := 2;

Func_Move (Gdk_WMFunction)

Func_Move : constant Gdk_WMFunction := 4;

Func_Minimize (Gdk_WMFunction)

Func_Minimize : constant Gdk_WMFunction := 8;

Func_Maximize (Gdk_WMFunction)

Func_Maximize : constant Gdk_WMFunction := 16;

Func_Close (Gdk_WMFunction)

Func_Close : constant Gdk_WMFunction := 32;

Cursor_Property (Glib.Properties.Property_Boxed)

Cursor_Property : constant Glib.Properties.Property_Boxed;
Type: Cursor The mouse pointer for a Gdk.Gdk_Window. See Gdk.Window.Set_Cursor and Gdk.Window.Get_Cursor for details.

Signal_Create_Surface (Glib.Signal_Name)

Signal_Create_Surface : constant Glib.Signal_Name := "create-surface";
The ::create-surface signal is emitted when an offscreen window needs its surface (re)created, which happens either when the the window is first drawn to, or when the window is being resized. The first signal handler that returns a non-null surface will stop any further signal emission, and its surface will be used. Note that it is not possible to access the window's previous surface from within any callback of this signal. Calling gdk_offscreen_window_get_surface will lead to a crash. function Handler (Self : Gdk_Window; Width : Gint; Height : Gint) return Cairo.Cairo_Surface Callback parameters: -- "width": the width of the offscreen surface to create -- "height": the height of the offscreen surface to create -- Returns the newly created cairo_surface_t for the offscreen window

Signal_From_Embedder (Glib.Signal_Name)

Signal_From_Embedder : constant Glib.Signal_Name := "from-embedder";
The ::from-embedder signal is emitted to translate coordinates in the embedder of an offscreen window to the offscreen window. See also Gtk.Window.Gtk_Window::to-embedder. procedure Handler (Self : Gdk_Window; Embedder_X : Gdouble; Embedder_Y : Gdouble; Offscreen_X : out System.Address; Offscreen_Y : out System.Address) Callback parameters: -- "embedder_x": x coordinate in the embedder window -- "embedder_y": y coordinate in the embedder window -- "offscreen_x": return location for the x coordinate in the offscreen -- window -- "offscreen_y": return location for the y coordinate in the offscreen -- window

Signal_Pick_Embedded_Child (Glib.Signal_Name)

Signal_Pick_Embedded_Child : constant Glib.Signal_Name := "pick-embedded-child";
The ::pick-embedded-child signal is emitted to find an embedded child at the given position. function Handler (Self : Gdk_Window; X : Gdouble; Y : Gdouble) return Gtk.Window.Gtk_Window Callback parameters: -- "x": x coordinate in the window -- "y": y coordinate in the window -- Returns the Gdk.Gdk_Window of the embedded child at X, Y, or null

Signal_To_Embedder (Glib.Signal_Name)

Signal_To_Embedder : constant Glib.Signal_Name := "to-embedder";
The ::to-embedder signal is emitted to translate coordinates in an offscreen window to its embedder. See also Gtk.Window.Gtk_Window::from-embedder. procedure Handler (Self : Gdk_Window; Offscreen_X : Gdouble; Offscreen_Y : Gdouble; Embedder_X : out System.Address; Embedder_Y : out System.Address) Callback parameters: -- "offscreen_x": x coordinate in the offscreen window -- "offscreen_y": y coordinate in the offscreen window -- "embedder_x": return location for the x coordinate in the embedder -- window -- "embedder_y": return location for the y coordinate in the embedder -- window

Subprograms & Entries

From_Object_Free

function From_Object_Free 
(B: access Gdk_Geometry) return Gdk_Geometry;

Convert

function Convert 
(R: Gdk.Gdk_Window) return System.Address;

Convert

function Convert 
(R: System.Address) return Gdk.Gdk_Window;

Gdk_New

procedure Gdk_New 
(Self: out Gdk_Window;
Parent: Gdk.Gdk_Window;
Attributes: Gdk.Gdk_Window_Attr;
Attributes_Mask: Gint);
Creates a new Gdk.Gdk_Window using the attributes from Attributes. See Gdk_Window_Attr and Gdk.Window.Gdk_Window_Attributes_Type for more details. Note: to use this on displays other than the default display, Parent must be specified. "parent": a Gdk.Gdk_Window, or null to create the window as a child of the default root window for the default display. "attributes": attributes of the new window "attributes_mask": mask indicating which fields in Attributes are valid

Gdk_Window_New

function Gdk_Window_New 
(Parent: Gdk.Gdk_Window;
Attributes: Gdk.Gdk_Window_Attr;
Attributes_Mask: Gint) return Gdk_Window;
Creates a new Gdk.Gdk_Window using the attributes from Attributes. See Gdk_Window_Attr and Gdk.Window.Gdk_Window_Attributes_Type for more details. Note: to use this on displays other than the default display, Parent must be specified. "parent": a Gdk.Gdk_Window, or null to create the window as a child of the default root window for the default display. "attributes": attributes of the new window "attributes_mask": mask indicating which fields in Attributes are valid

Get_Type

function Get_Type return Glib.GType;

Begin_Move_Drag

procedure Begin_Move_Drag 
(Self: Gdk.Gdk_Window;
Button: Gint;
Root_X: Gint;
Root_Y: Gint;
Timestamp: Guint32);

Begin_Move_Drag_For_Device

procedure Begin_Move_Drag_For_Device 
(Self: Gdk.Gdk_Window;
Device: not null access Gdk.Device.Gdk_Device_Record'Class;
Button: Gint;
Root_X: Gint;
Root_Y: Gint;
Timestamp: Guint32);
Begins a window move operation (for a toplevel window). You might use this function to implement a "window move grip," for example. The function works best with window managers that support the <ulink url="http://www.freedesktop.org/Standards/wm-spec">Extended Window Manager Hints</ulink>, but has a fallback implementation for other window managers. Since: gtk+ 3.4 "device": the device used for the operation "button": the button being used to drag "root_x": root window X coordinate of mouse click that began the drag "root_y": root window Y coordinate of mouse click that began the drag "timestamp": timestamp of mouse click that began the drag

Begin_Paint_Rect

procedure Begin_Paint_Rect 
(Self: Gdk.Gdk_Window;
Rectangle: Gdk.Rectangle.Gdk_Rectangle);

Begin_Paint_Region

procedure Begin_Paint_Region 
(Self: Gdk.Gdk_Window;
Region: Cairo.Region.Cairo_Region);

Begin_Resize_Drag

procedure Begin_Resize_Drag 
(Self: Gdk.Gdk_Window;
Edge: Gdk_Window_Edge;
Button: Gint;
Root_X: Gint;
Root_Y: Gint;
Timestamp: Guint32);

Begin_Resize_Drag_For_Device

procedure Begin_Resize_Drag_For_Device 
(Self: Gdk.Gdk_Window;
Edge: Gdk_Window_Edge;
Device: not null access Gdk.Device.Gdk_Device_Record'Class;
Button: Gint;
Root_X: Gint;
Root_Y: Gint;
Timestamp: Guint32);
Begins a window resize operation (for a toplevel window). You might use this function to implement a "window resize grip," for example; in fact Gtk.Status_Bar.Gtk_Status_Bar uses it. The function works best with window managers that support the <ulink url="http://www.freedesktop.org/Standards/wm-spec">Extended Window Manager Hints</ulink>, but has a fallback implementation for other window managers. Since: gtk+ 3.4 "edge": the edge or corner from which the drag is started "device": the device used for the operation "button": the button being used to drag "root_x": root window X coordinate of mouse click that began the drag "root_y": root window Y coordinate of mouse click that began the drag "timestamp": timestamp of mouse click that began the drag (use Gdk.Event.Get_Time)

Configure_Finished

procedure Configure_Finished 
(Self: Gdk.Gdk_Window);

Coords_From_Parent

procedure Coords_From_Parent 
(Self: Gdk.Gdk_Window;
Parent_X: Gdouble;
Parent_Y: Gdouble;
X: out Gdouble;
Y: out Gdouble);

Coords_To_Parent

procedure Coords_To_Parent 
(Self: Gdk.Gdk_Window;
X: Gdouble;
Y: Gdouble;
Parent_X: out Gdouble;
Parent_Y: out Gdouble);

Create_Similar_Surface

function Create_Similar_Surface 
(Self: Gdk.Gdk_Window;
Content: Cairo.Cairo_Content;
Width: Gint;
Height: Gint) return Cairo.Cairo_Surface;

Deiconify

procedure Deiconify 
(Self: Gdk.Gdk_Window);

Destroy

procedure Destroy 
(Self: Gdk.Gdk_Window);

Destroy_Notify

procedure Destroy_Notify 
(Self: Gdk.Gdk_Window);

Enable_Synchronized_Configure

procedure Enable_Synchronized_Configure 
(Self: Gdk.Gdk_Window);

End_Paint

procedure End_Paint 
(Self: Gdk.Gdk_Window);

Ensure_Native

function Ensure_Native 
(Self: Gdk.Gdk_Window) return Boolean;
Tries to ensure that there is a window-system native window for this GdkWindow. This may fail in some situations, returning False. Offscreen window and children of them can never have native windows. Some backends may not support native child windows. Since: gtk+ 2.18

Flush

procedure Flush 
(Self: Gdk.Gdk_Window);

Focus

procedure Focus 
(Self: Gdk.Gdk_Window;
Timestamp: Guint32);

Freeze_Toplevel_Updates_Libgtk_Only

procedure Freeze_Toplevel_Updates_Libgtk_Only 
(Self: Gdk.Gdk_Window);

Freeze_Updates

procedure Freeze_Updates 
(Self: Gdk.Gdk_Window);

Fullscreen

procedure Fullscreen 
(Self: Gdk.Gdk_Window);

Geometry_Changed

procedure Geometry_Changed 
(Self: Gdk.Gdk_Window);

Get_Accept_Focus

function Get_Accept_Focus 
(Self: Gdk.Gdk_Window) return Boolean;
Determines whether or not the desktop environment shuld be hinted that the window does not want to receive input focus. Since: gtk+ 2.22

Set_Accept_Focus

procedure Set_Accept_Focus 
(Self: Gdk.Gdk_Window;
Accept_Focus: Boolean);
Setting Accept_Focus to False hints the desktop environment that the window doesn't want to receive input focus. On X, it is the responsibility of the window manager to interpret this hint. ICCCM-compliant window manager usually respect it. Since: gtk+ 2.4 "accept_focus": True if the window should receive input focus

Get_Background_Pattern

function Get_Background_Pattern 
(Self: Gdk.Gdk_Window) return Cairo.Cairo_Pattern;

Set_Background_Pattern

procedure Set_Background_Pattern 
(Self: Gdk.Gdk_Window;
Pattern: Cairo.Cairo_Pattern);

Get_Children

function Get_Children 
(Self: Gdk.Gdk_Window) return Gdk_Window_List.Glist;
Gets the list of children of Window known to GDK. This function only returns children created via GDK, so for example it's useless when used with the root window; it only returns windows an application created itself. The returned list must be freed, but the elements in the list need not be.

Get_Clip_Region

function Get_Clip_Region 
(Self: Gdk.Gdk_Window) return Cairo.Region.Cairo_Region;

Get_Composited

function Get_Composited 
(Self: Gdk.Gdk_Window) return Boolean;
Determines whether Window is composited. See Gdk.Window.Set_Composited. Since: gtk+ 2.22

Set_Composited

procedure Set_Composited 
(Self: Gdk.Gdk_Window;
Composited: Boolean);
Sets a Gdk.Gdk_Window as composited, or unsets it. Composited windows do not automatically have their contents drawn to the screen. Drawing is redirected to an offscreen buffer and an expose event is emitted on the parent of the composited window. It is the responsibility of the parent's expose handler to manually merge the off-screen content onto the screen in whatever way it sees fit. See <xref linkend="composited-window-example"/> for an example. It only makes sense for child windows to be composited; see Gdk.Window.Set_Opacity if you need translucent toplevel windows. An additional effect of this call is that the area of this window is no longer clipped from regions marked for invalidation on its parent. Draws done on the parent window are also no longer clipped by the child. This call is only supported on some systems (currently, only X11 with new enough Xcomposite and Xdamage extensions). You must call Gdk.Display.Supports_Composite to check if setting a window as composited is supported before attempting to do so. Since: gtk+ 2.12 "composited": True to set the window as composited

Get_Cursor

function Get_Cursor 
(Self: Gdk.Gdk_Window) return Gdk.Gdk_Cursor;

Set_Cursor

procedure Set_Cursor 
(Self: Gdk.Gdk_Window;
Cursor: Gdk.Gdk_Cursor);

Get_Decorations

procedure Get_Decorations 
(Self: Gdk.Gdk_Window;
Decorations: out Gdk_WMDecoration;
Has_Decorations: out Boolean);
Returns the decorations set on the GdkWindow with Gdk.Window.Set_Decorations. "decorations": The window decorations will be written here

Set_Decorations

procedure Set_Decorations 
(Self: Gdk.Gdk_Window;
Decorations: Gdk_WMDecoration);

Get_Device_Cursor

function Get_Device_Cursor 
(Self: Gdk.Gdk_Window;
Device: not null access Gdk.Device.Gdk_Device_Record'Class) return Gdk.Gdk_Cursor;
Retrieves a Gdk.Gdk_Cursor pointer for the Device currently set on the specified Gdk.Gdk_Window, or null. If the return value is null then there is no custom cursor set on the specified window, and it is using the cursor for its parent window. Since: gtk+ 3.0 "device": a master, pointer Gdk.Device.Gdk_Device.

Set_Device_Cursor

procedure Set_Device_Cursor 
(Self: Gdk.Gdk_Window;
Device: not null access Gdk.Device.Gdk_Device_Record'Class;
Cursor: Gdk.Gdk_Cursor);
Sets a specific Gdk.Gdk_Cursor for a given device when it gets inside Window. Use gdk_cursor_new_for_display or gdk_cursor_new_from_pixbuf to create the cursor. To make the cursor invisible, use Gdk.Blank_Cursor. Passing null for the Cursor argument to Gdk.Window.Set_Cursor means that Window will use the cursor of its parent window. Most windows should use this default. Since: gtk+ 3.0 "device": a master, pointer Gdk.Device.Gdk_Device "cursor": a Gdk.Gdk_Cursor

Get_Device_Events

function Get_Device_Events 
(Self: Gdk.Gdk_Window;
Device: not null access Gdk.Device.Gdk_Device_Record'Class) return Gdk.Event.Gdk_Event_Mask;
Returns the event mask for Window corresponding to an specific device. Since: gtk+ 3.0 "device": a Gdk.Device.Gdk_Device.

Set_Device_Events

procedure Set_Device_Events 
(Self: Gdk.Gdk_Window;
Device: not null access Gdk.Device.Gdk_Device_Record'Class;
Event_Mask: Gdk.Event.Gdk_Event_Mask);
Sets the event mask for a given device (Normally a floating device, not attached to any visible pointer) to Window. For example, an event mask including GDK_BUTTON_PRESS_MASK means the window should report button press events. The event mask is the bitwise OR of values from the Gdk.Event.Gdk_Event_Mask enumeration. Since: gtk+ 3.0 "device": Gdk.Device.Gdk_Device to enable events for. "event_mask": event mask for Window

Get_Device_Position

procedure Get_Device_Position 
(Self: Gdk.Gdk_Window;
Device: not null access Gdk.Device.Gdk_Device_Record'Class;
X: out Gint;
Y: out Gint;
Mask: out Gdk.Types.Gdk_Modifier_Type;
Window: out Gdk.Gdk_Window);
Obtains the current device position and modifier state. The position is given in coordinates relative to the upper left corner of Window. Since: gtk+ 3.0 "device": pointer Gdk.Device.Gdk_Device to query to. "x": return location for the X coordinate of Device, or null. "y": return location for the Y coordinate of Device, or null. "mask": return location for the modifier mask, or null.

Get_Display

function Get_Display 
(Self: Gdk.Gdk_Window) return Gdk.Display.Gdk_Display;
Gets the Gdk.Display.Gdk_Display associated with a Gdk.Gdk_Window. Since: gtk+ 2.24

Get_Effective_Parent

function Get_Effective_Parent 
(Self: Gdk.Gdk_Window) return Gdk.Gdk_Window;

Get_Effective_Toplevel

function Get_Effective_Toplevel 
(Self: Gdk.Gdk_Window) return Gdk.Gdk_Window;

Get_Events

function Get_Events 
(Self: Gdk.Gdk_Window) return Gdk.Event.Gdk_Event_Mask;

Set_Events

procedure Set_Events 
(Self: Gdk.Gdk_Window;
Event_Mask: Gdk.Event.Gdk_Event_Mask);

Get_Focus_On_Map

function Get_Focus_On_Map 
(Self: Gdk.Gdk_Window) return Boolean;
Determines whether or not the desktop environment should be hinted that the window does not want to receive input focus when it is mapped. Since: gtk+ 2.22

Set_Focus_On_Map

procedure Set_Focus_On_Map 
(Self: Gdk.Gdk_Window;
Focus_On_Map: Boolean);
Setting Focus_On_Map to False hints the desktop environment that the window doesn't want to receive input focus when it is mapped. focus_on_map should be turned off for windows that aren't triggered interactively (such as popups from network activity). On X, it is the responsibility of the window manager to interpret this hint. Window managers following the freedesktop.org window manager extension specification should respect it. Since: gtk+ 2.6 "focus_on_map": True if the window should receive input focus when mapped

Get_Frame_Clock

function Get_Frame_Clock 
(Self: Gdk.Gdk_Window) return Gdk.Frame_Clock.Gdk_Frame_Clock;
Gets the frame clock for the window. The frame clock for a window never changes unless the window is reparented to a new toplevel window. Since: gtk+ 3.8

Get_Frame_Extents

procedure Get_Frame_Extents 
(Self: Gdk.Gdk_Window;
Rect: out Gdk.Rectangle.Gdk_Rectangle);

Get_Fullscreen_Mode

function Get_Fullscreen_Mode 
(Self: Gdk.Gdk_Window) return Gdk_Fullscreen_Mode;

Set_Fullscreen_Mode

procedure Set_Fullscreen_Mode 
(Self: Gdk.Gdk_Window;
Mode: Gdk_Fullscreen_Mode);

Get_Geometry

procedure Get_Geometry 
(Self: Gdk.Gdk_Window;
X: out Gint;
Y: out Gint;
Width: out Gint;
Height: out Gint);

Get_Group

function Get_Group 
(Self: Gdk.Gdk_Window) return Gdk.Gdk_Window;

Set_Group

procedure Set_Group 
(Self: Gdk.Gdk_Window;
Leader: Gdk.Gdk_Window);

Get_Height

function Get_Height 
(Self: Gdk.Gdk_Window) return Gint;

Get_Modal_Hint

function Get_Modal_Hint 
(Self: Gdk.Gdk_Window) return Boolean;
Determines whether or not the window manager is hinted that Window has modal behaviour. Since: gtk+ 2.22

Set_Modal_Hint

procedure Set_Modal_Hint 
(Self: Gdk.Gdk_Window;
Modal: Boolean);
The application can use this hint to tell the window manager that a certain window has modal behaviour. The window manager can use this information to handle modal windows in a special way. You should only use this on windows for which you have previously called Gdk.Window.Set_Transient_For "modal": True if the window is modal, False otherwise.

Get_Origin

procedure Get_Origin 
(Self: Gdk.Gdk_Window;
X: out Gint;
Y: out Gint);

Get_Parent

function Get_Parent 
(Self: Gdk.Gdk_Window) return Gdk.Gdk_Window;

Get_Pointer

procedure Get_Pointer 
(Self: Gdk.Gdk_Window;
X: out Gint;
Y: out Gint;
Mask: out Gdk.Types.Gdk_Modifier_Type;
Window: out Gdk.Gdk_Window);

Get_Position

procedure Get_Position 
(Self: Gdk.Gdk_Window;
X: out Gint;
Y: out Gint);

Get_Root_Coords

procedure Get_Root_Coords 
(Self: Gdk.Gdk_Window;
X: Gint;
Y: Gint;
Root_X: out Gint;
Root_Y: out Gint);

Get_Root_Origin

procedure Get_Root_Origin 
(Self: Gdk.Gdk_Window;
X: out Gint;
Y: out Gint);

Get_Screen

function Get_Screen 
(Self: Gdk.Gdk_Window) return Gdk.Screen.Gdk_Screen;
Gets the Gdk.Screen.Gdk_Screen associated with a Gdk.Gdk_Window. Since: gtk+ 2.24

Get_Source_Events

function Get_Source_Events 
(Self: Gdk.Gdk_Window;
Source: Gdk_Input_Source) return Gdk.Event.Gdk_Event_Mask;

Set_Source_Events

procedure Set_Source_Events 
(Self: Gdk.Gdk_Window;
Source: Gdk_Input_Source;
Event_Mask: Gdk.Event.Gdk_Event_Mask);

Get_Support_Multidevice

function Get_Support_Multidevice 
(Self: Gdk.Gdk_Window) return Boolean;
Returns True if the window is aware of the existence of multiple devices. Since: gtk+ 3.0

Set_Support_Multidevice

procedure Set_Support_Multidevice 
(Self: Gdk.Gdk_Window;
Support_Multidevice: Boolean);
This function will enable multidevice features in Window. Multidevice aware windows will need to handle properly multiple, per device enter/leave events, device grabs and grab ownerships. Since: gtk+ 3.0 "support_multidevice": True to enable multidevice support in Window.

Get_Toplevel

function Get_Toplevel 
(Self: Gdk.Gdk_Window) return Gdk.Gdk_Window;

Get_Type_Hint

function Get_Type_Hint 
(Self: Gdk.Gdk_Window) return Gdk_Window_Type_Hint;

Set_Type_Hint

procedure Set_Type_Hint 
(Self: Gdk.Gdk_Window;
Hint: Gdk_Window_Type_Hint);

Get_Update_Area

function Get_Update_Area 
(Self: Gdk.Gdk_Window) return Cairo.Region.Cairo_Region;

Get_Visible_Region

function Get_Visible_Region 
(Self: Gdk.Gdk_Window) return Cairo.Region.Cairo_Region;

Get_Visual

function Get_Visual 
(Self: Gdk.Gdk_Window) return Gdk.Visual.Gdk_Visual;

Get_Width

function Get_Width 
(Self: Gdk.Gdk_Window) return Gint;

Get_Window_Type

function Get_Window_Type 
(Self: Gdk.Gdk_Window) return Gdk_Window_Type;

Has_Native

function Has_Native 
(Self: Gdk.Gdk_Window) return Boolean;
Checks whether the window has a native window or not. Note that you can use Gdk.Window.Ensure_Native if a native window is needed. Since: gtk+ 2.22

Iconify

procedure Iconify 
(Self: Gdk.Gdk_Window);

Input_Shape_Combine_Region

procedure Input_Shape_Combine_Region 
(Self: Gdk.Gdk_Window;
Shape_Region: Cairo.Region.Cairo_Region;
Offset_X: Gint;
Offset_Y: Gint);

Invalidate_Maybe_Recurse

procedure Invalidate_Maybe_Recurse 
(Self: Gdk.Gdk_Window;
Region: Cairo.Region.Cairo_Region;
Child_Func: Gdk_Window_Child_Func);
Adds Region to the update area for Window. The update area is the region that needs to be redrawn, or "dirty region." The call Gdk.Window.Process_Updates sends one or more expose events to the window, which together cover the entire update area. An application would normally redraw the contents of Window in response to those expose events. GDK will call Gdk.Window.Process_All_Updates on your behalf whenever your program returns to the main loop and becomes idle, so normally there's no need to do that manually, you just need to invalidate regions that you know should be redrawn. The Child_Func parameter controls whether the region of each child window that intersects Region will also be invalidated. Only children for which Child_Func returns TRUE will have the area invalidated. "region": a cairo_region_t "child_func": function to use to decide if to recurse to a child, null means never recurse.

Invalidate_Rect

procedure Invalidate_Rect 
(Self: Gdk.Gdk_Window;
Rect: Gdk.Rectangle.Gdk_Rectangle;
Invalidate_Children: Boolean);
A convenience wrapper around Gdk.Window.Invalidate_Region which invalidates a rectangular region. See Gdk.Window.Invalidate_Region for details. "rect": rectangle to invalidate or null to invalidate the whole window "invalidate_children": whether to also invalidate child windows

Invalidate_Region

procedure Invalidate_Region 
(Self: Gdk.Gdk_Window;
Region: Cairo.Region.Cairo_Region;
Invalidate_Children: Boolean);
Adds Region to the update area for Window. The update area is the region that needs to be redrawn, or "dirty region." The call Gdk.Window.Process_Updates sends one or more expose events to the window, which together cover the entire update area. An application would normally redraw the contents of Window in response to those expose events. GDK will call Gdk.Window.Process_All_Updates on your behalf whenever your program returns to the main loop and becomes idle, so normally there's no need to do that manually, you just need to invalidate regions that you know should be redrawn. The Invalidate_Children parameter controls whether the region of each child window that intersects Region will also be invalidated. If False, then the update area for child windows will remain unaffected. See gdk_window_invalidate_maybe_recurse if you need fine grained control over which children are invalidated. "region": a cairo_region_t "invalidate_children": True to also invalidate child windows

Is_Destroyed

function Is_Destroyed 
(Self: Gdk.Gdk_Window) return Boolean;
Check to see if a window is destroyed.. Since: gtk+ 2.18

Is_Input_Only

function Is_Input_Only 
(Self: Gdk.Gdk_Window) return Boolean;
Determines whether or not the window is an input only window. Since: gtk+ 2.22

Is_Shaped

function Is_Shaped 
(Self: Gdk.Gdk_Window) return Boolean;
Determines whether or not the window is shaped. Since: gtk+ 2.22

Is_Viewable

function Is_Viewable 
(Self: Gdk.Gdk_Window) return Boolean;
Check if the window and all ancestors of the window are mapped. (This is not necessarily "viewable" in the X sense, since we only check as far as we have GDK window parents, not to the root window.)

Is_Visible

function Is_Visible 
(Self: Gdk.Gdk_Window) return Boolean;
Checks whether the window has been mapped (with Gdk.Window.Show or Gdk.Window.Show_Unraised).

Lower

procedure Lower 
(Self: Gdk.Gdk_Window);

Maximize

procedure Maximize 
(Self: Gdk.Gdk_Window);

Merge_Child_Input_Shapes

procedure Merge_Child_Input_Shapes 
(Self: Gdk.Gdk_Window);

Merge_Child_Shapes

procedure Merge_Child_Shapes 
(Self: Gdk.Gdk_Window);

Move

procedure Move 
(Self: Gdk.Gdk_Window;
X: Gint;
Y: Gint);

Move_Region

procedure Move_Region 
(Self: Gdk.Gdk_Window;
Region: Cairo.Region.Cairo_Region;
Dx: Gint;
Dy: Gint);

Move_Resize

procedure Move_Resize 
(Self: Gdk.Gdk_Window;
X: Gint;
Y: Gint;
Width: Gint;
Height: Gint);

Peek_Children

function Peek_Children 
(Self: Gdk.Gdk_Window) return Gdk_Window_List.Glist;
Like Gdk.Window.Get_Children, but does not copy the list of children, so the list does not need to be freed.

Process_Updates

procedure Process_Updates 
(Self: Gdk.Gdk_Window;
Update_Children: Boolean);
Sends one or more expose events to Window. The areas in each expose event will cover the entire update area for the window (see Gdk.Window.Invalidate_Region for details). Normally GDK calls Gdk.Window.Process_All_Updates on your behalf, so there's no need to call this function unless you want to force expose events to be delivered immediately and synchronously (vs. the usual case, where GDK delivers them in an idle handler). Occasionally this is useful to produce nicer scrolling behavior, for example. "update_children": whether to also process updates for child windows

Gdk_Raise

procedure Gdk_Raise 
(Self: Gdk.Gdk_Window);

Register_Dnd

procedure Register_Dnd 
(Self: Gdk.Gdk_Window);

Reparent

procedure Reparent 
(Self: Gdk.Gdk_Window;
New_Parent: Gdk.Gdk_Window;
X: Gint;
Y: Gint);

Resize

procedure Resize 
(Self: Gdk.Gdk_Window;
Width: Gint;
Height: Gint);

Restack

procedure Restack 
(Self: Gdk.Gdk_Window;
Sibling: Gdk.Gdk_Window;
Above: Boolean);
Changes the position of Window in the Z-order (stacking order), so that it is above Sibling (if Above is True) or below Sibling (if Above is False). If Sibling is null, then this either raises (if Above is True) or lowers the window. If Window is a toplevel, the window manager may choose to deny the request to move the window in the Z-order, Gdk.Window.Restack only requests the restack, does not guarantee it. Since: gtk+ 2.18 "sibling": a Gdk.Gdk_Window that is a sibling of Window, or null "above": a boolean

Scroll

procedure Scroll 
(Self: Gdk.Gdk_Window;
Dx: Gint;
Dy: Gint);

Set_Background

procedure Set_Background 
(Self: Gdk.Gdk_Window;
Color: Gdk.Color.Gdk_Color);

Set_Background_Rgba

procedure Set_Background_Rgba 
(Self: Gdk.Gdk_Window;
Rgba: Gdk.RGBA.Gdk_RGBA);

Set_Child_Input_Shapes

procedure Set_Child_Input_Shapes 
(Self: Gdk.Gdk_Window);

Set_Child_Shapes

procedure Set_Child_Shapes 
(Self: Gdk.Gdk_Window);

Set_Functions

procedure Set_Functions 
(Self: Gdk.Gdk_Window;
Functions: Gdk_WMFunction);

Set_Geometry_Hints

procedure Set_Geometry_Hints 
(Self: Gdk.Gdk_Window;
Geometry: Gdk_Geometry;
Geom_Mask: Gdk_Window_Hints);

Set_Icon_Name

procedure Set_Icon_Name 
(Self: Gdk.Gdk_Window;
Name: UTF8_String := "");
Windows may have a name used while minimized, distinct from the name they display in their titlebar. Most of the time this is a bad idea from a user interface standpoint. But you can set such a name with this function, if you like. After calling this with a non-null Name, calls to Gdk.Window.Set_Title will not update the icon title. Using null for Name unsets the icon title; further calls to Gdk.Window.Set_Title will again update the icon title as well. "name": name of window while iconified (minimized)

Set_Keep_Above

procedure Set_Keep_Above 
(Self: Gdk.Gdk_Window;
Setting: Boolean);
Set if Window must be kept above other windows. If the window was already above, then this function does nothing. On X11, asks the window manager to keep Window above, if the window manager supports this operation. Not all window managers support this, and some deliberately ignore it or don't have a concept of "keep above"; so you can't rely on the window being kept above. But it will happen with most standard window managers, and GDK makes a best effort to get it to happen. Since: gtk+ 2.4 "setting": whether to keep Window above other windows

Set_Keep_Below

procedure Set_Keep_Below 
(Self: Gdk.Gdk_Window;
Setting: Boolean);
Set if Window must be kept below other windows. If the window was already below, then this function does nothing. On X11, asks the window manager to keep Window below, if the window manager supports this operation. Not all window managers support this, and some deliberately ignore it or don't have a concept of "keep below"; so you can't rely on the window being kept below. But it will happen with most standard window managers, and GDK makes a best effort to get it to happen. Since: gtk+ 2.4 "setting": whether to keep Window below other windows

Set_Opacity

procedure Set_Opacity 
(Self: Gdk.Gdk_Window;
Opacity: Gdouble);

Set_Override_Redirect

procedure Set_Override_Redirect 
(Self: Gdk.Gdk_Window;
Override_Redirect: Boolean);
An override redirect window is not under the control of the window manager. This means it won't have a titlebar, won't be minimizable, etc. - it will be entirely under the control of the application. The window manager can't see the override redirect window at all. Override redirect should only be used for short-lived temporary windows, such as popup menus. Gtk.Menu.Gtk_Menu uses an override redirect window in its implementation, for example. "override_redirect": True if window should be override redirect

Set_Role

procedure Set_Role 
(Self: Gdk.Gdk_Window;
Role: UTF8_String);
When using GTK+, typically you should use Gtk.Window.Set_Role instead of this low-level function. The window manager and session manager use a window's role to distinguish it from other kinds of window in the same application. When an application is restarted after being saved in a previous session, all windows with the same title and role are treated as interchangeable. So if you have two windows with the same title that should be distinguished for session management purposes, you should set the role on those windows. It doesn't matter what string you use for the role, as long as you have a different role for each non-interchangeable kind of window. "role": a string indicating its role

Set_Skip_Pager_Hint

procedure Set_Skip_Pager_Hint 
(Self: Gdk.Gdk_Window;
Skips_Pager: Boolean);
Toggles whether a window should appear in a pager (workspace switcher, or other desktop utility program that displays a small thumbnail representation of the windows on the desktop). If a window's semantic type as specified with Gdk.Window.Set_Type_Hint already fully describes the window, this function should *not* be called in addition, instead you should allow the window to be treated according to standard policy for its semantic type. Since: gtk+ 2.2 "skips_pager": True to skip the pager

Set_Skip_Taskbar_Hint

procedure Set_Skip_Taskbar_Hint 
(Self: Gdk.Gdk_Window;
Skips_Taskbar: Boolean);
Toggles whether a window should appear in a task list or window list. If a window's semantic type as specified with Gdk.Window.Set_Type_Hint already fully describes the window, this function should *not* be called in addition, instead you should allow the window to be treated according to standard policy for its semantic type. Since: gtk+ 2.2 "skips_taskbar": True to skip the taskbar

Set_Startup_Id

procedure Set_Startup_Id 
(Self: Gdk.Gdk_Window;
Startup_Id: UTF8_String);
When using GTK+, typically you should use Gtk.Window.Set_Startup_Id instead of this low-level function. Since: gtk+ 2.12 "startup_id": a string with startup-notification identifier

Set_Static_Gravities

function Set_Static_Gravities 
(Self: Gdk.Gdk_Window;
Use_Static: Boolean) return Boolean;
Set the bit gravity of the given window to static, and flag it so all children get static subwindow gravity. This is used if you are implementing scary features that involve deep knowledge of the windowing system. Don't worry about it unless you have to. "use_static": True to turn on static gravity

Set_Title

procedure Set_Title 
(Self: Gdk.Gdk_Window;
Title: UTF8_String);
Sets the title of a toplevel window, to be displayed in the titlebar. If you haven't explicitly set the icon name for the window (using Gdk.Window.Set_Icon_Name), the icon name will be set to Title as well. Title must be in UTF-8 encoding (as with all user-readable strings in GDK/GTK+). Title may not be null. "title": title of Window

Set_Transient_For

procedure Set_Transient_For 
(Self: Gdk.Gdk_Window;
Parent: Gdk.Gdk_Window);

Set_Urgency_Hint

procedure Set_Urgency_Hint 
(Self: Gdk.Gdk_Window;
Urgent: Boolean);
Toggles whether a window needs the user's urgent attention. Since: gtk+ 2.8 "urgent": True if the window is urgent

Set_User_Data

procedure Set_User_Data 
(Self: Gdk.Gdk_Window;
User_Data: System.Address);

Shape_Combine_Region

procedure Shape_Combine_Region 
(Self: Gdk.Gdk_Window;
Shape_Region: Cairo.Region.Cairo_Region;
Offset_X: Gint;
Offset_Y: Gint);

Show_Unraised

procedure Show_Unraised 
(Self: Gdk.Gdk_Window);

Stick

procedure Stick 
(Self: Gdk.Gdk_Window);

Thaw_Toplevel_Updates_Libgtk_Only

procedure Thaw_Toplevel_Updates_Libgtk_Only 
(Self: Gdk.Gdk_Window);

Thaw_Updates

procedure Thaw_Updates 
(Self: Gdk.Gdk_Window);

Unfullscreen

procedure Unfullscreen 
(Self: Gdk.Gdk_Window);

Unmaximize

procedure Unmaximize 
(Self: Gdk.Gdk_Window);

Unstick

procedure Unstick 
(Self: Gdk.Gdk_Window);

Withdraw

procedure Withdraw 
(Self: Gdk.Gdk_Window);

Get_User_Data

function Get_User_Data 
(Window: Gdk_Window) return Glib.Object.GObject;
Return the widget to which events are reported when they happen on Window. This is the widget that was set through the call to Set_User_data.

Set_User_Data

procedure Set_User_Data 
(Window: Gdk_Window;
Widget: access Glib.Object.GObject_Record'Class);
Sets a special field in the window. All the events reported by the Xserver (or the Windows server) for Window will be redirected to Widget through the standard signals "expose_event", "button_press_event", ... You almost always need to call this function after creating a new Gdk_Window yourself, or you won't be able to handle the events.

Ref

procedure Ref 
(Window: Gdk_Window);

Unref

procedure Unref 
(Window: Gdk_Window);

At_Pointer

procedure At_Pointer 
(Win_X: out Gint;
Win_Y: out Gint;
Window: out Gdk.Gdk_Window);

Constrain_Size

procedure Constrain_Size 
(Geometry: Gdk_Geometry;
Flags: Guint;
Width: Gint;
Height: Gint;
New_Width: out Gint;
New_Height: out Gint);

Process_All_Updates

procedure Process_All_Updates;

Set_Debug_Updates

procedure Set_Debug_Updates 
(Setting: Boolean);
With update debugging enabled, calls to Gdk.Window.Invalidate_Region clear the invalidated region of the screen to a noticeable color, and GDK pauses for a short time before sending exposes to windows during Gdk.Window.Process_Updates. The net effect is that you can see the invalid region for each window and watch redraws as they occur. This allows you to diagnose inefficiencies in your application. In essence, because the GDK rendering model prevents all flicker, if you are redrawing the same region 400 times you may never notice, aside from noticing a speed problem. Enabling update debugging causes GTK to flicker slowly and noticeably, so you can see exactly what's being redrawn when, in what order. The --gtk-debug=updates command line option passed to GTK+ programs enables this debug option at application startup time. That's usually more useful than calling Gdk.Window.Set_Debug_Updates yourself, though you might want to use this function to enable updates sometime after application startup time. "setting": True to turn on update debugging