## 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-2010, 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.     --  <description>

31.     --  This widget implements a top level window.

32.     --  It is used as the base class for dialogs, ...

33.     --

34.     --  A window has both a default widget (to which events are sent if no other

35.     --  widget has been selected and has the focus), and a focus widget (which

36.     --  gets the events and overrides the default widget).

37.     --

38.     --  You can set many hints on the window (its minimum and maximum size, its

39.     --  decoration, etc.) but these are only hints to the window manager, which

40.     --  might not respect them.

41.     --

42.     --  A useful hint, respected by most window managers, can be used to force

43.     --  some secondary windows to stay on top of the main window on the screen

44.     --  (for instance, so that a smaller window can not be hidden by a bigger

45.     --  one). See the function Set_Transient_For below.

46.     --

47.     --  A window can also be modal, i.e. grab all the mouse and keyboard events

48.     --  in the application while it is displayed.

49.     --

50.     --  </description>

51.     --  <c_version>2.16.6</c_version>

52.     --  <group>Windows</group>

53.     --  <screenshot>gtk-window</screenshot>

55.     with Glib.ObjectTo API docTo specTo body;

56.     with Glib.PropertiesTo API docTo specTo body;

57.     with Gdk.EventTo API docTo specTo body;

58.     with Gdk.PixbufTo API docTo specTo body;

59.     with Gdk.TypesTo API docTo spec;

60.     with Gdk.WindowTo API docTo specTo body;

61.     with Gtk.Accel_GroupTo API docTo specTo body;

62.     with Gtk.BinTo API docTo specTo body;

63.     with Gtk.EnumsTo API docTo specTo body;

64.     with Gtk.WidgetTo API docTo specTo body;

66.     package Gtk.WindowTo API docTo specTo body is

68.        type Gtk_Window_RecordTo API docTo body is new Bin.Gtk_Bin_RecordTo API docTo spec with private;

69.        type Gtk_Window is access all Gtk_Window_RecordTo API docTo specTo body'Class;

71.        type Gtk_Window_Group_Record is

72.          new Glib.Object.GObject_RecordTo API docTo specTo body with null record;

73.        type Gtk_Window_Group is access all Gtk_Window_Group_RecordTo API docTo spec'Class;

75.        procedure Gtk_NewTo API docTo body

76.          (Window   : out Gtk_WindowTo API docTo spec;

77.           The_TypeTo API docTo body : Gtk.Enums.Gtk_Window_TypeTo API docTo spec := Gtk.Enums.Window_Toplevel);

78.        --  Create a new window.

79.        --  The_Type specifies the type of the window, and can be either a

80.        --  top level window, a dialog or a popup window. You will most often only

81.        --  need to use Window_Toplevel, the other types are mostly used internally

82.        --  by gtk+.

83.        --  A Popup window is used to display a temporary information window. It has

84.        --  no borders nor resizing handles.

86.        procedure InitializeTo API docTo body

87.          (Window   : access Gtk_Window_RecordTo API docTo specTo body'Class;

88.           The_TypeTo API docTo body : Gtk.Enums.Gtk_Window_TypeTo API docTo spec);

89.        --  Internal initialization function.

90.        --  See the section "Creating your own widgets" in the documentation.

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

93.        --  Return the internal value associated with a Gtk_Window.

95.        procedure Set_TitleTo API docTo body

96.          (Window : access Gtk_Window_RecordTo API docTo specTo body; Title : UTF8_StringTo API docTo spec);

97.        function Get_TitleTo API docTo body (Window : access Gtk_Window_RecordTo API docTo specTo body) return UTF8_StringTo API docTo spec;

98.        --  Change the title of the window, as it appears in the title bar.

99.        --  Note that on some systems you might not be able to change it.

101.        procedure Set_WmclassTo API docTo body

102.          (Window        : access Gtk_Window_RecordTo API docTo specTo body;

103.           Wmclass_Name  : String;

104.           Wmclass_Class : String);

105.        --  Don't use this function. It sets the X Window System "class" and

106.        --  "name" hints for a window. According to the ICCCM, you should

107.        --  always set these to the same value for all windows in an

108.        --  application, and GTK sets them to that value by default, so calling

109.        --  this function is sort of pointless. However, you may want to call

110.        --  Set_Role on each window in your application, for the

111.        --  benefit of the session manager. Setting the role allows the window

112.        --  manager to restore window positions when loading a saved session.

114.        procedure Set_RoleTo API docTo body (Window : access Gtk_Window_RecordTo API docTo specTo body; Role : String);

115.        function Get_RoleTo API docTo body  (Window : access Gtk_Window_RecordTo API docTo specTo body) return String;

116.        --  In combination with the window title, the window role allows a

117.        --  window manager to identify "the same" window when an application is

118.        --  restarted. So for example you might set the "toolbox" role on your

119.        --  app's toolbox window, so that when the user restarts their session,

120.        --  the window manager can put the toolbox back in the same place.

121.        --  If a window already has a unique title, you don't need to set the

122.        --  role, since the WM can use the title to identify the window when

123.        --  restoring the session.

124.        --  Role: unique identifier for the window to be used when restoring a

125.        --  session

127.        function Activate_FocusTo API docTo body (Window : access Gtk_Window_RecordTo API docTo specTo body) return Boolean;

128.        --  Call Gtk.Widget.Activate on the widget that currently has the focus in

129.        --  the window, ie sends an "activate" signal to that widget. Note that this

130.        --  signal does not really exists and is mapped to some widget-specific

131.        --  signal.

132.        --  Return True if the widget could be activated, False otherwise.

133.        --  The Focus widget is set through a signal "set_focus".

135.        function Activate_DefaultTo API docTo body

136.          (Window : access Gtk_Window_RecordTo API docTo specTo body) return Boolean;

137.        --  Activate the default widget in the window.

138.        --  In other words, send an "activate" signal to that widget. Note that

139.        --  this signal is a virtual one and is mapped to some widget specific

140.        --  signal.

141.        --  Return False is the widget could not be activated or if there was

142.        --  no default widget.

143.        --  You can set the default widget with the following calls:

144.        --

145.        --     Gtk.Widget.Set_Flags (Widget, Can_Default);

146.        --     Gtk.Widget.Grab_Default (Widget);

148.        procedure Set_Transient_ForTo API docTo body

149.          (Window : access Gtk_Window_RecordTo API docTo specTo body;

150.           Parent : access Gtk_Window_RecordTo API docTo specTo body'Class);

151.        function Get_Transient_ForTo API docTo body

152.          (Window : access Gtk_Window_RecordTo API docTo specTo body) return Gtk_WindowTo API docTo spec;

153.        --  Specify that Window is a transient window.

154.        --  A transient window is a temporary window, like a popup menu or a

155.        --  dialog box). Parent is the toplevel window of the application to which

156.        --  Window belongs. A window that has set this can expect less decoration

157.        --  from the window manager (for instance no title bar and no borders).

158.        --  (see XSetTransientForHint(3) on Unix systems)

159.        --

160.        --  The main usage of this function is to force Window to be on top of

161.        --  Parent on the screen at all times. Most window managers respect this

162.        --  hint, even if this is not mandatory.

164.        procedure Set_Type_HintTo API docTo body

165.          (Window : access Gtk_Window_RecordTo API docTo specTo body;

166.           HintTo API docTo body   : Gdk.Window.Gdk_Window_Type_HintTo API docTo spec);

167.        function Get_Type_HintTo API docTo body

168.          (Window : access Gtk_Window_RecordTo API docTo specTo body)

169.           return Gdk.Window.Gdk_Window_Type_HintTo API docTo spec;

170.        --  allow the window manager to decorate and handle the window in a way

171.        --  which is suitable to the function of the window in your application.

172.        --  This function should be called before the window becomes visible.

174.        procedure Set_Keep_AboveTo API docTo body

175.          (Window  : access Gtk_Window_RecordTo API docTo specTo body; Setting : Boolean);

176.        procedure Set_Keep_BelowTo API docTo body

177.          (Window  : access Gtk_Window_RecordTo API docTo specTo body; Setting : Boolean);

178.        --  Asks to keep Window above, so that it stays on top. Note that you

179.        --  shouldn't assume the window is definitely above afterward, because other

180.        --  entities (e.g. the user or window managers) could not keep it above, and

181.        --  not all window managers support keeping windows above. But normally the

182.        --  window will end kept above. Just don't write code that crashes if not.

183.        --

184.        --  It's permitted to call this function before showing a window, in which

185.        --  case the window will be kept above when it appears onscreen initially.

186.        --

187.        --  You can track the above state via the "window_state_event" signal on

188.        --  Window.

189.        --

190.        --  Note that, according to the "Extended Window Manager Hints"

191.        --  specification, the above state is mainly meant for user preferences and

192.        --  should not be used by applications e.g. for drawing attention to their

193.        --  dialogs.

195.        procedure Set_Auto_Startup_NotificationTo API docTo body (Setting : Boolean);

196.        --  By default, after showing the first Window for each screen, GTK+ calls

197.        --  gdk_notify_startup_complete(). Call this function to disable the

198.        --  automatic startup notification. You might do this if your first window

199.        --  is a splash screen, and you want to delay notification until after your

200.        --  real main window has been shown, for example.

201.        --

202.        --  In that example, you would disable startup notification temporarily,

203.        --  show your splash screen, then re-enable it so that showing the main

204.        --  window would automatically result in notification.

205.        --

206.        --  Notification is used by the desktop environment to show the user that

207.        --  your application is still loading.

209.        procedure Set_Startup_IdTo API docTo body

210.          (Window     : access Gtk_Window_RecordTo API docTo specTo body;

211.           Startup_Id : String);

212.        --  Startup notification identifiers are used by desktop environment to

213.        --  track application startup, to provide user feedback and other

214.        --  features. This function changes the corresponding property on the

215.        --  underlying Gdk_Window. Normally, startup identifier is managed

216.        --  automatically and you should only use this function in special cases

217.        --  like transferring focus from other processes. You should use this

218.        --  function before calling Present or any equivalent function generating

219.        --  a window map event.

220.        --

221.        --  This function is only useful on X11, not with other GTK+ targets.

223.        function Get_DeletableTo API docTo body (Window : access Gtk_Window_RecordTo API docTo specTo body) return Boolean;

224.        procedure Set_DeletableTo API docTo body

225.          (Window  : access Gtk_Window_RecordTo API docTo specTo body;

226.           Setting : Boolean);

227.        --  By default, windows have a close button in the window frame. Some

228.        --  window managers allow GTK+ to disable this button. If you set the

229.        --  deletable property to False using this function, GTK+ will do its best

230.        --  to convince the window manager not to show a close button. Depending on

231.        --  the system, this function may not have any effect when called on a

232.        --  window that is already visible, so you should call it before calling

233.        --  Gtk.Window.Show.

234.        --

235.        --  On Windows, this function always works, since there's no window manager

236.        --  policy involved.

238.        procedure Set_Destroy_With_ParentTo API docTo body

239.          (Window  : access Gtk_Window_RecordTo API docTo specTo body;

240.           Setting : Boolean := True);

241.        function Get_Destroy_With_ParentTo API docTo body

242.          (Window : access Gtk_Window_RecordTo API docTo specTo body) return Boolean;

243.        --  Set whether destroying the transient parent of Window will also destroy

244.        --  Window itself.

245.        --  This is useful for dialogs that shouldn't persist beyond the lifetime

246.        --  of the main window they're associated with, for example.

248.        procedure Set_Geometry_HintsTo API docTo body

249.          (Window          : access Gtk_Window_RecordTo API docTo specTo body;

250.           Geometry_Widget : Gtk.Widget.Gtk_WidgetTo API docTo spec;

251.           GeometryTo API docTo body        : Gdk.Window.Gdk_GeometryTo API docTo spec;

252.           Geom_Mask       : Gdk.Window.Gdk_Window_HintsTo API docTo spec);

253.        --  Specify some geometry hints for the window.

254.        --  This includes its minimal and maximal sizes, ...

255.        --  These attributes are specified in Geometry.

256.        --  Geom_Mask indicates which of the fields in Geometry are set.

257.        --  Geometry_Widget can be null (and thus is not an access parameter). It

258.        --  adds some extra size to Geometry based on the actual size of

259.        --  Geometry_Widget (the extra amount is Window'Size - Geometry_Widget'Size)

260.        --

261.        --  Geometry.Base_* indicates the size that is used by the window manager

262.        --  to report the size: for instance, if Base_Width = 600 and actual width

263.        --  is 200, the window manager will indicate a width of -400.

264.        --

265.        --  If your window manager respects the hints (and its doesn't have to),

266.        --  then the user will never be able to resize the window to a size not

267.        --  in Geometry.Min_* .. Geometry.Max_*.

268.        --

269.        --  Geometry.*_Inc specifies by which amount the size will be multiplied.

270.        --  For instance, if Width_Inc = 50 and the size reported by the Window

271.        --  Manager is 2x3, then the actual width of the window is 100.

272.        --  Your window's size will always be a multiple of the *_Inc values.

273.        --

274.        --  Geometry.*_Aspect specifies the aspect ratio for the window. The window

275.        --  will always be resized so that the ratio between its width and its

276.        --  height remains in the range Min_Aspect .. Max_Aspect.

278.        procedure Set_DecoratedTo API docTo body

279.          (Window  : access Gtk_Window_RecordTo API docTo specTo body;

280.           Setting : Boolean := True);

281.        function Get_DecoratedTo API docTo body (Window : access Gtk_Window_RecordTo API docTo specTo body) return Boolean;

282.        --  By default, windows are decorated with a title bar, resize

283.        --  controls, etc. Some window managers allow GtkAda to disable these

284.        --  decorations, creating a borderless window. If you set the decorated

285.        --  property to False using this function, GtkAda will do its best to

286.        --  convince the window manager not to decorate the window.

288.        procedure Set_ModalTo API docTo body

289.          (Window : access Gtk_Window_RecordTo API docTo specTo body;  Modal  : Boolean := True);

290.        function Get_ModalTo API docTo body (Window : access Gtk_Window_RecordTo API docTo specTo body) return Boolean;

291.        --  Define the window as being Modal.

292.        --  It will grab the input from the keyboard and the mouse while it is

293.        --  displayed and will release it when it is hidden. The grab is only in

294.        --  effect for the windows that belong to the same application, and will not

295.        --  affect other applications running on the same screen.

296.        --  In cunjunction with Gtk.Main.Main, this is the easiest way to show a

297.        --  dialog to which the user has to answer before the application can

298.        --  continue.

300.        procedure Set_Skip_Pager_HintTo API docTo body

301.          (Window  : access Gtk_Window_RecordTo API docTo specTo body;

302.           Setting : Boolean);

303.        function Get_Skip_Taskbar_HintTo API docTo body

304.          (Window : access Gtk_Window_RecordTo API docTo specTo body)

305.           return Boolean;

306.        --  Windows may set a hint asking the desktop environment not to display

307.        --  the window in the pager. This function sets this hint.

308.        --  (A "pager" is any desktop navigation tool such as a workspace

309.        --  switcher that displays a thumbnail representation of the windows

310.        --  on the screen).

312.        procedure Set_Skip_Taskbar_HintTo API docTo body

313.          (Window  : access Gtk_Window_RecordTo API docTo specTo body;

314.           Setting : Boolean);

315.        function Get_Skip_Pager_HintTo API docTo body

316.          (Window : access Gtk_Window_RecordTo API docTo specTo body)

317.           return Boolean;

318.        --  Windows may set a hint asking the desktop environment not to display

319.        --  the window in the task bar. This function sets this hint.

321.        procedure Set_Urgency_HintTo API docTo body

322.          (Window  : access Gtk_Window_RecordTo API docTo specTo body;

323.           Setting : Boolean);

324.        function Get_Urgency_HintTo API docTo body

325.          (Window : access Gtk_Window_RecordTo API docTo specTo body)

326.           return Boolean;

327.        --  Windows may set a hint asking the desktop environment to draw

328.        --  the users attention to the window. This function sets this hint.

330.        function List_ToplevelsTo API docTo body return Gtk.Widget.Widget_List.GlistTo API docTo specTo body;

331.        --  Return a list of all existing toplevel windows.

332.        --  The widgets in the list are not individually referenced. If you want

333.        --  to iterate through the list and perform actions involving

334.        --  callbacks that might destroy the widgets, you must "ref"erence

335.        --  all the widgets in the list first and then unref all the widgets

336.        --  afterwards.

337.        --  The list itself must be freed by the caller

339.        procedure PresentTo API docTo body (Window : access Gtk_Window_RecordTo API docTo specTo body);

340.        --  Present a window to the user.

341.        --  This may mean raising the window in the stacking order, deiconifying it,

342.        --  moving it to the current desktop, and/or giving it the keyboard focus,

343.        --  possibly dependent on the user's platform, window manager, and

344.        --  preferences.

345.        --

346.        --  If Window is hidden, this function calls Gtk.Widget.Show as well.

347.        --

348.        --  If you are calling this function in response to a user interaction, it

349.        --  is preferable to use Present_With_Time.

351.        procedure Present_With_TimeTo API docTo body

352.          (Window    : access Gtk_Window_RecordTo API docTo specTo body;

353.           Timestamp : Guint32To API docTo spec);

354.        --  Present a window to the user in response to a user interaction.

355.        --  Timestamp is the timestamp of the user interaction (typically a button

356.        --  or key press event) which triggered this call.

357.        --

358.        --  This function should be used when the user tries to open a window

359.        --  that's already open. Say for example the preferences dialog is

360.        --  currently open, and the user chooses Preferences from the menu

361.        --  a second time; use Present to move the already-open dialog

362.        --  where the user can see it.

364.        procedure StickTo API docTo body (Window : access Gtk_Window_RecordTo API docTo specTo body);

365.        --  Ask to stick Window, which means that it will appear on all user

366.        --  desktops. Note that you shouldn't assume the window is definitely

367.        --  stuck afterward, because other entities (e.g. the user or window

368.        --  manager) could unstick it again, and some window managers do not

369.        --  support sticking windows. But normally the window will end up

370.        --  stuck.

371.        --

372.        --  It's permitted to call this function before showing a window.

373.        --

374.        --  You can track stickiness via the "window_state_event" signal

375.        --  on Gtk_Widget.

377.        procedure UnstickTo API docTo body (Window : access Gtk_Window_RecordTo API docTo specTo body);

378.        --  Ask to unstick Window, which means that it will appear on only

379.        --  one of the user's desktops. Note that you shouldn't assume the

380.        --  window is definitely unstuck afterward, because other entities

381.        --  (e.g. the user or window manager) could stick it again. But

382.        --  normally the window will end up stuck.

383.        --

384.        --  You can track stickiness via the "window_state_event" signal

385.        --  on Gtk_Widget.

387.        function Get_OpacityTo API docTo body (Window : access Gtk_Window_RecordTo API docTo specTo body) return GdoubleTo API docTo spec;

388.        procedure Set_OpacityTo API docTo body

389.          (Window  : access Gtk_Window_RecordTo API docTo specTo body;

390.           Opacity : GdoubleTo API docTo spec);

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

392.        --  with opacity 0.0 being fully transparent and 1.0 fully opaque. (Values

393.        --  of the opacity parameter are clamped to the [0.0,1.0] range.) On X11

394.        --  this has any effect only on X screens with a compositing manager

395.        --  running. See Gtk.Widget.Is_Composited. On Windows it should always work.

396.        --

397.        --  Note that on Windows, setting a window's opacity after the window has

398.        --  been shown causes it to flicker once.

400.        --------------

401.        -- Position --

402.        --------------

404.        procedure MoveTo API docTo body (Window : access Gtk_Window_RecordTo API docTo specTo body; X, Y : GintTo API docTo spec);

405.        --  Asks the window manager to move Window to the given position. Window

406.        --  managers are free to ignore this; most window managers ignore requests

407.        --  for initial window positions (instead using a user-defined placement

408.        --  algorithm) and honor requests after the window has already been shown.

409.        --

410.        --  Note: the position is the position of the gravity-determined reference

411.        --  point for the window. The gravity determines two things: first, the

412.        --  location of the reference point in root window coordinates; and second,

413.        --  which point on the window is positioned at the reference point.

414.        --

415.        --  By default the gravity is GRAVITY_NORTH_WEST, so the reference point is

416.        --  simply the (x, y) supplied to Move. The top-left corner of the window

417.        --  decorations (aka window frame or border) will be placed at (x, y).

418.        --  Therefore, to position a window at the top left of the screen, you want

419.        --  to use the default gravity (which is GRAVITY_NORTH_WEST) and move the

420.        --  window to 0,0.

421.        --

422.        --  To position a window at the bottom right corner of the screen, you would

423.        --  set GRAVITY_SOUTH_EAST, which means that the reference point is at x +

424.        --  the window width and y + the window height, and the bottom-right corner

425.        --  of the window border will be placed at that reference point. So, to

426.        --  place a window in the bottom right corner you would first set gravity to

427.        --  south east, then write:

428.        --    Move (Window, Gdk_Screen_Width  - Window_Width,

429.        --                  Gdk_Screen_Height - Window_Height);

431.        procedure Set_PositionTo API docTo body

432.          (Window   : access Gtk_Window_RecordTo API docTo specTo body;

433.           PositionTo API docTo body : Gtk.Enums.Gtk_Window_PositionTo API docTo spec);

434.        --  Specify how the position of the window should be computed.

435.        --  If Position is Win_Pos_Center_Always or Win_Pos_Center, then the window

436.        --  is centered on the screen. In the first case, it is also recentered

437.        --  when the window is resized with Gtk.Widget.Set_Usize (ie except on

438.        --  user action).

439.        --  If Position is Win_Pos_Mouse, then the window is positioned so that it

440.        --  centered around the mouse.

441.        --  If Position is Win_Pos_None, no calculation is done. If

442.        --  Gtk.Widget.Set_Uposition has been called, it is respected. This is the

443.        --  default case.

445.        procedure Get_PositionTo API docTo body

446.          (Window         : access Gtk_Window_RecordTo API docTo specTo body;

447.           Root_X, Root_Y : out GintTo API docTo spec);

448.        --  This function returns the position you need to pass to gtk.window.move

449.        --  to keep Window in its current position. This means that the meaning of

450.        --  the returned value varies with window gravity. See Gtk.Window.Move for

451.        --  more details.

452.        --

453.        --  If you haven't changed the window gravity, its gravity will be

454.        --  GRAVITY_NORTH_WEST. This means that Get_Position gets the position of

455.        --  the top-left corner of the window manager frame for the window.

456.        --  gtk.window.move sets the position of this same top-left corner.

457.        --

458.        --  Get_Position is not 100% reliable because the X Window System does not

459.        --  specify a way to obtain the geometry of the decorations placed on a

460.        --  window by the window manager. Thus GTK+ is using a "best guess" that

461.        --  works with most window managers.

462.        --

463.        --  Moreover, nearly all window managers are historically broken with

464.        --  respect to their handling of window gravity. So moving a window to its

465.        --  current position as returned by Get_Position tends to result in moving

466.        --  the window slightly. Window managers are slowly getting better over

467.        --  time.

468.        --

469.        --  If a window has gravity GRAVITY_STATIC the window manager frame is not

470.        --  relevant, and thus Get_Position will always produce accurate results.

471.        --  However you can't use static gravity to do things like place a window in

472.        --  a corner of the screen, because static gravity ignores the window

473.        --  manager decorations.

474.        --

475.        --  If you are saving and restoring your application's window positions, you

476.        --  should know that it's impossible for applications to do this without

477.        --  getting it somewhat wrong because applications do not have sufficient

478.        --  knowledge of window manager state. The Correct Mechanism is to support

479.        --  the session management protocol (see the "GnomeClient" object in the

480.        --  GNOME libraries for example) and allow the window manager to save your

481.        --  window sizes and positions.

483.        procedure Begin_Move_DragTo API docTo body

484.          (Window    : access Gtk_Window_RecordTo API docTo specTo body;

485.           Button    : GintTo API docTo spec;

486.           Root_X    : GintTo API docTo spec;

487.           Root_Y    : GintTo API docTo spec;

488.           Timestamp : Guint32To API docTo spec);

489.        --  Starts moving a window. This function is used if an application has

490.        --  window movement grips. When GDK can support it, the window movement will

491.        --  be done using the standard mechanism for the window manager or windowing

492.        --  system. Otherwise, GDK will try to emulate window movement, potentially

493.        --  not all that well, depending on the windowing system.

494.        --  (Root_X, Root_Y): Position where the user clicked to initiate the drag,

495.        --  in root window coordinates. Timestamp is the timestamp of the event that

496.        --  initiated the drag

498.        function Parse_GeometryTo API docTo body

499.          (Window   : access Gtk_Window_RecordTo API docTo specTo body;

500.           Geometry : String)

501.           return Boolean;

502.        --  Parses a standard X Window System geometry string - see the manual page

503.        --  for X (type 'man X') for details on this. Parse_Geometry does work on

504.        --  all GTK+ ports including Win32 but is primarily intended for an X

505.        --  environment.

506.        --

507.        --  If either a size or a position can be extracted from the geometry

508.        --  string, Parse_Geometry returns True and calls Set_Default_Size and/or

509.        --  Move to resize/move the window.

510.        --

511.        --  If Parse_Geometry returns True, it will also set the HINT_USER_POS

512.        --  and/or HINT_USER_SIZE hints indicating to the window manager that the

513.        --  size/position of the window was user-specified. This causes most window

514.        --  managers to honor the geometry.

515.        --

516.        --  Note that for Parse_Geometry to work as expected, it has to be called

517.        --  when the window has its "final" size, i.e. after calling Show_All on the

518.        --  contents and Set_Geometry_Hints on the window.

520.        -----------

521.        -- Sizes --

522.        -----------

524.        procedure Set_ResizableTo API docTo body

525.          (Window    : access Gtk_Window_RecordTo API docTo specTo body;

526.           Resizable : Boolean := True);

527.        function Get_ResizableTo API docTo body (Window : access Gtk_Window_RecordTo API docTo specTo body) return Boolean;

528.        --  Sets or gets whether the user can resize a window.

529.        --  Windows are user resizable by default.

531.        procedure Set_GravityTo API docTo body

532.          (Window  : access Gtk_Window_RecordTo API docTo specTo body;

533.           GravityTo API docTo body : Gdk.Window.Gdk_GravityTo API docTo spec);

534.        function Get_GravityTo API docTo body

535.          (Window : access Gtk_Window_RecordTo API docTo specTo body) return Gdk.Window.Gdk_GravityTo API docTo spec;

536.        --  Window gravity defines the "reference point" to be used when

537.        --  positioning or resizing a window. Calls to

538.        --  Gtk.Widget.Set_UPosition will position a different point on the

539.        --  window depending on the window gravity. When the window changes size

540.        --  the reference point determined by the window's gravity will stay in

541.        --  a fixed location.

542.        --

543.        --  See Gdk_Gravity for full details. To briefly summarize,

544.        --  Gravity_North_West means that the reference point is the

545.        --  northwest (top left) corner of the window

546.        --  frame. Gravity_South_East would be the bottom right corner of

547.        --  the frame, and so on. If you want to position the window contents,

548.        --  rather than the window manager's frame, Gravity_Static moves

549.        --  the reference point to the northwest corner of the Gtk_Window

550.        --  itself.

551.        --

552.        --  The default window gravity is Gravity_North_West.

554.        procedure Set_Has_FrameTo API docTo body (Window : access Gtk_Window_RecordTo API docTo specTo body);

555.        function Get_Has_FrameTo API docTo body  (Window : access Gtk_Window_RecordTo API docTo specTo body) return Boolean;

556.        --  If this function is called on a window before it is realized

557.        --  or showed it will have a "frame" window around widget-window.

558.        --  Using the signal frame_event you can receive all events targeted at the

559.        --  frame.

560.        --

561.        --  This function is used by the linux-fb port to implement managed

562.        --  windows, but it could concievably be used by X-programs that

563.        --  want to do their own window decorations.

565.        procedure Set_Frame_DimensionsTo API docTo body

566.          (Window                   : access Gtk_Window_RecordTo API docTo specTo body;

567.           Left, Top, Right, Bottom : GintTo API docTo spec);

568.        procedure Get_Frame_DimensionsTo API docTo body

569.          (Window                   : access Gtk_Window_RecordTo API docTo specTo body;

570.           Left, Top, Right, Bottom : out GintTo API docTo spec);

571.        --  Change the size of the frame border.

572.        --  This has only an effect for windows with frames (see Set_Has_Frame).

574.        procedure FullscreenTo API docTo body   (Window : access Gtk_Window_RecordTo API docTo specTo body);

575.        procedure UnfullscreenTo API docTo body (Window : access Gtk_Window_RecordTo API docTo specTo body);

576.        --  Ask to place Window in fullscreen state.

577.        --  You shouldn't assume the window is definitely full screen afterward,

578.        --  because other entities (user or window manager) could unfullscreen it

579.        --  again and not all window managers honor requests to fullscreen windows.

580.        --  You can track the fullscreen state via the "window_state_event" signal.

582.        procedure IconifyTo API docTo body (Window : access Gtk_Window_RecordTo API docTo specTo body);

583.        --  Ask to iconify Window.

584.        --  Note that you shouldn't assume the window is definitely iconified

585.        --  afterward, because other entities (e.g. the user or window manager)

586.        --  could deiconify it again, or there may not be a window manager in which

587.        --  case iconification isn't possible, etc. But normally the window will end

588.        --  up iconified. Just don't write code that crashes if not.

589.        --

590.        --  It's permitted to call this function before showing a window,

591.        --  in which case the window will be iconified before it ever appears

592.        --  onscreen.

593.        --

594.        --  You can track iconification via the "window_state_event" signal

595.        --  on Gtk_Widget.

597.        procedure DeiconifyTo API docTo body (Window : access Gtk_Window_RecordTo API docTo specTo body);

598.        --  Ask to deiconify Window.

599.        --  Note that you shouldn't assume the window is definitely deiconified

600.        --  afterward, because other entities (e.g. the user or window manager)

601.        --  could iconify it again before your code which assumes deiconification

602.        --  gets to run.

603.        --

604.        --  You can track iconification via the "window_state_event" signal

605.        --  on Gtk_Widget.

607.        procedure MaximizeTo API docTo body (Window : access Gtk_Window_RecordTo API docTo specTo body);

608.        --  Ask to maximize Window, so that it becomes full-screen.

609.        --  Note that you shouldn't assume the window is definitely maximized

610.        --  afterward, because other entities (e.g. the user or window manager)

611.        --  could unmaximize it again, and not all window managers support

612.        --  maximization. But normally the window will end up maximized.

613.        --

614.        --  It's permitted to call this function before showing a window,

615.        --  in which case the window will be maximized when it appears onscreen

616.        --  initially.

617.        --

618.        --  You can track maximization via the "window_state_event" signal

619.        --  on Gtk_Widget.

621.        procedure UnmaximizeTo API docTo body (Window : access Gtk_Window_RecordTo API docTo specTo body);

622.        --  Ask to unmaximize Window.

623.        --  Note that you shouldn't assume the window is definitely unmaximized

624.        --  afterward, because other entities (e.g. the user or window manager)

625.        --  could maximize it again, and not all window managers honor requests to

626.        --  unmaximize. But normally the window will end up unmaximized.

627.        --

628.        --  You can track maximization via the "window_state_event" signal

629.        --  on Gtk_Widget.

631.        procedure Set_Default_SizeTo API docTo body

632.          (Window : access Gtk_Window_RecordTo API docTo specTo body; Width : GintTo API docTo spec; Height : GintTo API docTo spec);

633.        procedure Get_Default_SizeTo API docTo body

634.          (Window : access Gtk_Window_RecordTo API docTo specTo body;

635.           Width  : out GintTo API docTo spec;

636.           Height : out GintTo API docTo spec);

637.        --  Sets the default size of a window. If the window's "natural" size (its

638.        --  size request) is larger than the default, the default will be

639.        --  ignored. More generally, if the default size does not obey the geometry

640.        --  hints for the window (Set_Geometry_Hints can be used to set these

641.        --  explicitly), the default size will be clamped to the nearest permitted

642.        --  size.

643.        --

644.        --  Unlike Gtk.Widget.Set_Size_Request, which sets a size request for a

645.        --  widget and thus would keep users from shrinking the window, this

646.        --  function only sets the initial size, just as if the user had resized the

647.        --  window themselves. Users can still shrink the window again as they

648.        --  normally would. Setting a default size of -1 means to use the "natural"

649.        --  default size (the size request of the window).

650.        --

651.        --  For more control over a window's initial size and how resizing works,

652.        --  investigate Set_Geometry_Hints.

653.        --

654.        --  For some uses, Resize is a more appropriate function.  Resize changes

655.        --  the current size of the window, rather than the size to be used on

656.        --  initial display. Resize always affects the window itself, not the

657.        --  geometry widget.

658.        --

659.        --  The default size of a window only affects the first time a window is

660.        --  shown; if a window is hidden and re-shown, it will remember the size it

661.        --  had prior to hiding, rather than using the default size.

662.        --

663.        --  Windows can't actually be 0x0 in size, they must be at least 1x1, but

664.        --  passing 0 for Width and Height is OK, resulting in a 1x1 default size.

665.        --

666.        --  This has no effect on Popup windows (set in call to Gtk_New).

668.        procedure ResizeTo API docTo body

669.          (Window : access Gtk_Window_RecordTo API docTo specTo body;

670.           Width, Height : GintTo API docTo spec);

671.        --  Resize the window as if the user had done so, obeying geometry

672.        --  constraints. The default geometry constraint is that windows may

673.        --  not be smaller than their size request; to override this

674.        --  constraint, call Gtk.Widget.Set_Size_Request to set the window's

675.        --  request to a smaller value.

676.        --

677.        --  If Resize is called before showing a window for the -- first time, it

678.        --  overrides any default size set with -- Set_Default_Size.

679.        --

680.        --  Windows may not be resized smaller than 1 by 1 pixels. However, as a

681.        --  special case, if both Width and Height are set to -1, the best requested

682.        --  size is recomputed for the window, and used.

684.        procedure Get_SizeTo API docTo body

685.          (Window        : access Gtk_Window_RecordTo API docTo specTo body;

686.           Width, Height : out GintTo API docTo spec);

687.        --  Obtains the current size of Window. If Window is not onscreen, it

688.        --  returns the size GTK+ will suggest to the window manager for the initial

689.        --  window size (but this is not reliably the same as the size the window

690.        --  manager will actually select). The size obtained by Get_Size is the last

691.        --  size received in Gdk_Event_Configure, that is, GTK+ uses its

692.        --  locally-stored size, rather than querying the X server for the size. As

693.        --  a result, if you call Resize then immediately call Get_Size, the size

694.        --  won't have taken effect yet. After the window manager processes the

695.        --  resize request, GTK+ receives notification that the size has changed via

696.        --  a configure event, and the size of the window gets updated.

697.        --

698.        --  Note 1: Nearly any use of this function creates a race condition,

699.        --  because the size of the window may change between the time that you get

700.        --  the size and the time that you perform some action assuming that size is

701.        --  the current size. To avoid race conditions, connect to "configure_event"

702.        --  on the window and adjust your size-dependent state to match the size

703.        --  delivered in the Gdk_Event_Configure.

704.        --

705.        --  Note 2: The returned size does *not* include the size of the window

706.        --  manager decorations (aka the window frame or border). Those are not

707.        --  drawn by GTK+ and GTK+ has no reliable method of determining their size.

708.        --

709.        --  Note 3: If you are getting a window size in order to position the window

710.        --  onscreen, there may be a better way. The preferred way is to simply set

711.        --  the window's semantic type with Set_Type_Hint, which allows the window

712.        --  manager to e.g. center dialogs. Also, if you set the transient parent of

713.        --  dialogs with Set_Transient_For window managers will often center the

714.        --  dialog over its parent window. It's much preferred to let the window

715.        --  manager handle these things rather than doing it yourself, because all

716.        --  apps will behave consistently and according to user prefs if the window

717.        --  manager handles it. Also, the window manager can take the size of the

718.        --  window decorations/border into account, while your application cannot.

719.        --

720.        --  In any case, if you insist on application-specified window positioning,

721.        --  there's *still*> a better way than doing it yourself - Set_Position will

722.        --  frequently handle the details for you.

724.        procedure Reshow_With_Initial_SizeTo API docTo body (Window : access Gtk_Window_RecordTo API docTo specTo body);

725.        --  Hide Window, then reshows it, resetting the default size and position.

726.        --  Used by GUI builders only.

728.        procedure Begin_Resize_DragTo API docTo body

729.          (Window    : access Gtk_Window_RecordTo API docTo specTo body;

730.           EdgeTo API docTo body      : Gdk.Window.Gdk_Window_EdgeTo API docTo spec;

731.           Button    : GintTo API docTo spec;

732.           Root_X    : GintTo API docTo spec;

733.           Root_Y    : GintTo API docTo spec;

734.           Timestamp : Guint32To API docTo spec);

735.        --  Starts resizing a window. This function is used if an application has

736.        --  window resizing controls. When GDK can support it, the resize will be

737.        --  done using the standard mechanism for the window manager or windowing

738.        --  system. Otherwise, GDK will try to emulate window resizing, potentially

739.        --  not all that well, depending on the windowing system.

741.        -----------

742.        -- Icons --

743.        -----------

745.        procedure Set_Icon_NameTo API docTo body (Window : access Gtk_Window_RecordTo API docTo specTo body; Name : String);

746.        function Get_Icon_NameTo API docTo body  (Window : access Gtk_Window_RecordTo API docTo specTo body) return String;

747.        --  Set the icon for the window from a named themed icon. See

748.        --  Gtk.Icon_Them for more details. This has nothing to do with the

749.        --  WM_ICON_NAME property which is mentioned in the ICCCM (and related to

750.        --  window managers)

752.        procedure Set_IconTo API docTo body

753.          (Window : access Gtk_Window_RecordTo API docTo specTo body; Icon : Gdk.Pixbuf.Gdk_PixbufTo API docTo spec);

754.        function Get_IconTo API docTo body

755.          (Window : access Gtk_Window_RecordTo API docTo specTo body) return Gdk.Pixbuf.Gdk_PixbufTo API docTo spec;

756.        --  Sets up the icon representing Window. This icon is used when the window

757.        --  is minimized (also known as iconified). Some window managers or desktop

758.        --  environments may also place it in the window frame, or display it in

759.        --  other contexts.

760.        --

761.        --  The icon should be provided in whatever size it was naturally drawn;

762.        --  that is, don't scale the image before passing it to GTK+. Scaling is

763.        --  postponed until the last minute, when the desired final size is known,

764.        --  to allow best quality.

765.        --

766.        --  If you have your icon hand-drawn in multiple sizes, use

767.        --  Set_Icon_List. Then the best size will be used.

768.        --

769.        --  This function is equivalent to calling Set_Icon_List with a single

770.        --  element.

771.        --

772.        --  See also Set_Default_Icon_List to set the icon for all windows in your

773.        --  application in one go.

775.        procedure Set_Icon_ListTo API docTo body

776.          (Window : access Gtk_Window_RecordTo API docTo specTo body;

777.           ListTo API docTo body   : Glib.Object.Object_Simple_List.GlistTo API docTo specTo body);

778.        function Get_Icon_ListTo API docTo body

779.          (Window : access Gtk_Window_RecordTo API docTo specTo body)

780.           return Glib.Object.Object_Simple_List.GlistTo API docTo specTo body;

781.        --  Sets up the icon representing Window. The icon is used when the window

782.        --  is minimized (also known as iconified). Some window managers or desktop

783.        --  environments may also place it in the window frame, or display it in

784.        --  other contexts.

785.        --

786.        --  Set_Icon_List allows you to pass in the same icon in several hand-drawn

787.        --  sizes. The list should contain the natural sizes your icon is available

788.        --  in; that is, don't scale the image before passing it to GTK+. Scaling is

789.        --  postponed until the last minute, when the desired final size is known,

790.        --  to allow best quality.

791.        --

792.        --  By passing several sizes, you may improve the final image quality of the

793.        --  icon, by reducing or eliminating automatic image scaling.

794.        --

795.        --  Recommended sizes to provide: 16x16, 32x32, 48x48 at minimum, and larger

796.        --  images (64x64, 128x128) if you have them.

797.        --

798.        --  Note that transient windows (those who have been set transient for

799.        --  another window using Set_Transient_For) will inherit their icon from

800.        --  their transient parent. So there's no need to explicitly set the icon on

801.        --  transient windows.

803.        function Set_Icon_From_FileTo API docTo body

804.          (Window   : access Gtk_Window_RecordTo API docTo specTo body;

805.           Filename : String) return Boolean;

806.        --  Equivalent to calling Set_Icon with a pixbuf loaded from Filename.

807.        --  return False on failure.

809.        procedure Set_Default_Icon_ListTo API docTo body

810.          (ListTo API docTo body : Glib.Object.Object_Simple_List.GlistTo API docTo specTo body);

811.        function Get_Default_Icon_ListTo API docTo body

812.          return Glib.Object.Object_Simple_List.GlistTo API docTo specTo body;

813.        --  Sets an icon list to be used as fallback for windows that haven't had

814.        --  Set_Icon_List called on them to setup a window-specific icon list.

816.        procedure Set_Default_IconTo API docTo body (Icon : Gdk.Pixbuf.Gdk_PixbufTo API docTo spec);

817.        --  Sets an icon to be used as a fallback for windows that haven't had

818.        --  Set_Icon called on them

820.        function Set_Default_Icon_From_FileTo API docTo body (Filename : String) return Boolean;

821.        --  Same as Set_Default_Icon, loads the pixbuf automatically.

823.        function Get_Default_Icon_NameTo API docTo body return String;

824.        procedure Set_Default_Icon_NameTo API docTo body (Name : String);

825.        --  Gets/Sets icon to be used as a fallback for windows that haven't had a

826.        --  themed icon set (set Set_Icon_Name).

828.        ------------

829.        -- Groups --

830.        ------------

832.        procedure Gtk_NewTo API docTo body (Group : out Gtk_Window_GroupTo API docTo spec);

833.        --  Create a new window group.

834.        --  Grabs added with Gtk.Main.Grab_Add only affect windows within the same

835.        --  group.

837.        function Group_Get_TypeTo API docTo body return GTypeTo API docTo spec;

838.        --  Return the internal type used for window groups

840.        procedure Group_Add_WindowTo API docTo body

841.          (Window_Group : access Gtk_Window_Group_RecordTo API docTo spec;

842.           Window       : access Gtk_Window_RecordTo API docTo specTo body'Class);

843.        --  Add a window to Window_Group

845.        procedure Group_Remove_WindowTo API docTo body

846.          (Window_Group : access Gtk_Window_Group_RecordTo API docTo spec;

847.           Window       : access Gtk_Window_RecordTo API docTo specTo body'Class);

848.        --  Remove a specific window from the group

850.        function Group_List_WindowsTo API docTo body

851.          (Window_Group : access Gtk_Window_Group_RecordTo API docTo spec)

852.           return Gtk.Widget.Widget_List.GlistTo API docTo specTo body;

853.        --  Returns a list of the Gtk_Windows that belong to Window_Group.

855.        function Get_GroupTo API docTo body

856.          (Window : access Gtk_Window_RecordTo API docTo specTo body) return Gtk_Window_GroupTo API docTo spec;

857.        --  Returns the group for Window or the default group, if

858.        --  Window is null or if Window does not have an explicit

859.        --  window group.

861.        -----------

862.        -- Focus --

863.        -----------

865.        function Get_FocusTo API docTo body (Window : access Gtk_Window_RecordTo API docTo specTo body)

866.           return Gtk.Widget.Gtk_WidgetTo API docTo spec;

867.        --  Return the widget that would have the keyboard focus if

868.        --  Window itself has the focus. It currently has the focus

869.        --  only if Has_Focus_Is_Set returns True.

870.        --  To know whether the Window itself currently has the focus, check the

871.        --    Has_Toplevel_Focus_Property

872.        --  property described below

874.        procedure Set_FocusTo API docTo body

875.          (Window : access Gtk_Window_RecordTo API docTo specTo body;

876.           Focus  : Gtk.Widget.Gtk_WidgetTo API docTo spec);

877.        --  Set the focus child for Window.

878.        --  If Focus is not the current focus widget, and is focusable, sets

879.        --  it as the focus widget for the window. If Focus is null, unsets

880.        --  the focus widget for this window. To set the focus to a particular

881.        --  widget in the toplevel, it is usually more convenient to use

882.        --  gtk_widget_grab_focus() instead of this function.

884.        procedure Set_Accept_FocusTo API docTo body

885.          (Window  : access Gtk_Window_RecordTo API docTo specTo body;  Setting : Boolean);

886.        function Get_Accept_FocusTo API docTo body

887.          (Window : access Gtk_Window_RecordTo API docTo specTo body) return Boolean;

888.        --  Windows may set a hint asking the desktop environment not to receive

889.        --  the input focus.

891.        procedure Set_Focus_On_MapTo API docTo body

892.          (Window  : access Gtk_Window_RecordTo API docTo specTo body; Setting : Boolean);

893.        function Get_Focus_On_MapTo API docTo body

894.          (Window : access Gtk_Window_RecordTo API docTo specTo body) return Boolean;

895.        --  Windows may set a hint asking the desktop environment not to receive

896.        --  the input focus when the window is mapped.

898.        function Has_Toplevel_FocusTo API docTo body

899.          (Window : access Gtk_Window_RecordTo API docTo specTo body) return Boolean;

900.        --  Returns whether the input focus is within this Window. For real toplevel

901.        --  windows, this is identical to Is_Active, but for embedded windows the

902.        --  results will differ

904.        function Is_ActiveTo API docTo body (Window : access Gtk_Window_RecordTo API docTo specTo body) return Boolean;

905.        --  Returns whether the window is part of the current active toplevel. (That

906.        --  is, the toplevel window receiving keystrokes.) The return value is True

907.        --  if the window is active toplevel itself, but also if it is, say, a

908.        --  Gtk_Plug embedded in the active toplevel. You might use this function if

909.        --  you wanted to draw a widget differently in an active window from a

910.        --  widget in an inactive window.

912.        ------------------------

913.        -- Keys and shortcuts --

914.        ------------------------

916.        function Get_Default_WidgetTo API docTo body

917.          (Window : access Gtk_Window_RecordTo API docTo specTo body) return Gtk.Widget.Gtk_WidgetTo API docTo spec;

918.        procedure Set_DefaultTo API docTo body

919.          (Window         : access Gtk_Window_RecordTo API docTo specTo body;

920.           Default_Widget : access Gtk.Widget.Gtk_Widget_RecordTo API docTo specTo body'Class);

921.        --  The default widget is the widget that's activated when the user presses

922.        --  Enter in a dialog (for example). This function sets or unsets the

923.        --  default widget for a Window. When setting (rather than unsetting) the

924.        --  default widget it's generally easier to call Grab_Focus on the widget.

925.        --  Before making a widget the default widget, you must set the CAN_DEFAULT

926.        --  flag on the widget you'd like to make the default using

927.        --  Gtk.Widget.Set_Flags. A null value indicates no default widget.

929.        procedure Set_Mnemonic_ModifierTo API docTo body

930.          (Window   : access Gtk_Window_RecordTo API docTo specTo body;

931.           Modifier : Gdk.Types.Gdk_Modifier_TypeTo API docTo spec);

932.        function Get_Mnemonic_ModifierTo API docTo body

933.          (Window : access Gtk_Window_RecordTo API docTo specTo body)

934.           return Gdk.Types.Gdk_Modifier_TypeTo API docTo spec;

935.        --  Sets the mnemonic modifier for this window.

936.        --  Modifier is the mask used to active mnemonics in this window

938.        procedure Add_MnemonicTo API docTo body

939.          (Window : access Gtk_Window_RecordTo API docTo specTo body;

940.           Keyval : Gdk.Types.Gdk_Key_TypeTo API docTo spec;

941.           Target : access Gtk.Widget.Gtk_Widget_RecordTo API docTo specTo body'Class);

942.        procedure Remove_MnemonicTo API docTo body

943.          (Window : access Gtk_Window_RecordTo API docTo specTo body;

944.           Keyval : Gdk.Types.Gdk_Key_TypeTo API docTo spec;

945.           Target : access Gtk.Widget.Gtk_Widget_RecordTo API docTo specTo body'Class);

946.        --  Add a mnemonic to this window.

947.        --  Target will receive the "activate" signal when Keyval is pressed inside

948.        --  the window. In addition to keyval, the user must press the special key

949.        --  defined through Set_Mnemonic_Modifier

951.        function Mnemonic_ActivateTo API docTo body

952.          (Window   : access Gtk_Window_RecordTo API docTo specTo body;

953.           Keyval   : Gdk.Types.Gdk_Key_TypeTo API docTo spec;

954.           Modifier : Gdk.Types.Gdk_Modifier_TypeTo API docTo spec)

955.          return Boolean;

956.        --  Activates the targets associated with the mnemonic. This sends the

957.        --  "activate" signal to the corresponding signal

959.        function Activate_KeyTo API docTo body

960.          (Window : access Gtk_Window_RecordTo API docTo specTo body;

961.           Event  : Gdk.Event.Gdk_Event_KeyTo API docTo spec) return Boolean;

962.        --  Activates mnemonics and accelerators for this window. This is normally

963.        --  called by the default key_press_event_handler for toplevel windows,

964.        --  however in some cases it may be useful to call this directly when

965.        --  overriding the standard key handling for a toplevel window.

966.        --  Return True if the mnemonic was found and activated.

968.        function Propagate_Key_EventTo API docTo body

969.          (Window : access Gtk_Window_RecordTo API docTo specTo body;

970.           Event  : Gdk.Event.Gdk_Event_KeyTo API docTo spec) return Boolean;

971.        --  Propagate a key press or release event to the focus widget and up the

972.        --  focus container chain until a widget handles Event.

973.        --  This is normally called by the default key_press_event handler, but

974.        --  might be useful when overriding the standard key handling for a

975.        --  toplevel window.

977.        procedure Add_Accel_GroupTo API docTo body

978.          (Window      : access Gtk_Window_RecordTo API docTo specTo body;

979.           Accel_Group : Gtk.Accel_Group.Gtk_Accel_GroupTo API docTo spec);

980.        procedure Remove_Accel_GroupTo API docTo body

981.          (Window      : access Gtk_Window_RecordTo API docTo specTo body;

982.           Accel_Group : Gtk.Accel_Group.Gtk_Accel_GroupTo API docTo spec);

983.        --  Adds or Removes the specified accelerator group for the window, such

984.        --  that calling Gtk.Accel_Groups.Active on Window will activate

985.        --  accelerators in Accel_Group.

987.        -----------------

988.        -- Obsolescent --

989.        -----------------

990.        --  All subprograms below are now obsolescent in gtk+. They might be removed

991.        --  from future versions of gtk+ (and therefore GtkAda).

992.        --  To find out whether your code uses any of these, we recommend compiling

993.        --  with the -gnatwj switch

994.        --  <doc_ignore>

996.        procedure Set_Resizeable

997.          (Window    : access Gtk_Window_RecordTo API docTo specTo body;

998.           Resizable : Boolean := True) renames Set_ResizableTo API docTo specTo body;

999.        --  pragma Obsolescent ("Use Gtk.Window.Set_Resizable instead");

1001.        function Get_Resizeable (Window : access Gtk_Window_RecordTo API docTo specTo body) return Boolean

1002.          renames Get_ResizableTo API docTo specTo body;

1003.        --  pragma Obsolescent ("Use Gtk.Window.Get_Resizable instead");

1005.        procedure Set_PolicyTo API docTo body

1006.          (Window       : access Gtk_Window_RecordTo API docTo specTo body;

1007.           Allow_Shrink : Boolean;

1008.           Allow_Grow   : Boolean;

1009.           Auto_Shrink  : Boolean);

1010.        pragma Obsolescent;  --  Set_Policy

1011.        --  Specify the behavior of the window with regards to size modifications.

1012.        --  Default values when the window is created are:

1013.        --    Allow_Shrink => False,

1014.        --    Allow_Grow   => True,

1015.        --    Auto_Shrink  => False.

1016.        --

1017.        --  If Allow_Shrink is False, then the minimum size of the window is

1018.        --  calculated once depending on its children, and the window can never be

1019.        --  smaller.

1020.        --  If Allow_Grow is False, then the maximum size of the window is

1021.        --  calculated once depending on its children, and the window can never be

1022.        --  bigger.

1023.        --  If Auto_Shrink if False, then the window is not shrinked when its

1024.        --  content changes.

1026.        --  </doc_ignore>

1028.        ----------------

1029.        -- Properties --

1030.        ----------------

1032.        --  <properties>

1033.        --  The following properties are defined for this widget. See

1034.        --  Glib.Properties for more information on properties.

1035.        --

1036.        --  - Name:  Type_Property

1037.        --    Type:  Gtk_Window_Type

1038.        --    Flags: read-write (construct only)

1039.        --    Descr: The type of the window

1040.        --    See also:  Gtk_New

1041.        --

1042.        --  - Name:  Title_Property

1043.        --    Type:  UTF8_String

1044.        --    Flags: read-write

1045.        --    Descr: The title of the window

1046.        --    See also:  Set_Title and Get_Title

1047.        --

1048.        --  - Name:  Role_Property

1049.        --    Type:  String

1050.        --    See:   Set_Role / Get_Role

1051.        --

1052.        --  - Name:  Allow_Shrink_Property

1053.        --    Type:  Boolean

1054.        --    Flags: read-write

1055.        --    Descr: If TRUE, the window has no mimimum size. Don't use this

1056.        --           feature, it makes no sense

1057.        --    See also:  Set_Policy

1058.        --

1059.        --  - Name:  Allow_Grow_Property

1060.        --    Type:  Boolean

1061.        --    Flags: read-write

1062.        --    Descr: If TRUE, users can expand the window beyond its minimum size.

1063.        --    See also:  Set_Policy

1064.        --

1065.        --  - Name: Resizable_Property

1066.        --    Type: Boolean

1067.        --    See:  Set_Resizable / Get_Resizable

1068.        --

1069.        --  - Name:  Modal_Property

1070.        --    Type:  Boolean

1071.        --    Flags: read-write

1072.        --    Descr: If TRUE, the window is modal (other windows are not usable

1073.        --           while this one is up)

1074.        --    See also:  Set_Modal

1075.        --

1076.        --  - Name:  Win_Pos_Property

1077.        --    Type:  Gtk_Window_Position

1078.        --    Flags: read-write

1079.        --    Descr: The initial position of the window.

1080.        --    See also:  Set_Position

1081.        --

1082.        --  - Name:  Default_Width_Property

1083.        --    Type:  Gint

1084.        --    Flags: read-write

1085.        --    Descr: The default width of the window, or 0 to use the size request.

1086.        --    See also:  Set_Default_Size

1087.        --

1088.        --  - Name:  Default_Height_Property

1089.        --    Type:  Gint

1090.        --    Flags: read-write

1091.        --    Descr: The default height of the window, or 0 to use the size request.

1092.        --    See also:  Set_Default_Size

1093.        --

1094.        --  - Name:  Destroy_With_Parent_Property

1095.        --    Type:  Boolean

1096.        --    Flags: read-write

1097.        --    Descr: If this window should be destroyed when the parent is destroyed

1098.        --    See also:  Set_Destroy_With_Parent

1099.        --

1100.        --  - Name:  Has_Toplevel_Focus_Property

1101.        --    Type:  Boolean

1102.        --    Flags: read-only

1103.        --    Descr: Whether the input focus is within this Gtk_Window

1104.        --

1105.        --  - Name:  Is_Active_Property

1106.        --    Type:  Boolean

1107.        --    Flags: read-only

1108.        --    Descr: Whether the toplevel is the current active window

1109.        --

1110.        --  Name:  Deletable_Property

1111.        --  Type:  Boolean

1112.        --  Descr: Whether the window frame should have a close button

1113.        --

1114.        --  Name:  Opacity_Property

1115.        --  Type:  Double

1116.        --  Descr: The opacity of the window, from 0.0 to 1.0

1117.        --

1118.        --  Name:  Startup_Id_Property

1119.        --  Type:  String

1120.        --  Descr: Unique startup identifier for the window used by

1121.        --         startup-notification

1122.        --

1123.        --  Name:  Transient_For_Property

1124.        --  Type:  Object

1125.        --  Descr: The transient parent of the dialog

1126.        --

1127.        --  </properties>

1129.        Type_Property                : constant Gtk.Enums.Property_Gtk_Window_TypeTo API docTo spec;

1130.        Title_Property               : constant Glib.Properties.Property_StringTo API docTo spec;

1131.        Role_Property                : constant Glib.Properties.Property_StringTo API docTo spec;

1132.        Allow_Shrink_Property        : constant Glib.Properties.Property_BooleanTo API docTo spec;

1133.        Allow_Grow_Property          : constant Glib.Properties.Property_BooleanTo API docTo spec;

1134.        Modal_Property               : constant Glib.Properties.Property_BooleanTo API docTo spec;

1135.        Resizable_Property           : constant Glib.Properties.Property_BooleanTo API docTo spec;

1136.        Has_Toplevel_Focus_Property  : constant Glib.Properties.Property_BooleanTo API docTo spec;

1137.        Is_Active_Property           : constant Glib.Properties.Property_BooleanTo API docTo spec;

1138.        Window_Position_Property  : constant Gtk.Enums.Property_Gtk_Window_PositionTo API docTo spec;

1139.        Default_Width_Property       : constant Glib.Properties.Property_IntTo API docTo spec;

1140.        Default_Height_Property      : constant Glib.Properties.Property_IntTo API docTo spec;

1141.        Destroy_With_Parent_Property : constant Glib.Properties.Property_BooleanTo API docTo spec;

1142.        Icon_Property                : constant Glib.Properties.Property_ObjectTo API docTo spec;

1143.        Icon_Name_Property           : constant Glib.Properties.Property_StringTo API docTo spec;

1144.        Screen_Property              : constant Glib.Properties.Property_ObjectTo API docTo spec;

1145.        Type_Hint_Property          : constant Gdk.Window.Property_Window_Type_HintTo API docTo spec;

1146.        Skip_Taskbar_Hint_Property   : constant Glib.Properties.Property_BooleanTo API docTo spec;

1147.        Skip_Pager_Hint_Property     : constant Glib.Properties.Property_BooleanTo API docTo spec;

1148.        Urgency_Hint_Property        : constant Glib.Properties.Property_BooleanTo API docTo spec;

1149.        Accept_Focus_Property        : constant Glib.Properties.Property_BooleanTo API docTo spec;

1150.        Focus_On_Map_Property        : constant Glib.Properties.Property_BooleanTo API docTo spec;

1151.        Decorated_Property           : constant Glib.Properties.Property_BooleanTo API docTo spec;

1152.        Gravity_Property             : constant Gdk.Window.Property_GravityTo API docTo spec;

1153.        Deletable_Property           : constant Glib.Properties.Property_BooleanTo API docTo spec;

1154.        Opacity_Property             : constant Glib.Properties.Property_DoubleTo API docTo spec;

1155.        Startup_Id_Property          : constant Glib.Properties.Property_StringTo API docTo spec;

1156.        Transient_For_Property       : constant Glib.Properties.Property_ObjectTo API docTo spec;

1158.        -------------

1159.        -- Signals --

1160.        -------------

1162.        --  <signals>

1163.        --  The following new signals are defined for this widget:

1164.        --

1165.        --  - "set_focus"

1166.        --    procedure Handler (Window : access Gtk_Window_Record'Class;

1167.        --                       Widget : access Gtk_Widget_Record'Class);

1168.        --    Called when the widget that has the focus has changed.

1169.        --    This widget gets all keyboard events that happen in the window.

1170.        --    You should not block the emission of this signal, since most of

1171.        --    the work is done in the default handler.

1172.        --

1173.        --  - "frame_event"

1174.        --    function Handler

1175.        --      (Window : access Gtk_Window_Record'Class;

1176.        --       Event  : Gdk.Event.Gdk_Event) return Boolean;

1177.        --    If this function is called on a window before it is realized

1178.        --    or showed it will have a "frame" window around widget-window.

1179.        --    Called when the "frame" window set around a window receives events.

1180.        --    This is mainly used by the linux-fb port to implement managed

1181.        --    windows, but it could concievably be used by X-programs that

1182.        --    want to do their own window decorations.

1183.        --

1184.        --  - "activate_focus"

1185.        --    procedure Handler (Window : access Gtk_Window_Record'Class);

1186.        --    You should emit this signal to request that the currently focused

1187.        --    widget receives the "activate" signal. This is the same as calling

1188.        --    Activate_Focus, but can be bound to a key binding

1189.        --

1190.        --  - "activate_default"

1191.        --    procedure Handler (Window : access Gtk_Window_Record'Class);

1192.        --    Same as Activate_Default, but can be bound to a key binding

1193.        --

1194.        --  - "move_focus"

1195.        --    procedure Handler

1196.        --       (Window    : access Gtk_Window_Record'Class;

1197.        --        Direction : Gtk_Direction_Type);

1198.        --    Emitted when a new child gains the focus

1199.        --

1200.        --  - "keys_changed"

1201.        --    procedure Handler (Window : access Gtk_Window_Record'Class);

1202.        --    Emitted when the key accelerators or mnemonics are changed for the

1203.        --    window.

1204.        --

1205.        --  </signals>

1207.        Signal_Set_Focus        : constant Glib.Signal_NameTo API docTo spec := "set_focus";

1208.        Signal_Frame_Event      : constant Glib.Signal_NameTo API docTo spec := "frame_event";

1209.        Signal_Activate_Focus   : constant Glib.Signal_NameTo API docTo spec := "activate_focus";

1210.        Signal_Activate_Default : constant Glib.Signal_NameTo API docTo spec := "activate_default";

1211.        Signal_Move_Focus       : constant Glib.Signal_NameTo API docTo spec := "move_focus";

1212.        Signal_Keys_Changed     : constant Glib.Signal_NameTo API docTo spec := "keys_changed";

1214.     private

1215.        type Gtk_Window_RecordTo API docTo spec is new Bin.Gtk_Bin_RecordTo API docTo spec with null record;

1217.        Type_PropertyTo API docTo spec              : constant Gtk.Enums.Property_Gtk_Window_TypeTo API docTo spec :=

1218.          Gtk.Enums.BuildTo API docTo specTo body ("type");

1219.        Title_PropertyTo API docTo spec               : constant Glib.Properties.Property_StringTo API docTo spec :=

1220.          Glib.Properties.BuildTo API docTo specTo body ("title");

1221.        Allow_Shrink_PropertyTo API docTo spec        : constant Glib.Properties.Property_BooleanTo API docTo spec :=

1222.          Glib.Properties.BuildTo API docTo specTo body ("allow_shrink");

1223.        Allow_Grow_PropertyTo API docTo spec          : constant Glib.Properties.Property_BooleanTo API docTo spec :=

1224.          Glib.Properties.BuildTo API docTo specTo body ("allow_grow");

1225.        Modal_PropertyTo API docTo spec               : constant Glib.Properties.Property_BooleanTo API docTo spec :=

1226.          Glib.Properties.BuildTo API docTo specTo body ("modal");

1227.        Win_Pos_Property       : constant Gtk.Enums.Property_Gtk_Window_PositionTo API docTo spec :=

1228.          Gtk.Enums.BuildTo API docTo specTo body ("window_position");

1229.        Default_Width_PropertyTo API docTo spec       : constant Glib.Properties.Property_IntTo API docTo spec :=

1230.          Glib.Properties.BuildTo API docTo specTo body ("default_width");

1231.        Default_Height_PropertyTo API docTo spec      : constant Glib.Properties.Property_IntTo API docTo spec :=

1232.          Glib.Properties.BuildTo API docTo specTo body ("default_height");

1233.        Destroy_With_Parent_PropertyTo API docTo spec : constant Glib.Properties.Property_BooleanTo API docTo spec :=

1234.          Glib.Properties.BuildTo API docTo specTo body ("destroy_with_parent");

1235.        Has_Toplevel_Focus_PropertyTo API docTo spec : constant Glib.Properties.Property_BooleanTo API docTo spec :=

1236.          Glib.Properties.BuildTo API docTo specTo body ("has_toplevel_focus");

1237.        Is_Active_PropertyTo API docTo spec        : constant Glib.Properties.Property_BooleanTo API docTo spec :=

1238.          Glib.Properties.BuildTo API docTo specTo body ("is_active");

1239.        Icon_PropertyTo API docTo spec                : constant Glib.Properties.Property_ObjectTo API docTo spec :=

1240.          Glib.Properties.BuildTo API docTo specTo body ("icon");

1241.        Icon_Name_PropertyTo API docTo spec           : constant Glib.Properties.Property_StringTo API docTo spec :=

1242.          Glib.Properties.BuildTo API docTo specTo body ("icon-name");

1243.        Screen_PropertyTo API docTo spec              : constant Glib.Properties.Property_ObjectTo API docTo spec :=

1244.          Glib.Properties.BuildTo API docTo specTo body ("screen");

1245.        Type_Hint_PropertyTo API docTo spec        : constant Gdk.Window.Property_Window_Type_HintTo API docTo spec :=

1246.          Gdk.Window.BuildTo API docTo specTo body ("type-hint");

1247.        Skip_Taskbar_Hint_PropertyTo API docTo spec   : constant Glib.Properties.Property_BooleanTo API docTo spec :=

1248.          Glib.Properties.BuildTo API docTo specTo body ("skip-taskbar-hint");

1249.        Skip_Pager_Hint_PropertyTo API docTo spec     : constant Glib.Properties.Property_BooleanTo API docTo spec :=

1250.          Glib.Properties.BuildTo API docTo specTo body ("skip-pager-hint");

1251.        Urgency_Hint_PropertyTo API docTo spec        : constant Glib.Properties.Property_BooleanTo API docTo spec :=

1252.          Glib.Properties.BuildTo API docTo specTo body ("urgency-hint");

1253.        Accept_Focus_PropertyTo API docTo spec        : constant Glib.Properties.Property_BooleanTo API docTo spec :=

1254.          Glib.Properties.BuildTo API docTo specTo body ("accept-focus");

1255.        Focus_On_Map_PropertyTo API docTo spec        : constant Glib.Properties.Property_BooleanTo API docTo spec :=

1256.          Glib.Properties.BuildTo API docTo specTo body ("focus-on-map");

1257.        Decorated_PropertyTo API docTo spec           : constant Glib.Properties.Property_BooleanTo API docTo spec :=

1258.          Glib.Properties.BuildTo API docTo specTo body ("decorated");

1259.        Gravity_PropertyTo API docTo spec             : constant Gdk.Window.Property_GravityTo API docTo spec :=

1260.          Gdk.Window.BuildTo API docTo specTo body ("gravity");

1261.        Window_Position_PropertyTo API docTo spec     :

1262.          constant Gtk.Enums.Property_Gtk_Window_PositionTo API docTo spec :=

1263.          Gtk.Enums.BuildTo API docTo specTo body ("window-position");

1264.        Resizable_PropertyTo API docTo spec           : constant Glib.Properties.Property_BooleanTo API docTo spec :=

1265.          Glib.Properties.BuildTo API docTo specTo body ("resizable");

1266.        Role_PropertyTo API docTo spec                : constant Glib.Properties.Property_StringTo API docTo spec :=

1267.          Glib.Properties.BuildTo API docTo specTo body ("role");

1268.        Deletable_PropertyTo API docTo spec : constant Glib.Properties.Property_BooleanTo API docTo spec :=

1269.          Glib.Properties.BuildTo API docTo specTo body ("deletable");

1270.        Opacity_PropertyTo API docTo spec : constant Glib.Properties.Property_DoubleTo API docTo spec :=

1271.          Glib.Properties.BuildTo API docTo specTo body ("opacity");

1272.        Startup_Id_PropertyTo API docTo spec : constant Glib.Properties.Property_StringTo API docTo spec :=

1273.          Glib.Properties.BuildTo API docTo specTo body ("startup-id");

1274.        Transient_For_PropertyTo API docTo spec : constant Glib.Properties.Property_ObjectTo API docTo spec :=

1275.          Glib.Properties.BuildTo API docTo specTo body ("transient-for");

1277.        pragma Import (C, Get_TypeTo API docTo spec, "gtk_window_get_type");

1278.        pragma Import (C, Group_Get_TypeTo API docTo spec, "gtk_window_group_get_type");

1279.     end Gtk.WindowTo API docTo specTo body;

1281.     --  <example>

1282.     --  <include>../examples/documentation/banner.adb</include>

1283.     --  </example>

1285.     --  No binding: gtk_window_get_screen

1286.     --  No binding: gtk_window_set_screen

1287.     --  No binding: gtk_window_add_embedded_xid

1288.     --  No binding: gtk_window_remove_embedded_xid