## Documentation

Table of Contents
Class Inheritance Tree
Widget Screenshots
Package groups

1.     -----------------------------------------------------------------------

2.     --               GtkAda - Ada95 binding for Gtk+/Gnome               --

3.     --                                                                   --

4.     --   Copyright (C) 1998-2000, E. Briot, J. Brobecker and A. Charlet  --

5.     --                Copyright (C) 2000-2011, AdaCore                   --

6.     --                                                                   --

7.     -- This library is free software; you can redistribute it and/or     --

8.     -- modify it under the terms of the GNU General Public               --

9.     -- License as published by the Free Software Foundation; either      --

10.     -- version 2 of the License, or (at your option) any later version.  --

11.     --                                                                   --

12.     -- This library is distributed in the hope that it will be useful,   --

13.     -- but WITHOUT ANY WARRANTY; without even the implied warranty of    --

14.     -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU --

15.     -- General Public License for more details.                          --

16.     --                                                                   --

17.     -- You should have received a copy of the GNU General Public         --

18.     -- License along with this library; if not, write to the             --

19.     -- Free Software Foundation, Inc., 59 Temple Place - Suite 330,      --

20.     -- Boston, MA 02111-1307, USA.                                       --

21.     --                                                                   --

22.     -- As a special exception, if other files instantiate generics from  --

23.     -- this unit, or you link this unit with other files to produce an   --

24.     -- executable, this  unit  does not  by itself cause  the resulting  --

25.     -- executable to be covered by the GNU General Public License. This  --

26.     -- exception does not however invalidate any other reasons why the   --

27.     -- executable file  might be covered by the  GNU Public License.     --

28.     -----------------------------------------------------------------------

30.     --  A Gdk_Window is the physical window that appears on the screen.

31.     --  This is the low-level structure known to the X server or to Win32.

32.     --  All the widgets are internally associated with a specific Gdk_Window,

33.     --  that holds attributes such as the window decoration, whether the window

34.     --  can be interactively resized,...

35.     --

36.     --  On some systems, the graphic server knows how to display non-rectangular

37.     --  windows (this is part of the X extensions).

38.     --

39.     --  If you simply want to create a simply window, you should instead look

40.     --  at the functions provided in Gtk.Window and Gtk.Widget, which are higher

41.     --  level than these. See also the function Gtk.Widget.Get_Window to get the

42.     --  Gdk_Window associated with a widget. Be aware that some of them don't have

43.     --  such windows!

44.     --

45.     --  Scrolling can be implemented in several ways with GtkAda (toplevel

46.     --  scrolling should be done with the Gtk_Scrolled_Window widget, but you

47.     --  might want to handle scrolling yourself). See the function

48.     --  Gdk.Event.Get_Graphics_Expose for more information.

49.     --  <c_version>1.3.6</c_version>

50.     --  <c_version>2.12</c_version> for some of the functions

51.     --  <group>Gdk, the low-level API</group>

53.     with System;

54.     with GlibTo API docTo specTo body; use GlibTo API docTo specTo body;

55.     with Glib.ObjectTo API docTo specTo body;

56.     with Glib.Generic_PropertiesTo API docTo specTo body; use Glib.Generic_PropertiesTo API docTo specTo body;

57.     pragma Elaborate_All (Glib.Generic_PropertiesTo API docTo specTo body);

58.     with Glib.GlistTo API docTo specTo body;

59.     pragma Elaborate_All (Glib.GlistTo API docTo specTo body);

60.     with CairoTo API docTo specTo body;

61.     with GdkTo API docTo spec;

62.     with Gdk.ColorTo API docTo specTo body;

63.     with Gdk.CursorTo API docTo specTo body;

64.     with Gdk.EventTo API docTo specTo body;

65.     with Gdk.RectangleTo API docTo specTo body;

66.     with Gdk.TypesTo API docTo spec;

67.     with Unchecked_Conversion;

69.     package Gdk.WindowTo API docTo specTo body is

71.        subtype Gdk_Window is Gdk.Gdk_WindowTo API docTo spec;

73.        Null_Window : constant Gdk_WindowTo API docTo spec;

75.        type Gdk_Window_Class is (Input_Output, Input_Only);

77.        type Gdk_Window_Type is

78.          (Window_Root,

79.           --  there is only one root window and it is initialized at startup.

80.           --  Creating a window of type Window_Root is an error.

82.           Window_Toplevel,

83.           --  Windows which interact with the window manager.

85.           Window_Child,

86.           --  Windows which are children of some other type of window.

87.           --  (Any other type of window). Most windows are child windows.

89.           Window_Dialog,

90.           --  A special kind of toplevel window which interacts with the window

91.           --  manager slightly differently than a regular toplevel window.

92.           --  Dialog windows should be used for any transient window.

94.           Window_Temp,

95.           --  ???

97.           Window_Foreign

98.           --  A window that actually belongs to another application.

99.          );

100.        --  Type of windows.

102.        type Gdk_Window_Attributes_Type is mod 2 ** 32;

103.        Wa_Title    : constant Gdk_Window_Attributes_TypeTo API docTo spec := 2 ** 1;

104.        Wa_X        : constant Gdk_Window_Attributes_TypeTo API docTo spec := 2 ** 2;

105.        Wa_Y        : constant Gdk_Window_Attributes_TypeTo API docTo spec := 2 ** 3;

106.        Wa_Cursor   : constant Gdk_Window_Attributes_TypeTo API docTo spec := 2 ** 4;

107.        Wa_Colormap : constant Gdk_Window_Attributes_TypeTo API docTo spec := 2 ** 5;

108.        Wa_Visual   : constant Gdk_Window_Attributes_TypeTo API docTo spec := 2 ** 6;

109.        Wa_Wmclass  : constant Gdk_Window_Attributes_TypeTo API docTo spec := 2 ** 7;

110.        Wa_Noredir  : constant Gdk_Window_Attributes_TypeTo API docTo spec := 2 ** 8;

112.        type Gdk_Window_Hints is mod 2 ** 32;

113.        --  Size restriction.

114.        Gdk_Hint_Pos        : constant Gdk_Window_HintsTo API docTo spec := 2 ** 0;

115.        Gdk_Hint_Min_Size   : constant Gdk_Window_HintsTo API docTo spec := 2 ** 1;

116.        Gdk_Hint_Max_Size   : constant Gdk_Window_HintsTo API docTo spec := 2 ** 2;

117.        Gdk_Hint_Base_Size  : constant Gdk_Window_HintsTo API docTo spec := 2 ** 3;

118.        Gdk_Hint_Aspect     : constant Gdk_Window_HintsTo API docTo spec := 2 ** 4;

119.        Gdk_Hint_Resize_Inc : constant Gdk_Window_HintsTo API docTo spec := 2 ** 5;

121.        type Gdk_Window_Type_Hint is

122.          (Window_Type_Hint_Normal,

123.           --  Normal toplevel window

125.           Window_Type_Hint_Dialog,

126.           --  Dialog window

128.           Window_Type_Hint_Menu,

129.           --  Window used to implement a menu.

131.           Window_Type_Hint_Toolbar

132.           --  Toolbar: Window used to implement toolbars.

133.          );

134.        --  Hints for the window manager that indicate what type of function the

135.        --  window has. The window manager can use this when determining decoration

136.        --  and behaviour of the window. The hint must be set before mapping the

137.        --  window.

139.        type Gdk_Wm_Decoration is mod 2 ** 32;

140.        Decor_All      : constant Gdk_Wm_DecorationTo API docTo spec := 2 ** 0;

141.        Decor_Border   : constant Gdk_Wm_DecorationTo API docTo spec := 2 ** 1;

142.        Decor_Resize_H : constant Gdk_Wm_DecorationTo API docTo spec := 2 ** 2;

143.        Decor_Title    : constant Gdk_Wm_DecorationTo API docTo spec := 2 ** 3;

144.        Decor_Menu     : constant Gdk_Wm_DecorationTo API docTo spec := 2 ** 4;

145.        Decor_Minimize : constant Gdk_Wm_DecorationTo API docTo spec := 2 ** 5;

146.        Decor_Maximize : constant Gdk_Wm_DecorationTo API docTo spec := 2 ** 6;

148.        type Gdk_Wm_Function is mod 2 ** 32;

149.        Func_All      : constant Gdk_Wm_FunctionTo API docTo spec := 2 ** 0;

150.        Func_Resize   : constant Gdk_Wm_FunctionTo API docTo spec := 2 ** 1;

151.        Func_Move     : constant Gdk_Wm_FunctionTo API docTo spec := 2 ** 2;

152.        Func_Minimize : constant Gdk_Wm_FunctionTo API docTo spec := 2 ** 3;

153.        Func_Maximize : constant Gdk_Wm_FunctionTo API docTo spec := 2 ** 4;

154.        Func_Close    : constant Gdk_Wm_FunctionTo API docTo spec := 2 ** 5;

156.        type Gdk_Gravity is

157.          (Gravity_North_West,

158.           Gravity_North,

159.           Gravity_North_East,

160.           Gravity_West,

161.           Gravity_Center,

162.           Gravity_East,

163.           Gravity_South_West,

164.           Gravity_South,

165.           Gravity_South_East,

166.           Gravity_Static);

168.        type Gdk_Window_Edge is

169.          (Window_Edge_North_West,

170.           Window_Edge_North,

171.           Window_Edge_North_East,

172.           Window_Edge_West,

173.           Window_Edge_East,

174.           Window_Edge_South_West,

175.           Window_Edge_South,

176.           Window_Edge_South_East);

178.        type Gdk_Geometry is record

179.           Min_Width   : GintTo API docTo spec;

180.           Min_Height  : GintTo API docTo spec;

181.           Max_Width   : GintTo API docTo spec;

182.           Max_Height  : GintTo API docTo spec;

183.           Base_Width  : GintTo API docTo spec;

184.           Base_Height : GintTo API docTo spec;

185.           Width_Inc   : GintTo API docTo spec;

186.           Height_Inc  : GintTo API docTo spec;

187.           Min_Aspect  : GdoubleTo API docTo spec;

188.           Max_Aspect  : GdoubleTo API docTo spec;

189.           Win_Gravity : Gdk_GravityTo API docTo spec;

190.        end record;

192.        procedure Gdk_NewTo API docTo body

193.          (Window          : out Gdk_WindowTo API docTo spec;

194.           Parent          : Gdk_WindowTo API docTo spec;

195.           Attributes      : Gdk_Window_AttrTo API docTo spec;

196.           Attributes_Mask : Gdk_Window_Attributes_TypeTo API docTo spec);

197.        --  Creates a new gdk_window.

198.        --  There are few reasons for creating such windows yourself, and almost

199.        --  none if you are not creating a new widget.

200.        --  One nice thing with using such a window (rather than drawing directly on

201.        --  a gtk_widget is that you can get separate Events for this window

202.        --  (Expose, Button_Press, ...) without having do detect yourself where the

203.        --  event applied.

204.        --  Note that you should almost always call Set_User_Data on the newly

205.        --  created window, so that events are redirected to a specific widget.

206.        --

207.        --  You cannot pass a null value for Attributes.

208.        --

209.        --  Attributes_Mask indicates which fields are relevant in Attributes. Some

210.        --  of the fields are always taken into account, and thus do not have an

211.        --  associated mask.

212.        --

213.        --  See the package Gdk.Window_Attr for more information on window

214.        --  attributes.

215.        --

216.        --  Changing the background color of the window can be done through

217.        --  Gtk.Style.Set_Background

219.        procedure Set_User_DataTo API docTo body

220.          (Window : Gdk.Gdk_WindowTo API docTo spec;

221.           Widget : access Glib.Object.GObject_RecordTo API docTo specTo body'Class);

222.        --  Sets a special field in the window.

223.        --  All the events reported by the Xserver (or the Windows server) for

224.        --  Window will be redirected to Widget through the standard signals

225.        --  "expose_event", "button_press_event", ...

226.        --  You almost always need to call this function after creating a new

227.        --  Gdk_Window yourself, or you won't be able to handle the events.

229.        function Get_User_DataTo API docTo body

230.          (Window : Gdk.Gdk_WindowTo API docTo spec) return Glib.Object.GObjectTo API docTo spec;

231.        --  Return the widget to which events are reported when they happen on

232.        --  Window. This is the widget that was set through the call to

233.        --  Set_User_data.

235.        function Get_TypeTo API docTo body return Glib.GTypeTo API docTo spec;

236.        --  Return the internal lue associated with Gdk_Window.

238.        procedure DestroyTo API docTo body (Window : in out Gdk_WindowTo API docTo spec);

239.        --  Destroy a window and all its children.

241.        type Gdk_Filter_Return is

242.          (Continue,  --  Event not handled, continue processing

243.           Translate, --  Translated event stored

244.           Remove);   --  Terminate processing, removing event

246.        type Gdk_Filter_Func is access function

247.          (System_Event : C_ProxyTo API docTo spec;

248.           Event        : Gdk.Event.Gdk_EventTo API docTo spec;

249.           Data         : System.Address) return Gdk_Filter_ReturnTo API docTo spec;

250.        pragma Convention (C, Gdk_Filter_FuncTo API docTo spec);

251.        --  A filter function, that will be called before the standard processing

252.        --  in gtk+. System_Event is the raw event from the system,

253.        --

254.        --  Event hasn't been set when this function is set, and the function should

255.        --  set it to a meaningful value if it returns Translate.

256.        --

257.        --  Data is the user_data that was passed with Add_Filter.

259.        procedure Add_FilterTo API docTo body

260.          (Window : Gdk.Gdk_WindowTo API docTo spec;

261.           Filter : Gdk_Filter_FuncTo API docTo spec;

262.           Data   : System.Address);

263.        --  Add an event filter to Window, allowing you to intercept events

264.        --  before they reach GDK. This is a low-level operation and makes it

265.        --  easy to break GDK and/or GTK+, so you have to know what you're

266.        --  doing. Pass null for Window to get all events for all windows,

267.        --  instead of events for a specific window.

268.        --

269.        --  This can be used for a temporary keyboard grab, although you should

270.        --  consider using Gdk.Main.Keyboard_Grab instead.

272.        procedure Remove_FilterTo API docTo body

273.          (Window : Gdk.Gdk_WindowTo API docTo spec;

274.           Filter : Gdk_Filter_FuncTo API docTo spec;

275.           Data   : System.Address);

276.        --  Removing the filter that was previously associated with Filter and Data

278.        function Get_Window_TypeTo API docTo body (Window : Gdk_WindowTo API docTo spec) return Gdk_Window_TypeTo API docTo spec;

280.        procedure Window_At_PointerTo API docTo body

281.          (Win_X  : out GintTo API docTo spec;

282.           Win_Y  : out GintTo API docTo spec;

283.           Window : out Gdk_WindowTo API docTo spec);

284.        --  Return the window and the coordinates corresponding to the current

285.        --  position of the cursor.

287.        procedure ShowTo API docTo body (Window : Gdk_WindowTo API docTo spec);

289.        procedure Show_UnraisedTo API docTo body (Window : Gdk_WindowTo API docTo spec);

290.        --  Show Window on screen, but does not modify its stacking order. In

291.        --  contrast, Show will raise the window to the top of the window stack.

293.        procedure HideTo API docTo body (Window : Gdk_WindowTo API docTo spec);

295.        procedure WithdrawTo API docTo body (Window : Gdk_WindowTo API docTo spec);

297.        procedure MoveTo API docTo body

298.          (Window : Gdk_WindowTo API docTo spec;

299.           X      : GintTo API docTo spec;

300.           Y      : GintTo API docTo spec);

302.        procedure ResizeTo API docTo body

303.          (Window : Gdk_WindowTo API docTo spec;

304.           Width  : GintTo API docTo spec;

305.           Height : GintTo API docTo spec);

307.        procedure Move_ResizeTo API docTo body

308.          (Window : Gdk_WindowTo API docTo spec;

309.           X      : GintTo API docTo spec;

310.           Y      : GintTo API docTo spec;

311.           Width  : GintTo API docTo spec;

312.           Height : GintTo API docTo spec);

314.        procedure ReparentTo API docTo body

315.          (Window     : Gdk_WindowTo API docTo spec;

316.           New_Parent : Gdk_WindowTo API docTo spec;

317.           X          : GintTo API docTo spec;

318.           Y          : GintTo API docTo spec);

320.        procedure ClearTo API docTo body (Window : Gdk_WindowTo API docTo spec);

322.        procedure Clear_AreaTo API docTo body

323.          (Window : Gdk_WindowTo API docTo spec;

324.           X      : GintTo API docTo spec;

325.           Y      : GintTo API docTo spec;

326.           Width  : GintTo API docTo spec;

327.           Height : GintTo API docTo spec);

328.        --  Does not generate an expose event.

330.        procedure Clear_Area_ETo API docTo body

331.          (Window : Gdk_WindowTo API docTo spec;

332.           X      : GintTo API docTo spec;

333.           Y      : GintTo API docTo spec;

334.           Width  : GintTo API docTo spec;

335.           Height : GintTo API docTo spec);

336.        --  Same as Clear_Area, but generates an expose event.

338.        procedure Copy_AreaTo API docTo body

339.          (Window        : Gdk_WindowTo API docTo spec;

340.           Gc            : Gdk.Gdk_GCTo API docTo spec;

341.           X             : GintTo API docTo spec;

342.           Y             : GintTo API docTo spec;

343.           Source_Window : Gdk_WindowTo API docTo spec;

344.           Source_X      : GintTo API docTo spec;

345.           Source_Y      : GintTo API docTo spec;

346.           Width         : GintTo API docTo spec;

347.           Height        : GintTo API docTo spec);

348.        --  Obsolete. Use Gdk.Drawable.Draw_Drawable instead.

350.        function Create_Similar_SurfaceTo API docTo body

351.          (Window  : Gdk_WindowTo API docTo spec;

352.           Content : Cairo.Cairo_ContentTo API docTo spec;

353.           Width   : Glib.GintTo API docTo spec;

354.           Height  : Glib.GintTo API docTo spec) return Cairo.Cairo_SurfaceTo API docTo spec;

355.        --  Same as Cairo.Surface.Create_Similar, using Windows as similar surface.

357.        procedure Gdk_RaiseTo API docTo body (Window : Gdk_WindowTo API docTo spec);

359.        procedure LowerTo API docTo body (Window : Gdk_WindowTo API docTo spec);

361.        procedure FocusTo API docTo body (Window : Gdk_WindowTo API docTo spec; Timestamp : Guint32To API docTo spec);

363.        procedure Set_Override_RedirectTo API docTo body

364.          (Window            : Gdk_WindowTo API docTo spec;

365.           Override_Redirect : Boolean := True);

367.        procedure ScrollTo API docTo body (Window : Gdk_WindowTo API docTo spec; Dx, Dy : GintTo API docTo spec);

369.        procedure Shape_Combine_MaskTo API docTo body

370.          (Window     : Gdk_WindowTo API docTo spec;

371.           Shape_Mask : Gdk.Gdk_BitmapTo API docTo spec;

372.           Offset_X   : GintTo API docTo spec;

373.           Offset_Y   : GintTo API docTo spec);

374.        --  Allow for making shaped (partially transparent) windows.

375.        --  This featureis  needed for Drag and Drop for example.

376.        --  Shape_Mask can be the mask from Gdk.Pixmap.Create_From_Xpm.

378.        procedure Shape_Combine_RegionTo API docTo body

379.          (Window       : Gdk_WindowTo API docTo spec;

380.           Shape_Region : Gdk.Gdk_RegionTo API docTo spec;

381.           Offset_X     : GintTo API docTo spec;

382.           Offset_Y     : GintTo API docTo spec);

384.        procedure Set_Child_ShapesTo API docTo body (Window : Gdk_WindowTo API docTo spec);

385.        --  Quickly take the shapes of all the child windows of a window and use

386.        --  their shapes as the shape mask for this window - useful for container

387.        --  windows that do not want to look like a big box.

389.        procedure Merge_Child_ShapesTo API docTo body (Window : Gdk_WindowTo API docTo spec);

390.        --  Merge (ie add) child shapes to your own window's shape keeping its

391.        --  current shape and adding the child shapes to it.

393.        function Is_VisibleTo API docTo body (Window : Gdk_WindowTo API docTo spec) return Boolean;

395.        function Is_ViewableTo API docTo body (Window : Gdk_WindowTo API docTo spec) return Boolean;

397.        function Get_StateTo API docTo body (Window : Gdk_WindowTo API docTo spec) return Gdk.Event.Gdk_Window_StateTo API docTo spec;

398.        --  Return the current state of the Windows.

399.        --  See Gdk.Event.Gdk_Window_State for more details.

401.        function Set_Static_GravitiesTo API docTo body

402.          (Window     : Gdk_WindowTo API docTo spec;

403.           Use_Static : Boolean) return Boolean;

405.        procedure Set_HintsTo API docTo body

406.          (Window     : Gdk_WindowTo API docTo spec;

407.           X          : GintTo API docTo spec;

408.           Y          : GintTo API docTo spec;

409.           Min_Width  : GintTo API docTo spec;

410.           Min_Height : GintTo API docTo spec;

411.           Max_Width  : GintTo API docTo spec;

412.           Max_Height : GintTo API docTo spec;

413.           Flags      : Gdk_Window_HintsTo API docTo spec);

415.        procedure Set_Type_HintTo API docTo body

416.          (Window : Gdk_WindowTo API docTo spec;

417.           Hint   : Gdk_Window_Type_HintTo API docTo spec);

419.        procedure Set_Modal_HintTo API docTo body

420.          (Window : Gdk_WindowTo API docTo spec;

421.           Modal  : Boolean);

423.        procedure Set_Geometry_HintsTo API docTo body

424.          (Window   : Gdk_WindowTo API docTo spec;

425.           Geometry : in out Gdk_GeometryTo API docTo spec;

426.           Flags    : Gdk_Window_HintsTo API docTo spec);

428.        procedure Set_TitleTo API docTo body (Window : Gdk_WindowTo API docTo spec; Title : UTF8_StringTo API docTo spec);

430.        procedure Set_RoleTo API docTo body (Window : Gdk_WindowTo API docTo spec; Role : String);

432.        procedure Set_Transient_ForTo API docTo body

433.          (Window : Gdk_WindowTo API docTo spec; Leader : Gdk_WindowTo API docTo spec);

435.        procedure Set_OpacityTo API docTo body (Window : Gdk_WindowTo API docTo spec; Opacity : GdoubleTo API docTo spec);

436.        --  Request the windowing system to make Window partially transparent, with

437.        --  opacity 0.0 being fully transparent and 1.0 fully opaque (Values of the

438.        --  opacity parameter are clamped to the [0,1] range).

439.        --

440.        --  On X11, this works only on X screens with a compositing manager running

441.        --  (see Gdk.Screen.Is_Composited)

442.        --

443.        --  For setting up per-pixel alpha, see Gdk.Screen.Get_Rgba_Colormap

444.        --  For making non-toplevel windows translucent, see Set_Composited

445.        --

446.        --  Since: gtk+ 2.12

448.        procedure Set_CompositedTo API docTo body (Window : Gdk_WindowTo API docTo spec; Composited : Boolean);

449.        --  Sets Window as composited, or unsets it. Composited windows do not

450.        --  automatically have their contents drawn to the screen. Drawing is

451.        --  redirected to an offscreen buffer and an expose event is emitted on the

452.        --  parent of the composited window. It is the responsibility of the

453.        --  parent's expose handler to manually merge the off-screen content onto

454.        --  the screen in whatever way it sees fit.

455.        --

456.        --  It only makes sense for child windows to be composited; see Set_Opacity

457.        --  if you need translucent toplevel windows.

458.        --

459.        --  An additional effect of this call is that the area of this window is no

460.        --  longer clipped from regions marked for invalidation on its parent. Draws

461.        --  done on the parent window are also no longer clipped by the child.

462.        --

463.        --  This call is only supported on some systems (currently, only X11 with

464.        --  new enough Xcomposite and Xdamage extensions). You must call

465.        --  gdk_display_supports_composite() to check if setting a window as

466.        --  composited is supported before attempting to do so.

467.        --

468.        --  Since: 2.12

470.        procedure Set_BackgroundTo API docTo body

471.          (Window : Gdk_WindowTo API docTo spec; ColorTo API docTo body : Gdk.Color.Gdk_ColorTo API docTo specTo body);

473.        procedure Set_Back_PixmapTo API docTo body

474.          (Window          : Gdk_WindowTo API docTo spec;

475.           Pixmap          : Gdk.Gdk_PixmapTo API docTo spec;

476.           Parent_Relative : Boolean);

478.        procedure Set_CursorTo API docTo body

479.          (Window : Gdk_WindowTo API docTo spec; Cursor : Gdk.Cursor.Gdk_CursorTo API docTo spec);

480.        --  Note: the window must be realized first, ie have an associated X11/Win32

481.        --  window.

483.        procedure Get_GeometryTo API docTo body

484.          (Window : Gdk_WindowTo API docTo spec;

485.           X      : out GintTo API docTo spec;

486.           Y      : out GintTo API docTo spec;

487.           Width  : out GintTo API docTo spec;

488.           Height : out GintTo API docTo spec;

489.           Depth  : out GintTo API docTo spec);

490.        --  You can get the size of the root window (ie the size of the screen)

491.        --  simply by giving Null_Window as the first argument to this procedure.

493.        procedure Get_PositionTo API docTo body

494.          (Window : Gdk_WindowTo API docTo spec;

495.           X      : out GintTo API docTo spec;

496.           Y      : out GintTo API docTo spec);

498.        procedure Get_OriginTo API docTo body

499.          (Window  : Gdk_WindowTo API docTo spec;

500.           X       : out GintTo API docTo spec;

501.           Y       : out GintTo API docTo spec;

502.           Success : out Boolean);

503.        --  Obtains the position of a window in root window coordinates. (Compare

504.        --  with Get_Position and Get_Geometry which return the position of a window

505.        --  relative to its parent window)

507.        procedure Get_Desk_Relative_OriginTo API docTo body

508.          (Window  : Gdk_WindowTo API docTo spec;

509.           X       : out GintTo API docTo spec;

510.           Y       : out GintTo API docTo spec;

511.           Success : out Boolean);

513.        procedure Get_Root_OriginTo API docTo body

514.          (Window : Gdk_WindowTo API docTo spec;

515.           X      : out GintTo API docTo spec;

516.           Y      : out GintTo API docTo spec);

517.        --  Obtains the top-left corner of the window manager frame in root window

518.        --  coordinates.

520.        procedure Get_Frame_ExtentsTo API docTo body

521.          (Window : Gdk_WindowTo API docTo spec;

522.           Rect   : Gdk.Rectangle.Gdk_RectangleTo API docTo spec);

524.        procedure Get_PointerTo API docTo body

525.          (Window : Gdk_WindowTo API docTo spec;

526.           X      : out GintTo API docTo spec;

527.           Y      : out GintTo API docTo spec;

528.           Mask   : out Gdk.Types.Gdk_Modifier_TypeTo API docTo spec;

529.           Result : out Gdk_WindowTo API docTo spec);

531.        function Get_ParentTo API docTo body (Window : Gdk_WindowTo API docTo spec) return Gdk_WindowTo API docTo spec;

533.        function Get_ToplevelTo API docTo body (Window : Gdk_WindowTo API docTo spec) return Gdk_WindowTo API docTo spec;

535.        --  Gdk_Window_List

536.        --

537.        function Convert is new Unchecked_Conversion (Gdk_WindowTo API docTo spec, System.Address);

538.        function Convert is new Unchecked_Conversion (System.Address, Gdk_WindowTo API docTo spec);

540.        package Gdk_Window_List is new

541.          Glib.Glist.Generic_ListTo API docTo specTo body (GpointerTo API docTo spec => Gdk_WindowTo API docTo spec);

543.        function Get_ChildrenTo API docTo body (Window : Gdk_WindowTo API docTo spec) return Gdk_Window_List.GlistTo API docTo specTo body;

545.        function Peek_ChildrenTo API docTo body (Window : Gdk_WindowTo API docTo spec) return Gdk_Window_List.GlistTo API docTo specTo body;

547.        function Get_EventsTo API docTo body (Window : Gdk_WindowTo API docTo spec) return Gdk.Event.Gdk_Event_MaskTo API docTo spec;

549.        procedure Set_EventsTo API docTo body

550.          (Window : Gdk_WindowTo API docTo spec; Event_Mask : Gdk.Event.Gdk_Event_MaskTo API docTo spec);

552.        procedure Set_IconTo API docTo body

553.          (Window      : Gdk_WindowTo API docTo spec;

554.           Icon_Window : Gdk_WindowTo API docTo spec;

555.           Pixmap      : Gdk_PixmapTo API docTo spec;

556.           Mask        : Gdk_BitmapTo API docTo spec);

557.        --  Currently not supported under Windows

559.        procedure Set_Icon_NameTo API docTo body

560.          (Window : Gdk_WindowTo API docTo spec;

561.           Name   : UTF8_StringTo API docTo spec);

563.        procedure Set_GroupTo API docTo body (Window : Gdk_WindowTo API docTo spec; Leader : Gdk_WindowTo API docTo spec);

564.        --  Sets the group leader window for window. By default, GDK sets the group

565.        --  leader for all toplevel windows to a global window implicitly created by

566.        --  GDK. With this function you can override this default.

567.        --

568.        --  The group leader window allows the window manager to distinguish all

569.        --  windows that belong to a single application. It may for example allow

570.        --  users to minimize/unminimize all windows belonging to an application at

571.        --  once. You should only set a non-default group window if your application

572.        --  pretends to be multiple applications.

574.        procedure Set_DecorationsTo API docTo body

575.          (Window      : Gdk_WindowTo API docTo spec;

576.           Decorations : Gdk_Wm_DecorationTo API docTo spec);

578.        procedure Get_DecorationsTo API docTo body

579.          (Window      : Gdk_WindowTo API docTo spec;

580.           Decorations : out Gdk_Wm_DecorationTo API docTo spec;

581.           Success     : out Boolean);

583.        procedure Set_FunctionsTo API docTo body

584.          (Window    : Gdk_WindowTo API docTo spec;

585.           Functions : Gdk_Wm_FunctionTo API docTo spec);

587.        procedure Invalidate_RectTo API docTo body

588.          (Window              : Gdk_WindowTo API docTo spec;

589.           RectangleTo API docTo body           : Gdk.Rectangle.Gdk_RectangleTo API docTo spec;

590.           Invalidate_Children : Boolean);

592.        function Get_ToplevelsTo API docTo body return Gdk_Window_List.GlistTo API docTo specTo body;

593.        --  The returned list must be freed by calling Gdk_Window_List.Free.

594.        --  Consider using Gtk.Window.List_Toplevels instead.

596.        procedure IconifyTo API docTo body (Window : Gdk_WindowTo API docTo spec);

598.        procedure DeiconifyTo API docTo body (Window : Gdk_WindowTo API docTo spec);

600.        procedure StickTo API docTo body (Window : Gdk_WindowTo API docTo spec);

602.        procedure UnstickTo API docTo body (Window : Gdk_WindowTo API docTo spec);

604.        procedure MaximizeTo API docTo body (Window : Gdk_WindowTo API docTo spec);

606.        procedure UnmaximizeTo API docTo body (Window : Gdk_WindowTo API docTo spec);

608.        procedure Register_DndTo API docTo body (Window : Gdk_WindowTo API docTo spec);

610.        function Get_Update_AreaTo API docTo body (Window : Gdk_WindowTo API docTo spec) return Gdk_RegionTo API docTo spec;

612.        procedure Freeze_UpdatesTo API docTo body (Window : Gdk_WindowTo API docTo spec);

614.        procedure Thaw_UpdatesTo API docTo body (Window : Gdk_WindowTo API docTo spec);

616.        procedure Process_All_UpdatesTo API docTo body;

618.        procedure Process_UpdatesTo API docTo body

619.          (Window : Gdk_WindowTo API docTo spec; Update_Children : Boolean := True);

621.        procedure Set_Debug_UpdatesTo API docTo body (Setting : Boolean := True);

623.        procedure RefTo API docTo body (Window : Gdk_WindowTo API docTo spec);

624.        --  Increment the reference counter associated with window.

626.        procedure UnrefTo API docTo body (Window : Gdk_WindowTo API docTo spec);

627.        --  Decrement the reference counter associated with window.

629.        function Get_Window_IdTo API docTo body (Window : Gdk_WindowTo API docTo spec) return System.Address;

630.        --  Return the target specific window id.

631.        --  Under Windows, this returns a HWND object.

632.        --  Under X, this returns a Window object.

634.        pragma Convention (C, Gdk_Window_Type_HintTo API docTo spec);

636.        pragma Convention (C, Gdk_GravityTo API docTo spec);

637.        for Gdk_GravityTo API docTo spec use

638.          (Gravity_North_West => 1,

639.           Gravity_North      => 2,

640.           Gravity_North_East => 3,

641.           Gravity_West       => 4,

642.           Gravity_Center     => 5,

643.           Gravity_East       => 6,

644.           Gravity_South_West => 7,

645.           Gravity_South      => 8,

646.           Gravity_South_East => 9,

647.           Gravity_Static     => 10);

649.        package Window_Type_Hint_Properties is new

650.          Generic_Internal_Discrete_PropertyTo API docTo specTo body (Gdk_Window_Type_HintTo API docTo spec);

651.        package Gravity_Properties is new Generic_Internal_Discrete_PropertyTo API docTo specTo body

652.          (Gdk_GravityTo API docTo spec);

654.        type Property_Window_Type_Hint  is new Window_Type_Hint_Properties.PropertyTo API docTo spec;

655.        type Property_Gravity           is new Gravity_Properties.PropertyTo API docTo spec;

657.     private

659.        Null_WindowTo API docTo spec : constant Gdk_WindowTo API docTo spec := null;

660.        pragma Import (C, Get_TypeTo API docTo spec, "gdk_window_object_get_type");

661.        pragma Import (C, Add_FilterTo API docTo spec, "gdk_window_add_filter");

662.        pragma Import (C, ClearTo API docTo spec, "gdk_window_clear");

663.        pragma Import (C, Clear_AreaTo API docTo spec, "gdk_window_clear_area");

664.        pragma Import (C, Clear_Area_ETo API docTo spec, "gdk_window_clear_area_e");

665.        pragma Import (C, FocusTo API docTo spec, "gdk_window_focus");

666.        pragma Import (C, ScrollTo API docTo spec, "gdk_window_scroll");

667.        pragma Import (C, Shape_Combine_MaskTo API docTo spec, "gdk_window_shape_combine_mask");

668.        pragma Import (C, Shape_Combine_RegionTo API docTo spec, "gdk_window_shape_combine_region");

669.        pragma Import (C, Get_StateTo API docTo spec, "gdk_window_get_state");

670.        pragma Import (C, Set_Type_HintTo API docTo spec, "gdk_window_set_type_hint");

671.        pragma Import (C, Get_Frame_ExtentsTo API docTo spec, "gdk_window_get_frame_extents");

672.        pragma Import (C, IconifyTo API docTo spec, "gdk_window_iconify");

673.        pragma Import (C, DeiconifyTo API docTo spec, "gdk_window_deiconify");

674.        pragma Import (C, StickTo API docTo spec, "gdk_window_stick");

675.        pragma Import (C, UnstickTo API docTo spec, "gdk_window_unstick");

676.        pragma Import (C, MaximizeTo API docTo spec, "gdk_window_maximize");

677.        pragma Import (C, UnmaximizeTo API docTo spec, "gdk_window_unmaximize");

678.        pragma Import (C, Register_DndTo API docTo spec, "gdk_window_register_dnd");

679.        pragma Import (C, Get_Update_AreaTo API docTo spec, "gdk_window_get_update_area");

680.        pragma Import (C, Freeze_UpdatesTo API docTo spec, "gdk_window_freeze_updates");

681.        pragma Import (C, Thaw_UpdatesTo API docTo spec, "gdk_window_thaw_updates");

682.        pragma Import (C, Process_All_UpdatesTo API docTo spec, "gdk_window_process_all_updates");

683.        pragma Import (C, Get_EventsTo API docTo spec, "gdk_window_get_events");

684.        pragma Import (C, Get_GeometryTo API docTo spec, "gdk_window_get_geometry");

685.        pragma Import (C, Get_ParentTo API docTo spec, "gdk_window_get_parent");

686.        pragma Import (C, Get_PositionTo API docTo spec, "gdk_window_get_position");

687.        pragma Import (C, Get_Root_OriginTo API docTo spec, "gdk_window_get_root_origin");

688.        pragma Import (C, Get_ToplevelTo API docTo spec, "gdk_window_get_toplevel");

689.        pragma Import (C, Get_Window_TypeTo API docTo spec, "gdk_window_get_window_type");

690.        pragma Import (C, HideTo API docTo spec, "gdk_window_hide");

691.        pragma Import (C, LowerTo API docTo spec, "gdk_window_lower");

692.        pragma Import (C, Merge_Child_ShapesTo API docTo spec, "gdk_window_merge_child_shapes");

693.        pragma Import (C, MoveTo API docTo spec, "gdk_window_move");

694.        pragma Import (C, Move_ResizeTo API docTo spec, "gdk_window_move_resize");

695.        pragma Import (C, Gdk_RaiseTo API docTo spec, "gdk_window_raise");

696.        pragma Import (C, RefTo API docTo spec, "gdk_drawable_ref");

697.        pragma Import (C, Remove_FilterTo API docTo spec, "gdk_window_remove_filter");

698.        pragma Import (C, ReparentTo API docTo spec, "gdk_window_reparent");

699.        pragma Import (C, ResizeTo API docTo spec, "gdk_window_resize");

700.        pragma Import (C, Set_Child_ShapesTo API docTo spec, "gdk_window_set_child_shapes");

701.        pragma Import (C, Set_DecorationsTo API docTo spec, "gdk_window_set_decorations");

702.        pragma Import (C, Set_EventsTo API docTo spec, "gdk_window_set_events");

703.        pragma Import (C, Set_FunctionsTo API docTo spec, "gdk_window_set_functions");

704.        pragma Import (C, Set_Geometry_HintsTo API docTo spec, "gdk_window_set_geometry_hints");

705.        pragma Import (C, Set_GroupTo API docTo spec, "gdk_window_set_group");

706.        pragma Import (C, Set_HintsTo API docTo spec, "gdk_window_set_hints");

707.        pragma Import (C, Set_Transient_ForTo API docTo spec, "gdk_window_set_transient_for");

708.        pragma Import (C, ShowTo API docTo spec, "gdk_window_show");

709.        pragma Import (C, Show_UnraisedTo API docTo spec, "gdk_window_show_unraised");

710.        pragma Import (C, UnrefTo API docTo spec, "gdk_drawable_unref");

711.        pragma Import (C, WithdrawTo API docTo spec, "gdk_window_withdraw");

712.        pragma Import (C, Set_CursorTo API docTo spec, "gdk_window_set_cursor");

713.        pragma Import (C, Set_IconTo API docTo spec, "gdk_window_set_icon");

714.        pragma Import (C, Get_Window_IdTo API docTo spec, "ada_gdk_get_window_id");

715.        pragma Import (C, Set_OpacityTo API docTo spec, "gdk_window_set_opacity");

716.        pragma Import

717.          (C, Create_Similar_SurfaceTo API docTo spec, "gdk_window_create_similar_surface");

719.        pragma Convention (C, Gdk_Window_TypeTo API docTo spec);

721.        pragma Convention (C, Gdk_Window_ClassTo API docTo spec);

723.        pragma Convention (C, Gdk_Window_EdgeTo API docTo spec);

725.     end Gdk.WindowTo API docTo specTo body;

727.     --  missing:

728.     --  gdk_set_sm_client_id

729.     --  gdk_window_begin_paint_rect

730.     --  gdk_window_begin_paint_region

731.     --  gdk_window_end_paint

732.     --  gdk_window_begin_resize_drag

733.     --  gdk_window_begin_move_drag

734.     --  gdk_window_invalidate_region

735.     --  gdk_window_constrain_size