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

31.     --

32.     --  This widget is the base of the tree for displayable objects.

33.     --  (A displayable object is one which takes up some amount

34.     --  of screen real estate). It provides a common base and interface

35.     --  which actual widgets must adhere to.

36.     --

37.     --  This package provides some services which might have been more appropriate

38.     --  in some other packages, but could not because of dependency circularities

39.     --  (there are for instance some functions relating to colors and colormaps).

40.     --  We have tried to reference these functions in the other packages as well.

41.     --

42.     --  </description>

43.     --  <c_version>2.16.6</c_version>

44.     --  <group>Abstract base classes</group>

46.     with System;

47.     with Glib.ObjectTo API docTo specTo body;

48.     with Glib.PropertiesTo API docTo specTo body;

49.     with Glib.GlistTo API docTo specTo body;

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

51.     with Glib.GSlistTo API docTo specTo body;

52.     pragma Elaborate_All (Glib.GSlistTo API docTo specTo body);

53.     with Glib.ValuesTo API docTo specTo body;

55.     with Pango.ContextTo API docTo specTo body;

56.     with Pango.FontTo API docTo specTo body;

57.     with Pango.LayoutTo API docTo specTo body;

59.     with Gdk.ColorTo API docTo specTo body;

60.     with Gdk.EventTo API docTo specTo body;

61.     with Gdk.BitmapTo API docTo specTo body;

62.     with Gdk.RectangleTo API docTo specTo body;

63.     with Gdk.RegionTo API docTo specTo body;

64.     with Gdk.PixbufTo API docTo specTo body;

65.     with Gdk.PixmapTo API docTo specTo body;

66.     with Gdk.TypesTo API docTo spec;

67.     with Gdk.VisualTo API docTo specTo body;

68.     with Gdk.WindowTo API docTo specTo body;

70.     with Gtk.Accel_GroupTo API docTo specTo body;

71.     with Gtk.AdjustmentTo API docTo specTo body;

72.     with Gtk.EnumsTo API docTo specTo body;

73.     with Gtk.StyleTo API docTo specTo body;

75.     package Gtk.WidgetTo API docTo specTo body is

76.        type Gtk_Widget_RecordTo API docTo body is new Glib.Object.GObject_RecordTo API docTo specTo body with private;

77.        type Gtk_Widget is access all Gtk_Widget_RecordTo API docTo specTo body'Class;

79.        type Gtk_Requisition is record

80.           Width  : GintTo API docTo spec;

81.           Height : GintTo API docTo spec;

82.        end record;

83.        --  Gtk_Requisition is the desired amount of screen real-estate a widget

84.        --  requests to the server. Its real allocated size might be different.

85.        --  See the section in the GtkAda user guide on how to create new widgets

86.        --  in Ada, and the examples/base_widget directory for an example on how to

87.        --  use this.

88.        pragma Convention (C, Gtk_RequisitionTo API docTo spec);

90.        type Gtk_Requisition_Access is access all Gtk_RequisitionTo API docTo spec;

91.        pragma Convention (C, Gtk_Requisition_AccessTo API docTo spec);

92.        --  This type is used to create new widgets.

94.        type Gtk_Allocation is record

95.           X      : GintTo API docTo spec;

96.           Y      : GintTo API docTo spec;

97.           Width  : Allocation_IntTo API docTo spec;

98.           Height : Allocation_IntTo API docTo spec;

99.        end record;

100.        --  Gtk_Allocation indicates a size and position a widget was allocated.

101.        --  See the section in the user guide on how to create new widgets for more

102.        --  information.

103.        pragma Convention (C, Gtk_AllocationTo API docTo spec);

105.        type Gtk_Allocation_Access is access all Gtk_AllocationTo API docTo spec;

106.        pragma Convention (C, Gtk_Allocation_AccessTo API docTo spec);

107.        --  This type is used to create new widgets.

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

110.        --  Return the internal type associated with a Gtk_Widget.

112.        function Requisition_Get_TypeTo API docTo body return Glib.GTypeTo API docTo spec;

113.        --  Return the internal type for a Gtk_Requisition

115.        --------------------------------------

116.        -- Definitions for lists of widgets --

117.        --------------------------------------

119.        --  <doc_ignore>

120.        function ConvertTo API docTo body (W : Gtk_WidgetTo API docTo spec) return System.Address;

121.        function ConvertTo API docTo body (W : System.Address) return Gtk_WidgetTo API docTo spec;

122.        --  </doc_ignore>

124.        package Widget_List is new Glib.Glist.Generic_ListTo API docTo specTo body (Gtk_WidgetTo API docTo spec);

125.        package Widget_SList is new Glib.GSlist.Generic_SListTo API docTo specTo body (Gtk_WidgetTo API docTo spec);

127.        -------------------------

128.        -- Widgets' life cycle --

129.        -------------------------

131.        procedure DestroyTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

132.        --  Destroy the widget.

133.        --  This emits a "destroy" signal, calls all your handlers, and then

134.        --  unconnects them all. The object is then unref-ed, and if its reference

135.        --  count goes down to 0, the memory associated with the object and its

136.        --  user data is freed.

137.        --  Note that when you destroy handlers are called, the user_data is still

138.        --  available.

139.        --

140.        --  When a widget is destroyed, it will break any references it holds to

141.        --  other objects. If the widget is inside a container, the widget will be

142.        --  removed from the container. If the widget is a toplevel (derived from

143.        --  Gtk_Window), it will be removed from the list of toplevels, and the

144.        --  reference GTK+ holds to it will be removed. Removing widget from its

145.        --  container or the list of toplevels results in the widget being

146.        --  finalized, unless you've added additional references to the widget with

147.        --  Ref.

148.        --

149.        --  In most cases, only toplevel widgets (windows) require explicit

150.        --  destruction, because when you destroy a toplevel its children will be

151.        --  destroyed as well.

153.        procedure Destroy_CbTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body'Class);

154.        --  This function should be used as a callback to destroy a widget.

155.        --  All it does is call Destroy on its argument, but its profile is

156.        --  compatible with the handlers found in Gtk.Handlers.

158.        procedure UnparentTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body'Class);

159.        --  This function is only for use in widget implementations.

160.        --  Should be called by implementations of the remove method

161.        --  on Gtk_Container, to dissociate a child from the container.

162.        --  Users should call Remove instead.

163.        --  This function might be dangereous: it correctly updates widget to

164.        --  reflect that it no longer belongs to its parent, however the parent

165.        --  keeps an internal pointer to the widget, which will result in a

166.        --  storage_error if you try to further access it.

168.        procedure ShowTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

169.        --  Schedule the widget to be displayed on the screen when its parent is

170.        --  also shown (emits the "show" signal).

171.        --  If its ancestors are already mapped to the screen, then the widget is

172.        --  immediately displayed through a call to Map below.

174.        procedure Show_NowTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

175.        --  Show the widget.

176.        --  If it is an unmapped toplevel widget, wait for it to be mapped. This

177.        --  creates a recursive main_loop.

179.        procedure HideTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

180.        --  Hide the widget from the screen (emits the "hide" signal).

181.        --  If Widget was visible, it is immediately hidden.

182.        --  If one of its ancestor is later shown on the screen, Widget won't

183.        --  appear.

184.        --  Note that on some window managers, including CDE, hiding an iconified

185.        --  window will not do anything. You should in addition call

186.        --  Gdk.Window.Withdraw to make sure the window is properly hidden.

188.        procedure Show_AllTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

189.        --  Show Widget and all its children recursively.

190.        --  See also Set_Child_Visible below

192.        procedure Hide_AllTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

193.        --  Hide Widget and all its children.

194.        --  Note that if you simply want to delete Widget from the screen, you can

195.        --  simply call the Hide subprogram on it. This procedure Hide_All should

196.        --  only be used if you want to unschedule a widget to be displayed later,

197.        --  not to remove an actual widget from the screen.

198.        --  See also Set_Child_Visible below.

200.        procedure Set_No_Show_AllTo API docTo body

201.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body; No_Show_All : Boolean);

202.        function Get_No_Show_AllTo API docTo body

203.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return Boolean;

204.        --  Sets the "no_show_all" property, which determines whether calls to

205.        --  Show_All() and Hide_All() will affect this widget.

206.        --  This is mostly for use in constructing widget hierarchies with

207.        --  externally controlled visibility.

209.        procedure MapTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

210.        --  Map a widget to the screen.

211.        --  A window is created for it on the screen (through a call to Realize) and

212.        --  Widget is then drawn on the screen (if its ancestors are also mapped).

213.        --  This function is recursive and will also map all the children of Widget.

214.        --

215.        --  It is recommended to use the higher-level Show instead.

217.        procedure UnmapTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

218.        --  Unmap a widget from the screen.

219.        --  This results in the widget being hidden, but not destroyed. It can be

220.        --  shown again any time through a call to Map (provided its ancestors are

221.        --  also mapped).

222.        --

223.        --  It is recommended to use the higher-level Hide instead.

225.        procedure RealizeTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

226.        --  Create a window for Widget and its ancestors (emit the "realize" signal)

227.        --  This does not mean that the widget will appear on the screen, but

228.        --  resources such as colormaps, etc. become available.

229.        --  Some routines require that the widget is realized before any call.

230.        --  You must set the Event_Mask before calling this routine if you want to

231.        --  change it from its default value.

233.        procedure UnrealizeTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

234.        --  Hide the widget from the screen and deletes the associated window.

235.        --  This does not destroy the widget itself, only its server-side

236.        --  resources.

238.        generic

239.           type Widget_Type is new Gtk_Widget_RecordTo API docTo specTo body with private;

240.           with procedure Realize_Proc (Widget : access Widget_TypeTo API docTo spec'Class);

241.        package Realize_HandlingTo API docTo body is

243.           procedure Set_RealizeTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body'Class);

244.           --  Set the realize handler at the low level.

245.           --  This is needed to replace the default realize in new widgets.

247.        private

248.           --  <doc_ignore>

249.           procedure Internal_Realize (Widget : System.Address);

250.           --  The wrapper passed to Gtk+.

251.           pragma Convention (C, Internal_Realize);

252.           --  </doc_ignore>

253.        end Realize_HandlingTo API docTo specTo body;

255.        function Hide_On_DeleteTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body'Class)

256.           return Boolean;

257.        --  Hide widget and return True.

258.        --  This function is intended to be used as a callback.

260.        procedure Set_Child_VisibleTo API docTo body

261.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body; Is_Visible : Boolean);

262.        function Get_Child_VisibleTo API docTo body

263.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return Boolean;

264.        --  Sets whether Widget should be mapped along with its parent when its

265.        --  parent is mapped and Widget has been shown with Show.

266.        --

267.        --  "mapped" indicates the moment the window is actually shown on the

268.        --  screen. Show and Hide indicate your intention to show Widget on the

269.        --  scree or not, but if the parent of Widget is itself not shown at that

270.        --  time, the two commands Show and Hide have no immediate effect, and just

271.        --  set a flag to save your intent.

272.        --  Set_Child_Visible indicates that the widget shouldn't be part of the

273.        --  recursive processing done by Show_All and Hide_All on the parent. You

274.        --  have decided once and for all what the behavior should be, and you don't

275.        --  want it to be changed by future calls to Show_All and Hide_All.

276.        --

277.        --  The child visibility can be set for widget before it is added to a

278.        --  container with Set_Parent, to avoid mapping children unnecessary before

279.        --  immediately unmapping them. However it will be reset to its default

280.        --  state of True when the widget is removed from a container.

281.        --

282.        --  Note that changing the child visibility of a widget does not

283.        --  queue a resize on the widget. Most of the time, the size of

284.        --  a widget is computed from all visible children, whether or

285.        --  not they are mapped. If this is not the case, the container

286.        --  can queue a resize itself.

287.        --

288.        --  This function is only useful for container implementations and

289.        --  should generally not be called by an application.

291.        function Has_ScreenTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return Boolean;

292.        --  Checks whether there is a Gdk_Screen is associated with

293.        --  this widget. All toplevel widgets have an associated

294.        --  screen, and all widgets added into a hierarchy with a toplevel

295.        --  window at the top.

297.        ----------------------

298.        -- Drawing a widget --

299.        ----------------------

301.        procedure Queue_DrawTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

302.        --  Add a drawing request to the event queue for the whole widget.

303.        --  This is more efficient than calling Draw directly, since GtkAda groups

304.        --  drawing requests as much as possible to speed up the drawing process.

305.        --  The actual drawing will take place as soon as GtkAda is not busy

306.        --  processing other events, but before idle events.

308.        procedure Queue_Draw_AreaTo API docTo body

309.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body;

310.           X      : GintTo API docTo spec;

311.           Y      : GintTo API docTo spec;

312.           Width  : GintTo API docTo spec;

313.           Height : GintTo API docTo spec);

314.        --  Add a drawing request to the event queue for part of the widget.

315.        --  This is more efficient that calling Draw directly (see Queue_Draw).

317.        procedure Queue_ResizeTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

318.        --  Queue drawing requests after a resizing of the widget.

319.        --  This clears the widget, and its parent if any, so that everything is

320.        --  correctly redrawn.

321.        --  You should not have to call this function directly.

322.        --  For a Gtk_Window, check the procedure Gtk.Window.Resize instead.

324.        procedure Queue_Resize_No_RedrawTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

325.        --  This function works like Queue_Resize(), except that the

326.        --  widget is not invalidated (ie will not be redrawn)

328.        function Create_Pango_ContextTo API docTo body

329.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return Pango.Context.Pango_ContextTo API docTo spec;

330.        --  Create a new Pango_Context with the appropriate colormap, font

331.        --  description, and base direction for drawing text for this widget. See

332.        --  also Get_Pango_Context.

333.        --  The returned context must be freed by the caller.

335.        function Create_Pango_LayoutTo API docTo body

336.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body; Text : UTF8_StringTo API docTo spec := "")

337.           return Pango.Layout.Pango_LayoutTo API docTo spec;

338.        --  Return a new pango_layout that displays Text. This fully handles

339.        --  internationalization, and should be the preferred way to display text,

340.        --  rather than Gdk.Drawable.Draw_Text

341.        --  Text must be a valid Utf8 text, see Glib.Convert.

343.        -----------------------

344.        -- Size and position --

345.        -----------------------

347.        procedure Size_RequestTo API docTo body

348.          (Widget      : access Gtk_Widget_RecordTo API docTo specTo body;

349.           RequisitionTo API docTo body : in out Gtk_RequisitionTo API docTo spec);

350.        --  Emit a "size_request" event for the widget

352.        procedure Set_Size_RequestTo API docTo body

353.          (Widget      : access Gtk_Widget_RecordTo API docTo specTo body;

354.           Width, Height : GintTo API docTo spec := -1);

355.        procedure Get_Size_RequestTo API docTo body

356.          (Widget        : access Gtk_Widget_RecordTo API docTo specTo body;

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

358.        --  Sets the minimum size of a widget; that is, the widget's size request

359.        --  will be Width by Height. You can use this function to force a widget to

360.        --  be either larger or smaller than it normally would be.

361.        --

362.        --  In most cases, Set_Default_Size is a better choice for toplevel windows

363.        --  than this function; setting the default size will still allow users to

364.        --  shrink the window. Setting the size request will force them to leave the

365.        --  window at least as large as the size request. When dealing with window

366.        --  sizes, Gtk.Windo.Set_Geometry_Hints can be a useful function as well.

367.        --

368.        --  Note the inherent danger of setting any fixed size - themes,

369.        --  translations into other languages, different fonts, and user action can

370.        --  all change the appropriate size for a given widget. So, it's basically

371.        --  impossible to hardcode a size that will always be correct.

372.        --

373.        --  The size request of a widget is the smallest size a widget can accept

374.        --  while still functioning well and drawing itself correctly.  However in

375.        --  some strange cases a widget may be allocated less than its requested

376.        --  size, and in many cases a widget may be allocated more space than it

377.        --  requested.

378.        --

379.        --  If the size request in a given direction is -1 (unset), then

380.        --  the "natural" size request of the widget will be used instead.

381.        --

382.        --  Widgets can't actually be allocated a size less than 1 by 1, but

383.        --  you can pass 0,0 to this function to mean "as small as possible."

385.        procedure Size_AllocateTo API docTo body

386.          (Widget     : access Gtk_Widget_RecordTo API docTo specTo body;

387.           AllocationTo API docTo body : Gtk_AllocationTo API docTo spec);

388.        --  Emit a "size_allocate" event for the widget.

389.        --  Allocation'size is first constrained to a range between 1x1 and

390.        --  32767x32767.

391.        --  A clear and draw request is also queued if required.

393.        function Get_Child_RequisitionTo API docTo body

394.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return Gtk_RequisitionTo API docTo spec;

395.        --  Return the size requests by the widget.

396.        --  This is the ideal size for the widget, not necessarily its actual size.

397.        --  See the user guide's section on how to create new widgets for more

398.        --  information on the size requisition and allocation.

400.        function Get_Allocation_WidthTo API docTo body

401.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return Allocation_IntTo API docTo spec;

402.        --  Return the current width of the widget.

404.        function Get_Allocation_HeightTo API docTo body

405.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return Allocation_IntTo API docTo spec;

406.        --  Return the current height of the widget.

408.        function Get_Allocation_XTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return GintTo API docTo spec;

409.        --  Return the current position of the widget, relative to its parent.

411.        function Get_Allocation_YTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return GintTo API docTo spec;

412.        --  Return the current position of the widget, relative to its parent.

414.        procedure Set_Redraw_On_AllocateTo API docTo body

415.          (Widget             : access Gtk_Widget_RecordTo API docTo specTo body;

416.           Redraw_On_Allocate : Boolean);

417.        --  Sets whether the entire widget is queued for drawing when its size

418.        --  allocation changes. By default, this setting is %TRUE and the entire

419.        --  widget is redrawn on every size change. If your widget leaves the upper

420.        --  left unchanged when made bigger, turning this setting on will improve

421.        --  performance. Note that for %NO_WINDOW widgets setting this flag to

422.        --  %FALSE turns off all allocation on resizing: the widget will not even

423.        --  redraw if its position changes; this is to allow containers that don't

424.        --  draw anything to avoid excess invalidations. If you set this flag on

425.        --  %NO_WINDOW widget that *does* draw on Get_Window (Widget), you are

426.        --  responsible for invalidating both the old and new allocation of the

427.        --  widget when the widget is moved and responsible for invalidating regions

428.        --  newly when the widget increases size.

430.        ------------------

431.        -- Accelerators --

432.        ------------------

434.        procedure Add_AcceleratorTo API docTo body

435.          (Widget       : access Gtk_Widget_RecordTo API docTo specTo body;

436.           Accel_Signal : Glib.Signal_NameTo API docTo spec;

437.           Accel_Group  : Gtk.Accel_Group.Gtk_Accel_GroupTo API docTo spec;

438.           Accel_Key    : Gdk.Types.Gdk_Key_TypeTo API docTo spec;

439.           Accel_Mods   : Gdk.Types.Gdk_Modifier_TypeTo API docTo spec;

440.           Accel_Flags  : Gtk.Accel_Group.Gtk_Accel_FlagsTo API docTo spec);

441.        --  Add a new accelerator for the widget.

442.        --  The signal Accel_Signal will be sent to Widget when the matching

443.        --  key is pressed and the widget has the focus.

444.        --  Consider using Gtk.Accel_Map.Add_Entry instead, which is compatible with

445.        --  interactive change of accelerators by the user.

447.        procedure Remove_AcceleratorTo API docTo body

448.          (Widget       : access Gtk_Widget_RecordTo API docTo specTo body;

449.           Accel_Group  : Gtk.Accel_Group.Gtk_Accel_GroupTo API docTo spec;

450.           Accel_Key    : Gdk.Types.Gdk_Key_TypeTo API docTo spec;

451.           Accel_Mods   : Gdk.Types.Gdk_Modifier_TypeTo API docTo spec);

452.        --  Remove an accelerator for the widget.

454.        function Can_Activate_AccelTo API docTo body

455.          (Widget    : access Gtk_Widget_RecordTo API docTo specTo body;

456.           Signal_Id : GulongTo API docTo spec) return Boolean;

457.        --  Determines whether an accelerator that activates the signal identified

458.        --  by Signal_Id can currently be activated. This is done by emitting the

459.        --  GtkWidget::can-activate-accel signal on Widget; if the signal isn't

460.        --  overridden by handler or in a derived widget, then the default check is

461.        --  that the widget must be sensitive, and the widget and all its ancestors

462.        --  mapped.

463.        --  Signal_Id comes from the value returned by Gtk.Handlers.Connect

465.        procedure Set_Accel_PathTo API docTo body

466.          (Widget     : access Gtk_Widget_RecordTo API docTo specTo body;

467.           Accel_Path : UTF8_StringTo API docTo spec;

468.           Group      : Gtk.Accel_Group.Gtk_Accel_GroupTo API docTo spec);

469.        --  Set the path that will be used to reference the widget in calls to the

470.        --  subprograms in Gtk.Accel_Map. This means, for instance, that the widget

471.        --  is fully setup for interactive modification of the shortcuts by the

472.        --  user, should he choose to activate this possibility in his themes (see

473.        --  gtk-accel_map.ads for more information).

475.        function List_Mnemonic_LabelsTo API docTo body

476.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body)

477.           return Widget_List.GlistTo API docTo specTo body;

478.        --  Returns a newly allocated list of the widgets, normally labels, for

479.        --  which this widget is a the target of a mnemonic (see for example,

480.        --  gtk.label.set_mnemonic_widget).

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

482.        --  iterate through the list and perform actions involving callbacks that

483.        --  might destroy the widgets, you must call Ref first, and then unref all

484.        --  the widgets afterwards.

485.        --  The caller must free the returned list.

487.        procedure Add_Mnemonic_LabelTo API docTo body

488.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body;

489.           Label  : access Gtk_Widget_RecordTo API docTo specTo body'Class);

490.        --  Adds a widget to the list of mnemonic labels for this widget. (See

491.        --  List_Mnemonic_Labels). Note the list of mnemonic labels for the widget

492.        --  is cleared when the widget is destroyed, so the caller must make sure to

493.        --  update its internal state at this point as well, by using a connection

494.        --  to the ::destroy signal or a weak notifier.

496.        procedure Remove_Mnemonic_LabelTo API docTo body

497.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body;

498.           Label  : access Gtk_Widget_RecordTo API docTo specTo body'Class);

499.        --  Removes a widget from the list of mnemonic labels for this widget. The

500.        --  widget must have previously been added to the list with

501.        --  Add_Mnemonic_Label.

503.        function Mnemonic_ActivateTo API docTo body

504.          (Widget        : access Gtk_Widget_RecordTo API docTo specTo body;

505.           Group_Cycling : Boolean) return Boolean;

506.        --  Emits the signal "mnemonic_activate".

507.        --  In general (depending on what is connected to this signal), this results

508.        --  in calling the "activate" signal on the widget, as if a mnemonic had

509.        --  been used (when Group_Cycling if False), or to grab the focus on the

510.        --  widget when Group_Cycling is True)

512.        -------------------------

513.        --  Events and signals --

514.        -------------------------

516.        function EventTo API docTo body

517.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body'Class;

518.           Event  : Gdk.Event.Gdk_EventTo API docTo spec) return Boolean;

519.        --  Emit a signal on the widget.

520.        --  The exact signal depends on the event type (i.e. if the type is

521.        --  Gdk_Button_Press, then a "button_press" signal is emitted).

523.        procedure Send_ExposeTo API docTo body

524.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body;

525.           Event  : Gdk.Event.Gdk_Event_ExposeTo API docTo spec);

526.        --  Emit an expose event signals on a widget.

527.        --  This function is not normally used directly. The only time it is used

528.        --  is when propagating an expose event to a child No_Window widget, and

529.        --  that is normally done using Gtk.Container.Propagate_Expose.

530.        --

531.        --  If you want to force an area of a window to be redrawn,

532.        --  use Gdk.Window.Invalidate_Rect or Gdk.Window.Invalidate_Region.

533.        --  To cause the redraw to be done immediately, follow that call

534.        --  with a call to Gdk.Window.Process_Updates.

536.        procedure ActivateTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

537.        --  Emit an activate signal on the widget.

538.        --  The exact signal emitted depends on the widget type (i.e. for a

539.        --  Gtk_Button this emits a "clicked" signal, for a Gtk_Editable this emits

540.        --  the "activate" signal, ...).

542.        procedure Grab_FocusTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

543.        --  Emit the "grab_focus" signal for the widget.

544.        --  This is sent when the widget gets the focus. Its visual aspect might

545.        --  change.

546.        --  The "Can_Focus" flag must have been set first.

547.        --  See also Gtk.Widget.Child_Focus, which should be used instead when

548.        --  writting new widgets in Ada

550.        function Is_FocusTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return Boolean;

551.        --  Determines if the widget is the focus widget within its

552.        --  toplevel. (This does not mean that the HAS_FOCUS flag is

553.        --  necessarily set; HAS_FOCUS will only be set if the

554.        --  toplevel widget additionally has the global input focus)

556.        function Child_FocusTo API docTo body

557.          (Child     : access Gtk_Widget_RecordTo API docTo specTo body'Class;

558.           DirectionTo API docTo body : Gtk.Enums.Gtk_Direction_TypeTo API docTo spec := Gtk.Enums.Dir_Tab_Forward)

559.           return Boolean;

560.        --  Used by custom widget implementations to indicate the focus child.

561.        --  If you're writing an app, you'd use Grab_Focus to move the focus to a

562.        --  particular widget, and Gtk.Container.Set_Focus_Chain to change the focus

563.        --  tab order. So you may want to investigate those functions instead.

564.        --

565.        --  Child_Focus is called by containers as the user moves around

566.        --  the window using keyboard shortcuts. Direction indicates what kind of

567.        --  motion is taking place (up, down, left, right, tab forward, tab

568.        --  backward). Child_Focus invokes the "focus" signal on Child;

569.        --  widgets override the default handler for this signal in order to

570.        --  implement appropriate focus behavior.

571.        --

572.        --  The "focus" default handler for a widget should return True if moving in

573.        --  Direction left the focus on a focusable location inside that widget, and

574.        --  False if moving in Direction moved the focus outside the widget. If

575.        --  returning True, widgets normally call Grab_Focus to place the

576.        --  focus accordingly; if returning False, they don't modify the current

577.        --  focus location.

578.        --

579.        --  This function replaces Gtk.Container.Focus from GTK+ 1.2.  It was

580.        --  necessary to check that the child was visible, sensitive, and focusable

581.        --  before calling Gtk.Container.Focus. Child_Focus returns False

582.        --  if the widget is not currently in a focusable state, so there's no need

583.        --  for those checks.

584.        --

585.        --  Return value: True if focus ended up inside Child

587.        procedure Set_EventsTo API docTo body

588.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body;

589.           Events : Gdk.Event.Gdk_Event_MaskTo API docTo spec);

590.        function Get_EventsTo API docTo body

591.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return Gdk.Event.Gdk_Event_MaskTo API docTo spec;

592.        --  Sets or gets the event mask for the widget.

593.        --  Widget should not have been realized before, or nothing is done.

594.        --  This is the only way you can explicitly get mouse or keyboards events on

595.        --  widgets that do not automatically get them, as for instance in a

596.        --  Gtk_Drawing_Area.

598.        procedure Add_EventsTo API docTo body

599.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body;

600.           Events : Gdk.Event.Gdk_Event_MaskTo API docTo spec);

601.        --  Add some events to the current event mask of the widget.

603.        procedure Set_Extension_EventsTo API docTo body

604.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body;

605.           ModeTo API docTo body   : Gdk.Types.Gdk_Extension_ModeTo API docTo spec);

606.        function Get_Extension_EventsTo API docTo body

607.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return Gdk.Types.Gdk_Extension_ModeTo API docTo spec;

608.        --  Set the extension event mask for the widget.

609.        --  This is used to activate some special input modes for other devices than

610.        --  keyboard and mouse.

612.        function Default_Motion_Notify_EventTo API docTo body

613.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body'Class;

614.           Event  : Gdk.Event.Gdk_EventTo API docTo spec) return GintTo API docTo spec;

615.        --  Access to the standard default callback for motion events:

616.        --  This is mainly used for rulers in Gtk.Ruler (See the example in

617.        --  testgtk, with create_rulers.adb)

619.        function Has_Default_Motion_Notify_HandlerTo API docTo body

620.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body'Class) return Boolean;

621.        --  Return True if Widget has a default handler for motion_notify events.

622.        --  Note that the function Default_Motion_Notify_Event should not be called

623.        --  if this one returns False, since it would create a segmentation fault.

625.        procedure Error_BellTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

626.        --  Notifies the user about an input-related error on this widget.

627.        --  If the GtkSettings:gtk-error-bell setting is True, it calls

628.        --  Gdk_Window_Beep, otherwise it does nothing.

629.        --

630.        --  Note that the effect of Gdk_Window_Beep can be configured in many

631.        --  ways, depending on the windowing backend and the desktop environment

632.        --  or window manager that is used.

634.        function Keynav_FailedTo API docTo body

635.          (Widget    : access Gtk_Widget_RecordTo API docTo specTo body;

636.           DirectionTo API docTo body : Gtk.Enums.Gtk_Direction_TypeTo API docTo spec)

637.           return Boolean;

638.        --  This function should be called whenever keyboard navigation within

639.        --  a single widget hits a boundary. The function emits the

640.        --  GtkWidget::keynav-failed signal on the widget and its return

641.        --  value should be interpreted in a way similar to the return value of

642.        --  Child_Focus.

643.        --

644.        --  When True is returned, stay in the widget, the failed keyboard

645.        --  navigation is Ok and/or there is nowhere we can/should move the

646.        --  focus to.

647.        --

648.        --  When False is returned, the caller should continue with keyboard

649.        --  navigation outside the widget, e.g. by calling Child_Focus on the

650.        --  widget's toplevel.

651.        --

652.        --  The default ::keynav-failed handler returns True for

653.        --  Dir_Tab_Forward and Dir_Tab_Backward. For the other values of

654.        --  Gtk_Direction_Type, it looks at the

655.        --  GtkSettings:gtk-keynav-cursor-only setting and returns False

656.        --  if the setting is True. This way the entire user interface

657.        --  becomes cursor-navigatable on input devices such as mobile phones

658.        --  which only have cursor keys but no tab key.

659.        --

660.        --  Whenever the default handler returns True, it also calls

661.        --  Error_Bell to notify the user of the failed keyboard navigation.

662.        --

663.        --  A use case for providing an own implementation of ::keynav-failed

664.        --  (either by connecting to it or by overriding it) would be a row of

665.        --  Gtk_Entry widgets where the user should be able to navigate the

666.        --  entire row with the cursor keys, as e.g. known from user interfaces

667.        --  that require entering license keys.

669.        --------------------------

670.        -- Colors and colormaps --

671.        --------------------------

673.        procedure Set_ColormapTo API docTo body

674.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body;

675.           Cmap   : Gdk.Color.Gdk_ColormapTo API docTo spec);

676.        function Get_ColormapTo API docTo body

677.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return Gdk.Color.Gdk_ColormapTo API docTo spec;

678.        --  Modify the colormap of the widget.

679.        --  The widget must not have been realized when you set the colormap.

680.        --  The colormap is generally the same one for all widget, but might be

681.        --  different if for instance Gtk_Drawing_Area needs to display some

682.        --  different colors on a screen that only has a limited amount of colors.

684.        function Get_VisualTo API docTo body

685.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return Gdk.Visual.Gdk_VisualTo API docTo spec;

686.        --  Get the visual used for the widget.

687.        --  I.e. the structure that indicates the depth of the widget (number of

688.        --  bits per pixel), and some information used internally by GtkAda to

689.        --  handle colors and colormaps.

691.        procedure Push_ColormapTo API docTo body (Cmap : Gdk.Color.Gdk_ColormapTo API docTo spec);

692.        procedure Pop_ColormapTo API docTo body;

693.        --  Modify temporarily the default colormap set for newly created widgets.

694.        --  You should use this in pair with Pop_Colormap (Push the new value,

695.        --  create the widget, and pop the value).

697.        procedure Set_Default_ColormapTo API docTo body (Cmap : Gdk.Color.Gdk_ColormapTo API docTo spec);

698.        function Get_Default_ColormapTo API docTo body return Gdk.Color.Gdk_ColormapTo API docTo spec;

699.        --  Modify permanently the default colormap used when a widget is created.

700.        --  If you only want to modify this colormap temporarily for a few widgets,

701.        --  you should consider using Push_Colormap and Pop_Colormap instead.

702.        --  See also Gdk.Screen.Get_Default_Colormap for a multihead-aware version

704.        function Get_Default_VisualTo API docTo body return Gdk.Visual.Gdk_VisualTo API docTo spec;

705.        --  Return the default visual used when a new widget is created.

707.        function Is_CompositedTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return Boolean;

708.        --  Returns whether Widget can rely on having its alpha channel

709.        --  drawn correctly. On X11 this function returns whether a

710.        --  compositing manager is running for Widget's screen.

711.        --

712.        --  Please note that the semantics of this call will change

713.        --  in the future if used on a widget that has a composited

714.        --  window in its hierarchy (as set by Gdk.Window.Set_Composited).

716.        ------------

717.        -- Styles --

718.        ------------

720.        procedure Set_StyleTo API docTo body

721.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body;

722.           Style  : Gtk.Style.Gtk_StyleTo API docTo spec);

723.        function Get_StyleTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body)

724.          return Gtk.Style.Gtk_StyleTo API docTo spec;

725.        --  Set or get the style for a given widget.

726.        --  See also Gtk.Rc.Modify_Style

728.        function Get_Default_StyleTo API docTo body return Gtk.Style.Gtk_StyleTo API docTo spec;

729.        --  Get the default global style.

731.        procedure Ensure_StyleTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

732.        --  Make sure that the widget has a style associated to it.

733.        --  Either the default one as set by Set_Default_Style above or one set by

734.        --  the user with Set_Style.

736.        procedure Restore_Default_StyleTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

737.        --  Restore the default style that was set for the widget.

738.        --  The default style is the first one that was set either by a call

739.        --  to Set_Style or Set_Default_Style.

741.        procedure Reset_Rc_StylesTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

742.        --  Restore the Rc style recursively for widget and its children.

744.        function Get_Pango_ContextTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body)

745.           return Pango.Context.Pango_ContextTo API docTo spec;

746.        --  Get a Pango_Context with the appropriate colormap, font description and

747.        --  base direction for this widget. Unlike the context returned by

748.        --  Create_Pango_Context, this context is owned by the widget (it can be

749.        --  used as long as widget exists), and will be updated to match any changes

750.        --  to the widget's attributes.

751.        --

752.        --  If you create and keep a Pango_Layout using this context, you must deal

753.        --  with changes to the context by calling Pango_Layout.Context_Changed on

754.        --  the layout in response to the ::style_set and ::direction_set signals

755.        --  for the widget.

757.        procedure Modify_FgTo API docTo body

758.          (Widget     : access Gtk_Widget_RecordTo API docTo specTo body;

759.           State_TypeTo API docTo body : Enums.Gtk_State_TypeTo API docTo spec;

760.           ColorTo API docTo body      : Gdk.Color.Gdk_ColorTo API docTo specTo body);

761.        --  Sets the foreground color for a widget in a particular state.  All

762.        --  other style values are left untouched.

764.        procedure Modify_BgTo API docTo body

765.          (Widget     : access Gtk_Widget_RecordTo API docTo specTo body;

766.           State_TypeTo API docTo body : Enums.Gtk_State_TypeTo API docTo spec;

767.           ColorTo API docTo body      : Gdk.Color.Gdk_ColorTo API docTo specTo body);

768.        --  Sets the background color for a widget in a particular state.  All

769.        --  other style values are left untouched. This procedure has no effect

770.        --  when Widget has no physical window associated to it (for instance

771.        --  a Gtk_Label). In such cases, you must put widget inside a

772.        --  Gtk_Event_Box, and set the background color of the box itself.

774.        procedure Modify_TextTo API docTo body

775.          (Widget     : access Gtk_Widget_RecordTo API docTo specTo body;

776.           State_TypeTo API docTo body : Enums.Gtk_State_TypeTo API docTo spec;

777.           ColorTo API docTo body      : Gdk.Color.Gdk_ColorTo API docTo specTo body);

778.        --  Sets the text color for a widget in a particular state.  All other

779.        --  style values are left untouched. The text color is the foreground

780.        --  color used along with the base color (see Modify_Base)

781.        --  for widgets such as Gtk_Entry and Gtk_Text_View.

782.        --

783.        --  Note that this will not work with a Gtk_Button. Modify_Fg should be

784.        --  called on the button's label in order to set the color of its label.

785.        --  For example, assuming a simple button with a label attached to it:

786.        --

787.        --     Modify_Fg (Get_Child (My_Button), My_State, My_New_Color);

789.        procedure Modify_BaseTo API docTo body

790.          (Widget     : access Gtk_Widget_RecordTo API docTo specTo body;

791.           State_TypeTo API docTo body : Enums.Gtk_State_TypeTo API docTo spec;

792.           ColorTo API docTo body      : Gdk.Color.Gdk_ColorTo API docTo specTo body);

793.        --  Sets the base color for a widget in a particular state.

794.        --  All other style values are left untouched. The base color

795.        --  is the background color used along with the text color

796.        --  (see Modify_Text) for widgets such as Gtk_Entry and Gtk_Text_View.

798.        procedure Modify_FontTo API docTo body

799.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body;

800.           Desc   : Pango.Font.Pango_Font_DescriptionTo API docTo spec);

801.        --  Modify the font used for the widget.

802.        --  Desc must be freed by the caller to avoid memory leaks

804.        procedure Set_Default_DirectionTo API docTo body (Dir : Gtk.Enums.Gtk_Text_DirectionTo API docTo spec);

805.        function Get_Default_DirectionTo API docTo body return Gtk.Enums.Gtk_Text_DirectionTo API docTo spec;

806.        --  Obtains the current default reading direction. See

807.        --  Set_Default_Direction().

809.        procedure Set_DirectionTo API docTo body

810.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body; DirTo API docTo body : Gtk.Enums.Gtk_Text_DirectionTo API docTo spec);

811.        function Get_DirectionTo API docTo body

812.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return Gtk.Enums.Gtk_Text_DirectionTo API docTo spec;

813.        --  Sets the reading direction on a particular widget. This direction

814.        --  controls the primary direction for widgets containing text,

815.        --  and also the direction in which the children of a container are

816.        --  packed. The ability to set the direction is present in order

817.        --  so that correct localization into languages with right-to-left

818.        --  reading directions can be done. Generally, applications will

819.        --  let the default reading direction present, except for containers

820.        --  where the containers are arranged in an order that is explicitely

821.        --  visual rather than logical (such as buttons for text justification).

822.        --

823.        --  If the direction is set to TEXT_DIR_NONE, then the value

824.        --  set by Set_Default_Direction will be used.

826.        procedure Modify_CursorTo API docTo body

827.          (Widget    : access Gtk_Widget_RecordTo API docTo specTo body;

828.           PrimaryTo API docTo body   : Gdk.Color.Gdk_ColorTo API docTo specTo body;

829.           SecondaryTo API docTo body : Gdk.Color.Gdk_ColorTo API docTo specTo body);

830.        --  Sets the cursor color to use in a widget, overriding the

831.        --  GtkWidget:cursor-color and GtkWidget:secondary-cursor-color

832.        --  style properties. All other style values are left untouched.

833.        --  See also Gtk.Rc.Modify_Style.

835.        -------------------

836.        -- Widgets' tree --

837.        -------------------

839.        procedure Set_NameTo API docTo body

840.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body;

841.           Name   : UTF8_StringTo API docTo spec);

842.        --  Set the name for the widget.

843.        --  This name is used purely internally to identify the widget, and does not

844.        --  give any visual clue.

846.        function Get_NameTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return UTF8_StringTo API docTo spec;

847.        --  Return the name of the widget if it was set by Set_Name.

848.        --  Return the name of its class otherwise.

850.        function PathTo API docTo body          (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return String;

851.        function Path_ReversedTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return String;

852.        --  Obtains the full path to Widget. The path is simply the name of a

853.        --  widget and all its parents in the container hierarchy, separated by

854.        --  periods. The name of a widget comes from

855.        --  Get_Name. Paths are used to apply styles to a widget

856.        --  in gtkrc configuration files.  Widget names are the type of the

857.        --  widget by default (e.g. "GtkButton") or can be set to an

858.        --  application-specific value with Set_Name.  By setting

859.        --  the name of a widget, you allow users or theme authors to apply

860.        --  styles to that specific widget in their gtkrc

861.        --  file.

862.        --  Path_Reverse fills in the path in reverse order, starting with widget's

863.        --  name instead of starting with the name of the outermost ancestor.

865.        function Class_PathTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return String;

866.        function Class_Path_ReversedTo API docTo body

867.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return String;

868.        --  Same as Path(), but always uses the name of a widget's type,

869.        --  never uses a custom name set with Set_Name.

871.        function Get_AncestorTo API docTo body

872.          (Widget        : access Gtk_Widget_RecordTo API docTo specTo body;

873.           Ancestor_Type : Gtk_TypeTo API docTo spec) return Gtk_WidgetTo API docTo spec;

874.        --  Return the closest ancestor of Widget which is of type Ancestor_Type.

875.        --  Return null if there is none.

877.        procedure Set_ParentTo API docTo body

878.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body;

879.           Parent : access Gtk_Widget_RecordTo API docTo specTo body'Class);

880.        function Get_ParentTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return Gtk_WidgetTo API docTo spec;

881.        --  Modify the parent for the widget.

882.        --  This is not the recommended way to do this, you should use

883.        --  Gtk.Container.Add or Gtk.Box.Pack_Start instead.

885.        procedure Set_Parent_WindowTo API docTo body

886.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body;

887.           Window : Gdk.Window.Gdk_WindowTo API docTo spec);

888.        function Get_Parent_WindowTo API docTo body

889.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return Gdk.Window.Gdk_WindowTo API docTo spec;

890.        --  Set the parent window for the actual Gdk_Window of the widget. This sets

891.        --  up required internal fields, and should be used only when you implement

892.        --  your own container, as opposed to using one of the standard containers.

894.        function Get_ToplevelTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return Gtk_WidgetTo API docTo spec;

895.        --  This function returns the topmost widget in the container hierarchy

896.        --  Widget is a part of. If Widget has no parent widgets, it will be

897.        --  returned as the topmost widget.

898.        --

899.        --  Note the difference in behavior vs. Get_Ancestor:

900.        --  Get_Ancestor (Widget, GTK_TYPE_WINDOW) would return null

901.        --  if Widget wasn't inside a toplevel window, and if the

902.        --  window was inside a Gtk_Window-derived widget which was in turn

903.        --  inside the toplevel Gtk_Window. While the second case may

904.        --  seem unlikely, it actually happens when a Gtk_Plug is embedded

905.        --  inside a Gtk_Socket within the same application.

906.        --

907.        --  To reliably find the toplevel Gtk_Window, use

908.        --  Get_Toplevel and check if the "toplevel" flag

909.        --  is set on the result:

910.        --

911.        --  Toplevel := Get_Toplevel (Widget);

912.        --  if Top_Level_Is_Set (Toplevel) then

913.        --     [ Perform some action on Toplevel. ]

914.        --  end if;

916.        function Is_AncestorTo API docTo body

917.          (Widget   : access Gtk_Widget_RecordTo API docTo specTo body;

918.           Ancestor : access Gtk_Widget_RecordTo API docTo specTo body'Class) return Boolean;

919.        --  Return True if Ancestor is in the ancestor tree for Widget.

920.        --  I.e. if Widget is contained within Ancestor.

922.        procedure ReparentTo API docTo body

923.          (Widget     : access Gtk_Widget_RecordTo API docTo specTo body;

924.           New_Parent : access Gtk_Widget_RecordTo API docTo specTo body'Class);

925.        --  Change the parent of the widget dynamically.

926.        --  If both the new parent and the widget are shown, then the widget is

927.        --  visually redrawn in its new parent.

929.        procedure Translate_CoordinatesTo API docTo body

930.          (Src_Widget  : Gtk_WidgetTo API docTo spec;

931.           Dest_Widget : Gtk_WidgetTo API docTo spec;

932.           Src_X       : GintTo API docTo spec;

933.           Src_Y       : GintTo API docTo spec;

934.           Dest_X      : out GintTo API docTo spec;

935.           Dest_Y      : out GintTo API docTo spec;

936.           Result      : out Boolean);

937.        --  Translate coordinates relative to Src_Widget's allocation to coordinates

938.        --  relative to Dest_Widget's allocations. In order to perform this

939.        --  operation, both widgets must be realized, and must share a common

940.        --  toplevel.

941.        --

942.        --  Result is set to False if either widget was not realized, or there

943.        --  was no common ancestor. In this case, nothing is stored in Dest_X and

944.        --  Dest_Y. Otherwise True.

946.        function Get_Root_WindowTo API docTo body

947.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return Gdk.Window.Gdk_WindowTo API docTo spec;

948.        --  Get the root window where this widget is located. This function can only

949.        --  be called after the widget has been added to a widget hierarchy.

950.        --

951.        --  The root window is useful for such purposes as creating a popup

952.        --  Gdk_Window associated with the window. In general, you should only

953.        --  create display specific resources when a widget has been realized, and

954.        --  you should free those resources when the widget is unrealized.

956.        procedure Set_Composite_NameTo API docTo body

957.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body; Name : String);

958.        function Get_Composite_NameTo API docTo body

959.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return String;

960.        --  Sets or gets a widgets composite name. The widget must be

961.        --  a composite child of its parent; see Push_Composite_Child.

963.        procedure Push_Composite_ChildTo API docTo body;

964.        procedure Pop_Composite_ChildTo API docTo body;

965.        --  Makes all newly-created widgets as composite children until

966.        --  the corresponding Pop_Composite_Child call.

967.        --

968.        --  A composite child is a child that's an implementation detail of the

969.        --  container it's inside and should not be visible to people using the

970.        --  container. Composite children aren't treated differently by GTK (but

971.        --  see gtk.container.foreach() vs. gtk.container.forall()), but e.g. GUI

972.        --  builders might want to treat them in a different way.

973.        --

974.        --  Here is a simple example:

975.        --      Push_Composite_Child;

976.        --      Gtk_New (Scrolled_Window.Hscrollbar, Hadjustment);

977.        --      Set_Composite_Name (Scrolled_Window.Hscrollbar, "hscrollbar");

978.        --      Pop_Composite_Child;

979.        --      Set_Parent (Scrolled_Window.Hscrollbar, Scrolled_Window);

980.        --      Ref (Scrolled_Window.Hscrollbar);

982.        --------------------

983.        -- Misc functions --

984.        --------------------

986.        procedure Set_Scroll_AdjustmentsTo API docTo body

987.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body;

988.           Hadj   : Gtk.Adjustment.Gtk_AdjustmentTo API docTo spec;

989.           Vadj   : Gtk.Adjustment.Gtk_AdjustmentTo API docTo spec);

990.        --  Emit the "set_scroll_adjustments" signal.

991.        --  The exact signal emitted depends on the widget type (see

992.        --  Glib.Object.Initialize_Class_Record).

993.        --  The handler creates the adjustments if null is passed as argument, and

994.        --  makes sure both adjustments are in the correct range.

996.        function IntersectTo API docTo body

997.          (Widget       : access Gtk_Widget_RecordTo API docTo specTo body;

998.           AreaTo API docTo body         : Gdk.Rectangle.Gdk_RectangleTo API docTo spec;

999.           Intersection : access Gdk.Rectangle.Gdk_RectangleTo API docTo spec) return Boolean;

1000.        --  Return True if the widget intersects the screen area Area.

1001.        --  The intersection area is returned in Intersection.

1003.        function Region_IntersectTo API docTo body

1004.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body;

1005.           Region : Gdk.Region.Gdk_RegionTo API docTo spec)

1006.           return Gdk.Region.Gdk_RegionTo API docTo spec;

1007.        --  Region must be in the same coordinate system as the widget's allocation,

1008.        --  ie relative to the widget's window, or to the parent's window for

1009.        --  No_Window widgets.

1010.        --  Returns a newly allocated region. The coordinats are in the same system

1011.        --  as described above.

1012.        --  Computes the intersection of a Widget's area and Region, returning

1013.        --  the intersection. The result may be empty, use gdk.region.empty to

1014.        --  check.

1016.        procedure Grab_DefaultTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

1017.        --  The widget becomes the default widget for its parent window or dialog.

1018.        --  All keyboard events will be sent to it if no other widget has the focus.

1019.        --  Note that the "Can_Default" flag must have been set first on WIDGET.

1021.        procedure Set_StateTo API docTo body

1022.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body;

1023.           StateTo API docTo body  : Enums.Gtk_State_TypeTo API docTo spec);

1024.        function Get_StateTo API docTo body

1025.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return Enums.Gtk_State_TypeTo API docTo spec;

1026.        --  Modify the state of the widget.

1027.        --  This modifies its visual aspect, and thus should be used only if you

1028.        --  change its behavior at the same time, so as not to confuse the user.

1030.        procedure Set_SensitiveTo API docTo body

1031.          (Widget    : access Gtk_Widget_RecordTo API docTo specTo body;

1032.           Sensitive : Boolean := True);

1033.        --  Modify the sensitivity of the widget.

1034.        --  An insensitive widget is generally grayed out, and can not be activated.

1035.        --  For instance, an insensitive menu item is grayed, and can never be

1036.        --  selected.

1038.        procedure Set_App_PaintableTo API docTo body

1039.          (Widget        : access Gtk_Widget_RecordTo API docTo specTo body;

1040.           App_Paintable : Boolean);

1041.        --  Modify the "App_Paintable" flag for the widget.

1043.        procedure Set_Double_BufferedTo API docTo body

1044.          (Widget          : access Gtk_Widget_RecordTo API docTo specTo body;

1045.           Double_Buffered : Boolean := True);

1046.        --  Modify the "Double_Buffered" flag for the widget.

1048.        procedure Get_PointerTo API docTo body

1049.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body;

1050.           X      : out GintTo API docTo spec;

1051.           Y      : out GintTo API docTo spec);

1052.        --  Return the coordinates of the pointer (i.e. mouse) relative to Widget.

1054.        procedure Set_WindowTo API docTo body

1055.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body;

1056.           Window : Gdk.Window.Gdk_WindowTo API docTo spec);

1057.        function Get_WindowTo API docTo body

1058.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return Gdk.Window.Gdk_WindowTo API docTo spec;

1059.        --  Set the Gdk window associated with the widget.

1060.        --  You can use this window if you need to draw directly on the widget using

1061.        --  the functions found in the Gdk hierarchy.

1062.        --  These functions are rarely used except when you implement your own own

1063.        --  widget types. Predefined widgets takes care of that automatically.

1065.        procedure Shape_Combine_MaskTo API docTo body

1066.          (Widget     : access Gtk_Widget_RecordTo API docTo specTo body;

1067.           Shape_Mask : Gdk.Bitmap.Gdk_BitmapTo API docTo spec;

1068.           Offset_X   : GintTo API docTo spec;

1069.           Offset_Y   : GintTo API docTo spec);

1070.        --  Modify the shape of the window that contains the widget.

1071.        --  This allows for transparent windows, and requires the Xext library to be

1072.        --  available on your system. If this library is not available, your program

1073.        --  will still work.

1074.        --  See the manual page for XShapeCombineMask(3x) for more information.

1076.        procedure Input_Shape_Combine_MaskTo API docTo body

1077.          (Widget     : access Gtk_Widget_RecordTo API docTo specTo body;

1078.           Shape_Mask : Gdk.Bitmap.Gdk_BitmapTo API docTo spec;

1079.           Offset_X   : GintTo API docTo spec;

1080.           Offset_Y   : GintTo API docTo spec);

1081.        --  Sets an input shape for this widget's GDK window. This allows for

1082.        --  windows which react to mouse click in a nonrectangular region, see

1083.        --  Gdk.Window.Input_Shape_Combine_Mask for more information.

1085.        procedure Reset_ShapesTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

1086.        --  Recursively resets the shape on this widget and its descendants.

1088.        function Render_IconTo API docTo body

1089.          (Widget   : access Gtk_Widget_RecordTo API docTo specTo body;

1090.           Stock_Id : String;

1091.           Size     : Gtk.Enums.Gtk_Icon_SizeTo API docTo spec;

1092.           Detail   : UTF8_StringTo API docTo spec := "") return Gdk.Pixbuf.Gdk_PixbufTo API docTo spec;

1093.        --  A convenience function that uses the theme engine for Widget, to lookup

1094.        --  a Stock_Id (see Gtk.Stock) and render it to a pixbuf (see Gdk.Pixbuf).

1095.        --  Detail should be a string that identifies the widget or code doing the

1096.        --  rendering, so that the theme engine can special-case rendering for that

1097.        --  widget or code. It can be left to the empty stirng to get the default

1098.        --  behavior.

1099.        --

1100.        --  Null is returned if Stock_Id wasn't known.

1102.        function Get_SnapshotTo API docTo body

1103.          (Widget    : access Gtk_Widget_RecordTo API docTo specTo body;

1104.           Clip_Rect : Gdk.Rectangle.Gdk_Rectangle_AccessTo API docTo spec)

1105.           return Gdk.Pixmap.Gdk_PixmapTo API docTo spec;

1106.        --  Create a Gdk_Pixmap of the contents of the widget and its children.

1107.        --

1108.        --  Works even if the widget is obscured. The depth and visual of the

1109.        --  resulting pixmap is dependent on the widget being snapshot and likely

1110.        --  differs from those of a target widget displaying the pixmap.

1111.        --  The function Gdk.Pixbuf.Get_From_Drawable can be used to convert

1112.        --  the pixmap to a visual independant representation.

1113.        --

1114.        --  The snapshot area used by this function is the Widget's allocation plus

1115.        --  any extra space occupied by additional windows belonging to this widget

1116.        --  (such as the arrows of a spin button).  Thus, the resulting snapshot

1117.        --  pixmap is possibly larger than the allocation.

1118.        --

1119.        --  If Clip_Rect is non-null, the resulting pixmap is shrunken to

1120.        --  match the specified clip_rect. The (x,y) coordinates of Clip_Rect are

1121.        --  interpreted widget relative. If width or height of Clip_Rect are 0 or

1122.        --  negative, the width or height of the resulting pixmap will be shrunken

1123.        --  by the respective amount.

1124.        --

1125.        --  For instance using a Clip_Rect'(+5, +5, -10, -10) will chop off 5 pixels

1126.        --  at each side of the snapshot pixmap.

1127.        --

1128.        --  If non-null, Clip_Rect will contain the exact widget-relative snapshot

1129.        --  coordinates upon return. A Clip_Rect of (-1, -1, 0, 0) can be used to

1130.        --  preserve the auto-grown snapshot area and use Clip_Rect as a pure output

1131.        --  parameter.

1132.        --

1133.        --  The returned pixmap can be null, if the resulting Clip_Area was empty.

1135.        --------------

1136.        -- Tooltips --

1137.        --------------

1139.        function Get_Tooltip_TextTo API docTo body

1140.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return UTF8_StringTo API docTo spec;

1141.        procedure Set_Tooltip_TextTo API docTo body

1142.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body;

1143.           Text   : UTF8_StringTo API docTo spec);

1144.        --  Gets/Sets text as the contents of the tooltip. This function will take

1145.        --  care of setting GtkWidget::has-tooltip to TRUE and of the default

1146.        --  handler for the GtkWidget::query-tooltip signal.

1147.        --

1148.        --  See also the GtkWidget:tooltip-text property and Gtk_Tooltips.Set_Text.

1150.        function Get_Tooltip_MarkupTo API docTo body

1151.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return UTF8_StringTo API docTo spec;

1152.        procedure Set_Tooltip_MarkupTo API docTo body

1153.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body;

1154.           Text   : UTF8_StringTo API docTo spec);

1155.        --  Gets/Sets tooltip contents, marked up with the Pango text markup

1156.        --  language.

1157.        --

1158.        --  This function will take care of setting GtkWidget:has-tooltip to TRUE

1159.        --  and of the default handler for the GtkWidget::query-tooltip signal.

1160.        --

1161.        --  See also the GtkWidget::tooltip-markup property and

1162.        --  Gtk_Tooltips.Set_Markup.

1164.        procedure Set_Tooltip_WindowTo API docTo body

1165.          (Widget        : access Gtk_Widget_RecordTo API docTo specTo body;

1166.           Custom_Window : access Gtk_Widget_RecordTo API docTo specTo body'Class);

1167.        --   Custom_Window : access Gtk.Window.Gtk_Window_Record'Class);

1168.        --

1169.        --  Replaces the default, usually yellow, window used for displaying

1170.        --  tooltips with custom_window. GTK+ will take care of showing and hiding

1171.        --  Custom_Window at the right moment, to behave likewise as the default

1172.        --  tooltip window. If Custom_Window is NULL, the default tooltip window

1173.        --  will be used.

1175.        function Get_Tooltip_WindowTo API docTo body

1176.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return Gtk_WidgetTo API docTo spec;

1177.        --    return Gtk.Window.Gtk_Window;

1178.        --

1179.        --  Returns the GtkWindow of the current tooltip. This can be the GtkWindow

1180.        --  created by default, or the custom tooltip window set using

1181.        --  Gtk.Widget.Set_Tooltip_Window.

1183.        function Get_Has_TooltipTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return Boolean;

1184.        procedure Set_Has_TooltipTo API docTo body

1185.          (Widget      : access Gtk_Widget_RecordTo API docTo specTo body;

1186.           Has_Tooltip : Boolean);

1187.        --  Gets/Sets the has-tooltip property on Widget to Has_Tooltip.  See

1188.        --  GtkWidget:has-tooltip for more information.

1190.        procedure Trigger_Tooltip_QueryTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

1191.        --  Triggers a tooltip query on the display where the toplevel of Widget

1192.        --  is located. See Gtk.Tooltip.Trigger_Tooltip_Query for more

1193.        --  information.

1195.        --------------------------

1196.        -- Creating new widgets --

1197.        --------------------------

1198.        --  Although the core subprogram for creating new widgets is

1199.        --  Glib.Gobjects.Initialize_Class_Record, it is often useful to override

1200.        --  some internal pointers to functions.

1201.        --  The functions below are not needed unless you are writting your own

1202.        --  widgets, and should be reserved for advanced customization of the

1203.        --  standard widgets.

1205.        procedure Set_Scroll_Adjustments_SignalTo API docTo body

1206.          (Widget : Glib.Object.GObject_ClassTo API docTo spec; Signal : String);

1207.        --  Modify the signal to be sent when the adjustments are modified.

1208.        --  This is only useful when you are rewritting your own widget that can be

1209.        --  embedded directly in a Gtk_Scrolled_Window, without any Gtk_Viewport.

1210.        --

1211.        --  Signal is the name of the signal that will be emitted when Widget is

1212.        --  put inside a Gtk_Scrolled_Window.

1213.        --

1214.        --  Note that the handlers for this signal must take two arguments in

1215.        --  addition to the widget (the horizontal and vertical adjustments to be

1216.        --  used). See Gtk.Scrolled_Window and Gtk.Widget.Set_Scroll_Adjustment for

1217.        --  more information on this signal.

1219.        type Size_Allocate_Handler is access procedure

1220.          (Widget : System.Address; Allocation : Gtk_AllocationTo API docTo spec);

1221.        pragma Convention (C, Size_Allocate_HandlerTo API docTo spec);

1222.        --  Widget is the gtk+ C widget, that needs to be converted to Ada through

1223.        --  a call to:

1224.        --    declare

1225.        --       Stub : Gtk_Widget_Record; --  or the exact type you expect

1226.        --    begin

1227.        --       My_Widget := Gtk_Widget (Glib.Object.Get_User_Data (Widget, Stub);

1228.        --    end;

1230.        procedure Set_Default_Size_Allocate_HandlerTo API docTo body

1231.          (Klass   : Glib.Object.GObject_ClassTo API docTo spec;

1232.           Handler : Size_Allocate_HandlerTo API docTo spec);

1233.        --  Override the default size_allocate handler for this class. This handler

1234.        --  is automatically called in several cases (when a widget is dynamically

1235.        --  resized for instance), not through a signal. Thus, if you need to

1236.        --  override the default behavior provided by one of the standard

1237.        --  containers, you can not simply use Gtk.Handlers.Emit_Stop_By_Name, and

1238.        --  you must override the default handler. Note also that this handler

1239.        --  is automatically inherited by children of this class.

1241.        procedure Set_AllocationTo API docTo body

1242.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body'Class; AllocTo API docTo body : Gtk_AllocationTo API docTo spec);

1243.        --  Modifies directly the internal field of Widget to register the new

1244.        --  allocation.

1245.        --  Beware that the only use of this method is inside a callback set

1246.        --  by Set_Default_Size_Allocate_Handler. If you simply want to resize

1247.        --  or reposition a widget, use Size_Allocate instead.

1249.        type Expose_Event_Handler is access function

1250.          (Widget : System.Address; Event : Gdk.Event.Gdk_EventTo API docTo spec) return Boolean;

1251.        pragma Convention (C, Expose_Event_HandlerTo API docTo spec);

1252.        function Default_Expose_Event_HandlerTo API docTo body (Klass : GObject_ClassTo API docTo spec)

1253.           return Expose_Event_HandlerTo API docTo spec;

1254.        --  Return the default expose event handler for the widget class Klass. The

1255.        --  typical use for this function is when you are writting your own

1256.        --  container class. You should then, from your own handler for

1257.        --  expose_event, call the one of the parent class, so that all the children

1258.        --  are automatically redrawn.

1260.        -----------

1261.        -- Flags --

1262.        -----------

1263.        --  Some flags are defined for all the visual objects (widgets).

1264.        --  These flags are important in that they define exactly the different

1265.        --  states a widget can be in.

1266.        --

1267.        --  - "Toplevel":

1268.        --    Set if the widget is a toplevel widget, ie has no parent. This is

1269.        --    mostly true for windows and dialogs.

1270.        --

1271.        --  - "No_Window":

1272.        --    Set if the widget does not have an associated X11 window, ie can not

1273.        --    receive events directly. For instance, a Gtk_Toolbar does not have

1274.        --    an associated window. These objects are more lightweight, but require

1275.        --    more work from GtkAda. This flag is only set if the widget will never

1276.        --    have a window, even after it is realized.

1277.        --

1278.        --  - "Realized":

1279.        --    Set if the widget has been realized, ie its associated X11 window has

1280.        --    been created (providing the widget excepts a window, see the No_Window

1281.        --    flag

1282.        --

1283.        --  - "Mapped":

1284.        --    Set if the widget is visible on the screen. This is only possible if

1285.        --    the Visible flag is also set.

1286.        --

1287.        --  - "Visible":

1288.        --    Set if the widget will be displayed on the screen when mapped (see the

1289.        --    functions Show and Hide in this package).

1290.        --

1291.        --  - "Sensitive":

1292.        --    Set if the widget is listening to events. See the function

1293.        --    Set_Sensitive in this package. An insensitive widget will generally

1294.        --    have a different visual aspect to clue that it is unavailable (for

1295.        --    instance an insensitive item menu will be grayed)

1296.        --

1297.        --  - "Parent_Sensitive":

1298.        --    Set if the parent is sensitive. A widget is sensitive only if both

1299.        --    the Sensitive and Parent_Sensitive are set.

1300.        --

1301.        --  - "Can_Focus":

1302.        --    Set if the widget can have the focus, ie get keyboard events. Most

1303.        --    widgets can not have the focus.

1304.        --

1305.        --  - "Has_Focus":

1306.        --    Set if the widget currently has the focus. See the function Grab_Focus

1307.        --    in this package. See also the subprogram Gtk.Widget.Is_Focus

1308.        --

1309.        --  - "Can_Default":

1310.        --    Set if the widget can be the default widget in a window, ie the one

1311.        --    that will get the keyboard events by default. For instance, the

1312.        --    default button in a dialog is the one that gets clicked on when the

1313.        --    user pressed Enter anywhere in the dialog.

1314.        --

1315.        --  - "Has_Default":

1316.        --    Set if the widget is currently the default widget. See the function

1317.        --    Grab_Default in this package.

1318.        --

1319.        --  - "Has_Grab":

1320.        --    Set if the widget currently grabs all mouse and keyboard events in

1321.        --    the application, even if it does not have the focus. There can be only

1322.        --    such widget per application at any given time.

1323.        --

1324.        --  - "Rc_Style":

1325.        --    Set if the widget's style is either the default style, or in a

1326.        --    customization file. This is unset if the style has been modified by

1327.        --    the user.

1328.        --

1329.        --  - "Composite_Child":

1330.        --    This indicates whether the widget is composed of other widgets

1331.        --

1332.        --  - "No_Reparent":

1333.        --    This flags is never used in gtk+.

1334.        --

1335.        --  - "App_Paintable":

1336.        --    For some containers (including Gtk_Window and Gtk_Layout), this is

1337.        --    unset when the container itself has some special drawing routines. It

1338.        --    indicates whether the application will paint directly on the widget.

1339.        --

1340.        --  - "Receives_Default":

1341.        --    Set when the widget receives the default at the time it receives the

1342.        --    focus. This is how the default button in a dialog is automatically

1343.        --    changed when you press another button.

1345.        In_Destruction : constant := 2 ** 0;

1346.        Floating       : constant := 2 ** 1;

1347.        Reserved_1     : constant := 2 ** 2;

1348.        Reserved_2     : constant := 2 ** 3;

1349.        Toplevel         : constant := 2 ** 4;

1350.        No_Window        : constant := 2 ** 5;

1351.        Realized         : constant := 2 ** 6;

1352.        Mapped           : constant := 2 ** 7;

1353.        Visible          : constant := 2 ** 8;

1354.        Sensitive        : constant := 2 ** 9;

1355.        Parent_Sensitive : constant := 2 ** 10;

1356.        Can_Focus        : constant := 2 ** 11;

1357.        Has_Focus        : constant := 2 ** 12;

1358.        Can_Default      : constant := 2 ** 13;

1359.        Has_Default      : constant := 2 ** 14;

1360.        Has_Grab         : constant := 2 ** 15;

1361.        Rc_Style         : constant := 2 ** 16;

1362.        Composite_Child  : constant := 2 ** 17;

1363.        No_Reparent      : constant := 2 ** 18;

1364.        App_Paintable    : constant := 2 ** 19;

1365.        Receives_Default : constant := 2 ** 20;

1366.        Double_Buffered  : constant := 2 ** 21;

1368.        function FlagsTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body) return Guint32To API docTo spec;

1369.        --  Return the flags that are set for the object, as a binary mask.

1371.        procedure Set_FlagsTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body; Flags : Guint32To API docTo spec);

1372.        --  Set some specific flags for the object.

1373.        --  Flags is a mask that will be added to the current flags of the object.

1375.        procedure Unset_FlagsTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body; Flags : Guint32To API docTo spec);

1376.        --  Unset some specific flags for the object.

1377.        --  Flags is a mask that will be deleted from the current flags of the

1378.        --  object.

1380.        function Flag_Is_SetTo API docTo body

1381.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body; Flag : Guint32To API docTo spec) return Boolean;

1382.        --  Return True if the specific flag Flag is set for the object.

1384.        function In_Destruction_Is_SetTo API docTo body

1385.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body'Class) return Boolean;

1386.        --  Test if the Destroyed flag is set for the object.

1388.        --  <doc_ignore>

1389.        function Destroyed_Is_Set (Widget : access Gtk_Widget_RecordTo API docTo specTo body'Class)

1390.           return Boolean renames In_Destruction_Is_SetTo API docTo specTo body;

1391.        --  backward compatibility only

1392.        --  </doc_ignore>

1394.        function Floating_Is_SetTo API docTo body

1395.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body'Class) return Boolean;

1396.        --  Test if the Floating flag is set for the object.

1398.        function Toplevel_Is_SetTo API docTo body

1399.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body'Class) return Boolean;

1400.        --  Test whether the Toplevel flag is set.

1402.        function No_Window_Is_SetTo API docTo body

1403.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body'Class) return Boolean;

1404.        --  Test whether the No_Window flag is set.

1406.        function Realized_Is_SetTo API docTo body

1407.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body'Class) return Boolean;

1408.        --  Test whether the Realized flag is set.

1410.        function Mapped_Is_SetTo API docTo body

1411.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body'Class) return Boolean;

1412.        --  Test whether the Mapped flag is set.

1414.        function Visible_Is_SetTo API docTo body

1415.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body'Class) return Boolean;

1416.        --  Test whether the Visible flag is set.

1418.        function Drawable_Is_SetTo API docTo body

1419.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body'Class) return Boolean;

1420.        --  True if the widget is both visible and mapped.

1421.        --  In other words, if it does appear on the screen.

1423.        function Is_SensitiveTo API docTo body

1424.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body'Class) return Boolean;

1425.        --  Test whether the widget is Sensitive.

1427.        function Can_Focus_Is_SetTo API docTo body

1428.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body'Class) return Boolean;

1429.        --  Test whether the Can_Focus flag is set.

1431.        function Has_Focus_Is_SetTo API docTo body

1432.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body'Class) return Boolean;

1433.        --  Test whether the Has_Focus flag is set.

1435.        function Has_Default_Is_SetTo API docTo body

1436.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body'Class) return Boolean;

1437.        --  Test whether the Has_Default flag is set.

1439.        function Has_Grab_Is_SetTo API docTo body

1440.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body'Class) return Boolean;

1441.        --  Test whether the Has_Grab flag is set.

1443.        function Rc_Style_Is_SetTo API docTo body

1444.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body'Class) return Boolean;

1445.        --  Test whether the Rc_Style flag is set.

1447.        function Double_Buffered_Is_SetTo API docTo body

1448.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body'Class) return Boolean;

1449.        --  Test whether the Double_Buffered flag is set.

1451.        --------------------

1452.        -- GValue support --

1453.        --------------------

1455.        function Get_RequisitionTo API docTo body

1456.          (ValueTo API docTo body : Glib.Values.GValueTo API docTo specTo body) return Gtk_Requisition_AccessTo API docTo spec;

1457.        --  Convert a value into a Gtk_Requisition_Access.

1459.        function Get_AllocationTo API docTo body

1460.          (ValueTo API docTo body : Glib.Values.GValueTo API docTo specTo body) return Gtk_Allocation_AccessTo API docTo spec;

1461.        --  Convert a value into a Gtk_Allocation_Access.

1463.        -----------------

1464.        -- Obsolescent --

1465.        -----------------

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

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

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

1469.        --  with the -gnatwj switch

1470.        --  <doc_ignore>

1472.        procedure DrawTo API docTo body

1473.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body;

1474.           AreaTo API docTo body   : Gdk.Rectangle.Gdk_RectangleTo API docTo spec := Gdk.Rectangle.Full_AreaTo API docTo specTo body);

1475.        pragma Obsolescent;  --  Draw

1476.        --  Emit a "draw" signal for a specific area of the widget.

1477.        --  The visual aspect might be different whether the widget has the focus

1478.        --  or not.

1480.        procedure Set_UPositionTo API docTo body

1481.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body;

1482.           X, Y   : GintTo API docTo spec);

1483.        pragma Obsolescent;  --  Set_Uposition

1484.        --  Modify the position of the widget.

1485.        --  This should be used only for toplevel widgets (windows and dialogs),

1486.        --  since other widgets' positions are handled by their parent.

1488.        procedure Set_USizeTo API docTo body

1489.          (Widget        : access Gtk_Widget_RecordTo API docTo specTo body;

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

1491.        pragma Obsolescent ("Use Set_Size_Request instead");  --  Set_Usize

1492.        --  Modify the size of the widget.

1493.        --  This sets an absolute size for the widget, no matter what its requested

1494.        --  size would be. For Gtk_Windows, you should consider using

1495.        --  Set_Default_Size instead, which sets a minimal size, but use the

1496.        --  widget's requested size if it is bigger.

1497.        --  If Width or Height is negative, they are ignored, and the widget's

1498.        --  default width is kept.

1500.        procedure Queue_ClearTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

1501.        pragma Obsolescent; --  Queue_Clear

1502.        --  Add a clear request to the event queue for the whole widget.

1503.        --  This is added to the same list as for Queue_Draw, and thus is coalesced

1504.        --  as much as possible with other drawing requests.

1506.        procedure Queue_Clear_AreaTo API docTo body

1507.          (Widget : access Gtk_Widget_RecordTo API docTo specTo body;

1508.           X      : GintTo API docTo spec;

1509.           Y      : GintTo API docTo spec;

1510.           Width  : GintTo API docTo spec;

1511.           Height : GintTo API docTo spec);

1512.        pragma Obsolescent; --  Queue_Clear_Area

1513.        --  Add a clear request to the event queue for part of the widget.

1514.        --  This is added to the same list as for Queue_Draw, and thus is coalesced

1515.        --  as much as possible with other drawing requests.

1517.        --  </doc_ignore>

1519.        ----------------

1520.        -- Properties --

1521.        ----------------

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

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

1525.        --  <properties>

1526.        --  Name:  Name_Property

1527.        --  Type:  UTF8_String

1528.        --  Flags: read-write

1529.        --  Descr: The name of the widget

1530.        --  See also:  Set_Name procedure

1531.        --

1532.        --  Name:  Parent_Property

1533.        --  Type:  Gtk_Container'Class

1534.        --  Flags: read-write

1535.        --  Descr: The parent widget of this widget.

1536.        --  See also:  Set_Parent or Add procecures

1537.        --

1538.        --  Name:  X_Property

1539.        --  Type:  Gint

1540.        --  Flags: read-write

1541.        --  Descr: The x coordinate of the top-left corner of the widget,

1542.        --         or -1 if not set

1543.        --

1544.        --  Name:  Y_Property

1545.        --  Type:  Gint

1546.        --  Flags: read-write

1547.        --  Descr: The y coordinate of the top-left corner of the widget,

1548.        --         or -1 if not set

1549.        --

1550.        --  Name:  Width_Property

1551.        --  Type:  Gint

1552.        --  Flags: read-write

1553.        --  Descr: The width of the widget or -1 if not set

1554.        --  See also:  Set_USize

1555.        --

1556.        --  Name:  Height_Property

1557.        --  Type:  Gint

1558.        --  Flags: read-write

1559.        --  Descr: The height of the widget or -1 if not set

1560.        --  See also:  Set_USize

1561.        --

1562.        --  Name:  Visible_Property

1563.        --  Type:  Boolean

1564.        --  Flags: read-write

1565.        --  Descr: Whether the widget is visible

1566.        --  See also:  Hide and Show procedures

1567.        --

1568.        --  Name:  Sensitive_Property

1569.        --  Type:  Boolean

1570.        --  Flags: read-write

1571.        --  Descr: Whether the widget responds to input

1572.        --  See also: Set_Sensitive

1573.        --

1574.        --  Name:  App_Paintable_Property

1575.        --  Type:  Boolean

1576.        --  Flags: read-write

1577.        --  Descr: Whether the application will paint directly on the widget

1578.        --  See also: Set_App_Paintable

1579.        --

1580.        --  Name:  Can_Focus_Property

1581.        --  Type:  Boolean

1582.        --  Flags: read-write

1583.        --  Descr: Whether the widget can accept the input focus (keyboard)

1584.        --  See also: Set or unset the flag Can_Focus

1585.        --

1586.        --  Name:  Has_Focus_Property

1587.        --  Type:  Boolean

1588.        --  Flags: read-write

1589.        --  Descr: Whether the widget has the input focus

1590.        --  See also: Grab_Focus

1591.        --

1592.        --  Name:  Can_Default_Property

1593.        --  Type:  Boolean

1594.        --  Flags: read-write

1595.        --  Descr: Whether the widget can be the default widget

1596.        --  See also: Set or unset the flag Can_Default

1597.        --

1598.        --  Name:  Has_Default_Property

1599.        --  Type:  Boolean

1600.        --  Flags: read-write

1601.        --  Descr: Whether the widget is the default widget

1602.        --  See also: Grab_Default

1603.        --

1604.        --  Name:  Receives_Default_Property

1605.        --  Type:  Boolean

1606.        --  Flags: read-write

1607.        --  Descr: If True, the widget will receive the default action when

1608.        --         it is focused

1609.        --  See also: Set or unset the flag Receives_Default

1610.        --

1611.        --  Name:  Composite_Child_Property

1612.        --  Type:  Boolean

1613.        --  Flags: read-write

1614.        --  Descr: Whether the widget is composed of other widgets

1615.        --  See also: Set or unset the flag Composite_Child

1616.        --

1617.        --  Name:  Style_Property

1618.        --  Type:  Gtk_Style

1619.        --  Flags: read-write

1620.        --  Descr: The style of the widget, which contains information about how

1621.        --         it will look (colors etc).

1622.        --  See also: Set_Style

1623.        --

1624.        --  Name:  Events_Property

1625.        --  Type:  flags

1626.        --  Flags: read-write

1627.        --  Descr: The event mask that decides what kind of GdkEvents this widget

1628.        --         gets.

1629.        --  See also: Set_Events

1630.        --

1631.        --  Name:  Prop_Extensions_Events_Property

1632.        --  Type:  flags

1633.        --  Flags: read-write

1634.        --  Descr: The mask that decides what kind of extension events this widget

1635.        --         gets.

1636.        --  See also: Set_Extension_Events

1637.        --

1638.        --  Name:  Extension_Events_Property

1639.        --  Type:  Enum

1640.        --  Descr: The mask that decides what kind of extension events this widget

1641.        --         gets

1642.        --

1643.        --  Name:  Height_Request_Property

1644.        --  Type:  Int

1645.        --  Descr: Override for height request of the widget, or -1 if natural

1646.        --         request should be used

1647.        --

1648.        --  Name:  Is_Focus_Property

1649.        --  Type:  Boolean

1650.        --  Descr: Whether the widget is the focus widget within the toplevel

1651.        --

1652.        --  Name:  No_Show_All_Property

1653.        --  Type:  Boolean

1654.        --  Descr: Whether gtk_widget_show_all() should not affect this widget

1655.        --

1656.        --  Name:  Width_Request_Property

1657.        --  Type:  Int

1658.        --  Descr: Override for width request of the widget, or -1 if natural

1659.        --         request should be used

1660.        --

1661.        --  Name:  Tooltip_Markup_Property

1662.        --  Type:  String

1663.        --  Descr: The contents of the tooltip for this widget

1664.        --

1665.        --  Name:  Tooltip_Text_Property

1666.        --  Type:  String

1667.        --  Descr: The contents of the tooltip for this widget

1668.        --

1669.        --  Name:  Has_Tooltip

1670.        --  Type:  Boolean

1671.        --  Descr: Enables or disables the emission of "query-tooltip" on widget. A

1672.        --         value of TRUE indicates that widget can have a tooltip, in this

1673.        --         case the widget will be queried using "query-tooltip" to

1674.        --         determine whether it will provide a tooltip or not.

1675.        --

1676.        --         Note that setting this property to TRUE for the first time will

1677.        --         change the event masks of the GdkWindows of this widget to

1678.        --         include leave-notify and motion-notify events. This cannot and

1679.        --         will not be undone when the property is set to FALSE again.

1680.        --

1681.        --  Name:  Window_Property

1682.        --  Type:  Object

1683.        --  Descr: The widget's window if it is realized

1684.        --

1685.        --  </properties>

1687.        procedure Child_NotifyTo API docTo body

1688.          (Widget         : access Gtk_Widget_RecordTo API docTo specTo body;

1689.           Child_Property : String);

1690.        --  Emits a "child-notify" signal for the child property on Widget.

1691.        --  This signal indicates the the value of the child property has changed on

1692.        --  the parent, and thus that Widget should refresh itself if needed.

1693.        --

1694.        --  Child_Property is the name of a child property installed on Widget's

1695.        --  parent. You should use Glib.Propert_Name to get the name from the

1696.        --  property declaration in each of the GtkAda packages

1698.        procedure Freeze_Child_NotifyTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

1699.        --  Stops emission of "child-notify" signals on Widget. The signals are

1700.        --  queued until Thaw_Child_Notify() is called on Wwidget.

1702.        procedure Thaw_Child_NotifyTo API docTo body (Widget : access Gtk_Widget_RecordTo API docTo specTo body);

1703.        --  Reverts the effect of a previous call to Freeze_Child_Notify.

1704.        --  This causes all queued "child-notify" signals on Widget to be emitted.

1706.        procedure Class_Install_Style_PropertyTo API docTo body

1707.          (Klass : Glib.Object.GObject_ClassTo API docTo spec;

1708.           Pspec : Glib.Param_SpecTo API docTo spec);

1709.        --  Installs a style property on a widget class. The parser for the

1710.        --  style property is determined by the value type of Pspec.

1711.        --  A style property configures the look-and-feel of a widget class. They

1712.        --  are generally modified by the current gtk+ theme, although users can

1713.        --  also modify them in their own configuration file.

1715.        function Class_List_Style_PropertiesTo API docTo body

1716.          (Klass : Glib.Object.GObject_ClassTo API docTo spec) return Glib.Param_Spec_ArrayTo API docTo spec;

1717.        --  Returns all style properties of a widget class.

1719.        function Class_Find_Style_PropertyTo API docTo body

1720.          (Klass         : Glib.Object.GObject_ClassTo API docTo spec;

1721.           Property_Name : String) return Glib.Param_SpecTo API docTo spec;

1722.        --  Finds a style property of a widget class by name.

1723.        --  Klass must be a descendent of Gtk_Widget.

1724.        --  You should use Glib.Property_Name to get the name from the property

1725.        --  declaration in each of the GtkAda packages

1727.        procedure Style_Get_PropertyTo API docTo body

1728.          (Widget        : access Gtk_Widget_RecordTo API docTo specTo body;

1729.           Property_Name : String;

1730.           ValueTo API docTo body         : out Glib.Values.GValueTo API docTo specTo body);

1731.        --  Gets the value of a style property of Widget.

1732.        --  You should use Glib.Property_Name to get the name from the property

1733.        --  declaration in each of the GtkAda packages

1735.        Name_Property                  : constant Glib.Properties.Property_StringTo API docTo spec;

1736.        Parent_Property                : constant Glib.Properties.Property_ObjectTo API docTo spec;

1737.        X_Property                     : constant Glib.Properties.Property_IntTo API docTo spec;

1738.        Y_Property                     : constant Glib.Properties.Property_IntTo API docTo spec;

1739.        Width_Property                 : constant Glib.Properties.Property_IntTo API docTo spec;

1740.        Height_Property                : constant Glib.Properties.Property_IntTo API docTo spec;

1741.        Visible_Property               : constant Glib.Properties.Property_BooleanTo API docTo spec;

1742.        Sensitive_Property             : constant Glib.Properties.Property_BooleanTo API docTo spec;

1743.        App_Paintable_Property         : constant Glib.Properties.Property_BooleanTo API docTo spec;

1744.        Can_Focus_Property             : constant Glib.Properties.Property_BooleanTo API docTo spec;

1745.        Has_Focus_Property             : constant Glib.Properties.Property_BooleanTo API docTo spec;

1746.        Can_Default_Property           : constant Glib.Properties.Property_BooleanTo API docTo spec;

1747.        Has_Default_Property           : constant Glib.Properties.Property_BooleanTo API docTo spec;

1748.        Receives_Default_Property      : constant Glib.Properties.Property_BooleanTo API docTo spec;

1749.        Composite_Child_Property       : constant Glib.Properties.Property_BooleanTo API docTo spec;

1750.        Style_Property                 : constant Glib.Properties.Property_ObjectTo API docTo spec;

1751.        Events_Property                : constant Gdk.Event.Property_Gdk_Event_MaskTo API docTo spec;

1752.        Prop_Extensions_Events_Property :

1753.          constant Gdk.Types.Property_Gdk_Extension_ModeTo API docTo spec;

1754.        Extension_Events_Property  : constant Gdk.Types.Property_Gdk_Extension_ModeTo API docTo spec;

1755.        Height_Request_Property        : constant Glib.Properties.Property_IntTo API docTo spec;

1756.        Is_Focus_Property              : constant Glib.Properties.Property_BooleanTo API docTo spec;

1757.        No_Show_All_Property           : constant Glib.Properties.Property_BooleanTo API docTo spec;

1758.        Width_Request_Property         : constant Glib.Properties.Property_IntTo API docTo spec;

1759.        Tooltip_Markup_Property        : constant Glib.Properties.Property_StringTo API docTo spec;

1760.        Tooltip_Text_Property          : constant Glib.Properties.Property_StringTo API docTo spec;

1761.        Has_Tooltip_Property           : constant Glib.Properties.Property_BooleanTo API docTo spec;

1762.        Window_Property                : constant Glib.Properties.Property_ObjectTo API docTo spec;

1764.        ----------------------

1765.        -- Style Properties --

1766.        ----------------------

1767.        --  The following properties can be changed through the gtk theme and

1768.        --  configuration files, and retrieved through Gtk.Widget.Style_Get_Property

1770.        --  <style_properties>

1771.        --  Name:  Cursor_Aspect_Ratio_Property

1772.        --  Type:  Float

1773.        --  Descr: Aspect ratio with which to draw insertion cursor

1774.        --

1775.        --  Name:  Cursor_Color_Property

1776.        --  Type:  Boxed

1777.        --  Descr: Color with which to draw insertion cursor

1778.        --

1779.        --  Name:  Draw_Border_Property

1780.        --  Type:  Boxed

1781.        --  Descr: Size of areas outside the widget's allocation to draw

1782.        --

1783.        --  Name:  Focus_Line_Pattern_Property

1784.        --  Type:  String

1785.        --  Descr: Dash pattern used to draw the focus indicator

1786.        --

1787.        --  Name:  Focus_Line_Width_Property

1788.        --  Type:  Int

1789.        --  Descr: Width, in pixels, of the focus indicator line

1790.        --

1791.        --  Name:  Focus_Padding_Property

1792.        --  Type:  Int

1793.        --  Descr: Width, in pixels, between focus indicator and the widget 'box'

1794.        --

1795.        --  Name:  Interior_Focus_Property

1796.        --  Type:  Boolean

1797.        --  Descr: Whether to draw the focus indicator inside widgets

1798.        --

1799.        --  Name:  Link_Color_Property

1800.        --  Type:  Boxed

1801.        --  Descr: Color of unvisited links

1802.        --

1803.        --  Name:  Scroll_Arrow_Hlength_Property

1804.        --  Type:  Int

1805.        --  Descr: The length of horizontal scroll arrows

1806.        --

1807.        --  Name:  Scroll_Arrow_Vlength_Property

1808.        --  Type:  Int

1809.        --  Descr: The length of vertical scroll arrows

1810.        --

1811.        --  Name:  Secondary_Cursor_Color_Property

1812.        --  Type:  Boxed

1813.        --  Descr: Color with which to draw the secondary insertion cursor when

1814.        --         editing mixed right-to-left and left-to-right text

1815.        --

1816.        --  Name:  Separator_Height_Property

1817.        --  Type:  Int

1818.        --  Descr: The height of separators if \

1819.        --

1820.        --  Name:  Separator_Width_Property

1821.        --  Type:  Int

1822.        --  Descr: The width of separators if wide-separators is TRUE

1823.        --

1824.        --  Name:  Visited_Link_Color_Property

1825.        --  Type:  Boxed

1826.        --  Descr: Color of visited links

1827.        --

1828.        --  Name:  Wide_Separators_Property

1829.        --  Type:  Boolean

1830.        --  Descr: Whether separators have configurable width and should be drawn

1831.        --         using a box instead of a line

1832.        --  </style_properties>

1834.        Cursor_Aspect_Ratio_Property  : constant Glib.Properties.Property_FloatTo API docTo spec;

1835.        --  Cursor_Color_Property        : constant Glib.Properties.Property_Boxed;

1836.        --  Draw_Border_Property         : constant Glib.Properties.Property_Boxed;

1837.        Focus_Line_Pattern_Property   : constant Glib.Properties.Property_StringTo API docTo spec;

1838.        Focus_Line_Width_Property     : constant Glib.Properties.Property_IntTo API docTo spec;

1839.        Focus_Padding_Property        : constant Glib.Properties.Property_IntTo API docTo spec;

1840.        Interior_Focus_Property       : constant Glib.Properties.Property_BooleanTo API docTo spec;

1841.        Link_Color_Property           : constant Glib.Properties.Property_BoxedTo API docTo spec;

1842.        Scroll_Arrow_Hlength_Property : constant Glib.Properties.Property_IntTo API docTo spec;

1843.        Scroll_Arrow_Vlength_Property : constant Glib.Properties.Property_IntTo API docTo spec;

1844.        --  Secondary_Cursor_Color_Property : constant

1845.        --    Glib.Properties.Property_Boxed;

1846.        Separator_Height_Property     : constant Glib.Properties.Property_IntTo API docTo spec;

1847.        Separator_Width_Property      : constant Glib.Properties.Property_IntTo API docTo spec;

1848.        Visited_Link_Color_Property   : constant Glib.Properties.Property_BoxedTo API docTo spec;

1849.        Wide_Separators_Property      : constant Glib.Properties.Property_BooleanTo API docTo spec;

1851.        -------------

1852.        -- Signals --

1853.        -------------

1855.        --  <signals>

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

1857.        --

1858.        --  - "show"

1859.        --    procedure Handler (Widget : access Gtk_Widget_Record'Class);

1860.        --    Emitted when a widget is to be shown (see explanation for the Show

1861.        --    subprogam). This schedules the widget to be displayed on the screen,

1862.        --    and if this is a toplevel widget it actually appears on the screen

1863.        --    and all its children that have been shown.

1864.        --

1865.        --  - "hide"

1866.        --    procedure Handler (Widget : access Gtk_Widget_Record'Class);

1867.        --    Emitted when a widget is to be hidden (see explanation for the Hide

1868.        --    subprogram). Hides the widget from the screen, and if its parent is

1869.        --    shown, the widget will not appear on the screen again.

1870.        --

1871.        --  - "map"

1872.        --    procedure Handler (Widget : access Gtk_Widget_Record'Class);

1873.        --    Emitted when a widget is mapped on the screen (the default handler

1874.        --    simply emits the "show" signal).

1875.        --

1876.        --  - "unmap"

1877.        --    procedure Handler (Widget : access Gtk_Widget_Record'Class);

1878.        --    Emitted when a widget needs to be unmapped on the screen (the default

1879.        --    handler simply emits the "hide" signal).

1880.        --

1881.        --  - "realize"

1882.        --    procedure Handler (Widget : access Gtk_Widget_Record'Class);

1883.        --    Emitted when a widget is realized. The default handler creates the

1884.        --    Gdk window associated with the widget, and its ancestors.

1885.        --

1886.        --  - "unrealize"

1887.        --    procedure Handler (Widget : access Gtk_Widget_Record'Class);

1888.        --    Emitted when a widget is unrealized. The default handler destroys the

1889.        --    Gdk windows of the widget and all its children.

1890.        --

1891.        --  - "draw"

1892.        --    procedure Handler (Widget : access Gtk_Widget_Record'Class;

1893.        --                       Area   : Gdk.Rectangle.Gdk_Rectangle);

1894.        --    Emitted when a widget needs to be drawn. The default handler emits

1895.        --    the "expose" event.

1896.        --

1897.        --  - "draw_focus"

1898.        --    procedure Handler (Widget : access Gtk_Widget_Record'Class);

1899.        --    Emitted when a widget needs to be drawn and it has the focus. Some

1900.        --    widgets might want to provide visual clues that they have the focus,

1901.        --    like a black border. This is never called if the widget can not have

1902.        --    the focus (ie the "Can_Focus" flag is unset).

1903.        --

1904.        --  - "draw_default"

1905.        --    procedure Handler (Widget : access Gtk_Widget_Record'Class);

1906.        --    Emitted when a widget needs to be drawn and it does not have the

1907.        --    focus. This is never called if the widget can not have the focus

1908.        --    (ie the "Can_Focus" flag is unset).

1909.        --

1910.        --  - "size_request"

1911.        --    procedure Handler (Widget      : access Gtk_Widget_Record'Class;

1912.        --                       Requisition : access Gtk_Requisition);

1913.        --    Should return (in Requisition) the ideal size the widget would like to

1914.        --    have. It is not sure this is the size that will be assigned to it,

1915.        --    since it depends on the size of its parent).

1916.        --

1917.        --  - "size_allocate"

1918.        --    procedure Handler (Widget     : access Gtk_Widget_Record'Class;

1919.        --                       Allocation : Gtk_Allocation);

1920.        --    A size and position were assigned to the widget. This is called every

1921.        --    time the size of the widget changes.

1922.        --    The default handler takes care of resizing and moving the widget.

1923.        --

1924.        --  - "state_changed"

1925.        --    procedure Handler (Widget         : access Gtk_Widget_Record'Class;

1926.        --                       Previous_State : Gtk.Enums.Gtk_State_Type);

1927.        --    The state of the widget has changed.

1928.        --

1929.        --  - "parent_set"

1930.        --    procedure Handler (Widget : access Gtk_Widget_Record'Class;

1931.        --                       Previous_Parent : access Gtk_Widget_Record'Class);

1932.        --    A new parent has been set for the widget. The previous parent is

1933.        --    given in arguments (if there was none,

1934.        --    Gdk.Is_Created (Previous_Parent) returns False).

1935.        --

1936.        --  - "style_set"

1937.        --    procedure Handler (Widget : access Gtk_Widget_Record'Class);

1938.        --                       Previous_Style : Gtk.Style.Gtk_Style);

1939.        --    The widget's style has been changed (this is not call when some

1940.        --    settings in the style are changed, only when the style itself is

1941.        --    completely changed with a call to Set_Style or Set_Default_Style).

1942.        --

1943.        --  - "add_accelerator"

1944.        --  ???

1945.        --

1946.        --  - "remove_accelerator"

1947.        --  ???

1948.        --

1949.        --  - "grab_focus"

1950.        --    procedure Handler (Widget : access Gtk_Widget_Record'Class);

1951.        --    The widget has got the focus, ie will now get the keyboard events

1952.        --    sent to a window. This is only called if the "Can_Focus" flag is

1953.        --    set. The "Has_Focus" flag might not be set when this signal is

1954.        --    emitted.

1955.        --

1956.        --  - "event"

1957.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

1958.        --                      Event  : Gdk.Event.Gdk_Event)

1959.        --                     return Boolean;

1960.        --    Some event was sent to the widget. This covers all the cases

1961.        --    below, and acts as a general handler. This is called in addition to

1962.        --    the relevant specific handler below.

1963.        --    If the handler returns False, the event might be pass to the parent

1964.        --    of widget (if no other handler of widget has returned True).

1965.        --

1966.        --  - "button_press_event"

1967.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

1968.        --                      Event  : Gdk.Event.Gdk_Event_Button)

1969.        --                     return Boolean;

1970.        --    A button was pressed while the pointer was inside the widget.

1971.        --    To get this signal, some widgets by have to use the Set_Events

1972.        --    subprogram first to get this event.

1973.        --    If the handler returns False, the event might be pass to the parent

1974.        --    of widget (if no other handler of widget has returned True).

1975.        --

1976.        --  - "button_release_event"

1977.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

1978.        --                      Event  : Gdk.Event.Gdk_Event_Button)

1979.        --                     return Boolean;

1980.        --    A button was released while the pointer was inside the widget.

1981.        --    Note that in some cases (Gtk_Buttons for instance), another "clicked"

1982.        --    signal could be emitted). This "button_release_event" should mainly

1983.        --    be used for widgets that don't already have specific signals to cover

1984.        --    that case (Gtk_Drawing_Area for instance).

1985.        --

1986.        --    To get this signal, some widgets may have to use the Set_Events

1987.        --    subprogram first to get this event.

1988.        --

1989.        --    If the handler returns False, the event might be pass to the parent

1990.        --    of widget (if no other handler of widget has returned True).

1991.        --

1992.        --  - "motion_notify_event"

1993.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

1994.        --                      Event  : Gdk.Event.Gdk_Event_Motion)

1995.        --                     return Boolean;

1996.        --    The pointer has moved while remaining inside the widget.

1997.        --    The Set_Events subprogram has to be called first to get this event.

1998.        --

1999.        --    If the handler returns False, the event might be pass to the parent

2000.        --    of widget (if no other handler of widget has returned True).

2001.        --

2002.        --  - "delete_event"

2003.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

2004.        --                      Event  : Gdk.Event.Gdk_Event)

2005.        --                     return Boolean;

2006.        --    The user has clicked on the "close" button in the window's frame

2007.        --    (the button that is automatically set by the window manager). If the

2008.        --    handler returns False, the widget will be destroyed (and the window

2009.        --    closed), but if the handler returns True, nothing will be done.

2010.        --    This is a good way to prevent the user from closing your application's

2011.        --    window if there should be some clean ups first (like saving the

2012.        --    document).

2013.        --

2014.        --  - "destroy"

2015.        --    procedure Handler (Widget : access Gtk_Widget_Record'Class);

2016.        --

2017.        --    Raised when the widget is about to be destroyed. The "destroyed"

2018.        --    flag has been set on the object first. Handlers should not keep

2019.        --    a reference on the object.

2020.        --    Note that when your destroy handlers are called, the user_data is

2021.        --    still available.

2022.        --    The default implementation destroys all the handlers.

2023.        --

2024.        --  - "destroy_event"

2025.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

2026.        --                      Event  : Gdk.Event.Gdk_Event)

2027.        --                     return Boolean;

2028.        --    This signal is apparently never emitted by Gtk+. You might want to

2029.        --    use "destroy" instead.

2030.        --

2031.        --  - "expose_event"

2032.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

2033.        --                      Event  : Gdk.Event.Gdk_Event_Expose)

2034.        --                     return Boolean;

2035.        --    The widget needs to be partly redrawn. The exact area to redraw is

2036.        --    found in Event. For some widgets, you should rather connect to the

2037.        --    "draw" signal. However, for instance for Gtk_Drawing_Area widgets,

2038.        --    you have to use this, after setting the correct event mask with

2039.        --    Set_Events.

2040.        --    If the handler returns False, the event might be passed to the parent

2041.        --    of widget (if no other handler of widget has returned True).

2042.        --

2043.        --  - "key_press_event"

2044.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

2045.        --                      Event  : Gdk.Event.Gdk_Event_Key)

2046.        --                     return Boolean;

2047.        --    A key has been pressed while Widget had the focus. Note that some

2048.        --    widgets like Gtk_Editable provide some higher-level signals to handle

2049.        --    this.

2050.        --    If the handler returns False, the event might be pass to the parent

2051.        --    of widget (if no other handler of widget has returned True).

2052.        --

2053.        --  - "key_release_event"

2054.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

2055.        --                      Event  : Gdk.Event.Gdk_Event_Key)

2056.        --                     return Boolean;

2057.        --    A key has been released while Widget had the focus.

2058.        --    If the handler returns False, the event might be pass to the parent

2059.        --    of widget (if no other handler of widget has returned True).

2060.        --

2061.        --  - "enter_notify_event"

2062.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

2063.        --                      Event  : Gdk.Event.Gdk_Event_Crossing)

2064.        --                     return Boolean;

2065.        --    The pointer has just entered the widget. If the "Can_Focus" flag is

2066.        --    set, Widget will gain the focus, and the widget might be drawn

2067.        --    differently.

2068.        --    If the handler returns False, the event might be pass to the parent

2069.        --    of widget (if no other handler of widget has returned True).

2070.        --

2071.        --  - "leave_notify_event"

2072.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

2073.        --                      Event  : Gdk.Event.Gdk_Event_Crossing)

2074.        --                     return Boolean;

2075.        --    The pointer has just leaved the widget. If the "Can_Focus" flag is

2076.        --    set, Widget will gain the focus, and the widget might be drawn

2077.        --    differently.

2078.        --    If the handler returns False, the event might be pass to the parent

2079.        --    of widget (if no other handler of widget has returned True).

2080.        --

2081.        --  - "configure_event"

2082.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

2083.        --                      Event  : Gdk.Event.Gdk_Event_Configure)

2084.        --                     return Boolean;

2085.        --    Some configuration of the window has changed (it has been

2086.        --    moved or resized).

2087.        --    If the handler returns False, the event might be pass to the parent

2088.        --    of widget (if no other handler of widget has returned True).

2089.        --

2090.        --  - "focus_in_event"

2091.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

2092.        --                      Event  : Gdk.Event.Gdk_Event_Focus)

2093.        --                     return Boolean;

2094.        --    The widget has just gained the focus.

2095.        --    If the handler returns False, the event might be pass to the parent

2096.        --    of widget (if no other handler of widget has returned True).

2097.        --    This event is only emitted if you called Add_Events with a

2098.        --    Enter_Notify_Mask parameter

2099.        --

2100.        --  - "focus_out_event"

2101.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

2102.        --                      Event  : Gdk.Event.Gdk_Event_Focus)

2103.        --                     return Boolean;

2104.        --    The widget has just lost the focus.

2105.        --    If the handler returns False, the event might be pass to the parent

2106.        --    of widget (if no other handler of widget has returned True).

2107.        --    This event is only emitted if you called Add_Events with a

2108.        --    Leave_Notify_Mask parameter

2109.        --

2110.        --  - "map_event"

2111.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

2112.        --                      Event  : Gdk.Event.Gdk_Event)

2113.        --                     return Boolean;

2114.        --    The widget has just been mapped. This is different from the "map"

2115.        --    signal, which is called *before* the widget is actually mapped.

2116.        --    If the handler returns False, the event might be pass to the parent

2117.        --    of widget (if no other handler of widget has returned True).

2118.        --

2119.        --  - "unmap_event"

2120.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

2121.        --                      Event  : Gdk.Event.Gdk_Event)

2122.        --                     return Boolean;

2123.        --    The widget has just been unmapped. This is different from the "unmap"

2124.        --    signal, which is called *before* the widget is actually unmapped.

2125.        --    If the handler returns False, the event might be pass to the parent

2126.        --    of widget (if no other handler of widget has returned True).

2127.        --

2128.        --  - "property_notify_event"

2129.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

2130.        --                      Event  : Gdk.Event.Gdk_Event_Property)

2131.        --                     return Boolean;

2132.        --    ???

2133.        --

2134.        --  - "selection_clear_event"

2135.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

2136.        --                      Event  : Gdk.Event.Gdk_Event_Selection)

2137.        --                     return Boolean;

2138.        --    ???

2139.        --

2140.        --  - "selection_request_event"

2141.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

2142.        --                      Event  : Gdk.Event.Gdk_Event_Selection)

2143.        --                     return Boolean;

2144.        --    ???

2145.        --

2146.        --  - "selection_notify_event"

2147.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

2148.        --                      Event  : Gdk.Event.Gdk_Event_Selection)

2149.        --                     return Boolean;

2150.        --    ???

2151.        --

2152.        --  - "selection_received"

2153.        --    Related to the selection mechanism, see Gtk.Selection

2154.        --

2155.        --  - "selection_get"

2156.        --    Related to the selection mechanism, see Gtk.Selection

2157.        --

2158.        --  - "proximity_in_event"

2159.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

2160.        --                      Event  : Gdk.Event.Gdk_Event_Proximity)

2161.        --                     return Boolean;

2162.        --    Used for special input devices. See the description of

2163.        --    Gdk.Event.Gdk_Event_Proximity.

2164.        --    If the handler returns False, the event might be pass to the parent

2165.        --    of widget (if no other handler of widget has returned True).

2166.        --

2167.        --  - "proximity_out_event"

2168.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

2169.        --                      Event  : Gdk.Event.Gdk_Event_Proximity)

2170.        --                     return Boolean;

2171.        --    Used for special input devices. See the description of

2172.        --    Gdk.Event.Gdk_Event_Proximity.

2173.        --    If the handler returns False, the event might be pass to the parent

2174.        --    of widget (if no other handler of widget has returned True).

2175.        --

2176.        --  - "drag_leave"

2177.        --    Event related to drag-and-drop support. See the Gtk.Dnd documentation.

2178.        --

2179.        --  - "drag_begin"

2180.        --    Event related to drag-and-drop support. See the Gtk.Dnd documentation.

2181.        --

2182.        --  - "drag_end"

2183.        --    Event related to drag-and-drop support. See the Gtk.Dnd documentation.

2184.        --

2185.        --  - "drag_data_delete"

2186.        --    Event related to drag-and-drop support. See the Gtk.Dnd documentation.

2187.        --

2188.        --  - "drag_motion"

2189.        --    Event related to drag-and-drop support. See the Gtk.Dnd documentation.

2190.        --

2191.        --  - "drag_drop"

2192.        --    Event related to drag-and-drop support. See the Gtk.Dnd documentation.

2193.        --

2194.        --  - "drag_data_get"

2195.        --    Event related to drag-and-drop support. See the Gtk.Dnd documentation.

2196.        --

2197.        --  - "drag_data_received"

2198.        --    Event related to drag-and-drop support. See the Gtk.Dnd documentation.

2199.        --

2200.        --  - "visibility_notify_event"

2201.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

2202.        --                      Event  : Gdk.Event.Gdk_Event_Visibility)

2203.        --                     return Boolean;

2204.        --    The visibility state of the widget has changed (partially visible,

2205.        --    fully visible, ...). You might want to use the "expose" signal

2206.        --    instead.

2207.        --    If the handler returns False, the event might be pass to the parent

2208.        --    of widget (if no other handler of widget has returned True).

2209.        --

2210.        --  - "client_event"

2211.        --    ???

2212.        --

2213.        --  - "no_expose_event"

2214.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

2215.        --                      Event  : Gdk.Event.Gdk_Event)

2216.        --                     return Boolean;

2217.        --    ???

2218.        --

2219.        --  - "child_notify"

2220.        --    procedure Handler (Widget : access Gtk_Widget_Record'Class);

2221.        --    This signal is emitted when the value of one of the child properties

2222.        --    for the widget has been changed. If you are only interested in the

2223.        --    changes for a specific property, you can also connect directly to

2224.        --    "child_notify::<property>", for instance "child_notify:right_attach"

2225.        --    for a child of Gtk.Menu.Gtk_Menu.

2226.        --

2227.        --

2228.        --  - "query-tooltip"

2229.        --    function Handler (Widget : access Gtk_Widget_Record'Class;

2230.        --                      Params : Glib.Values.GValues)

2231.        --                     return Boolean;

2232.        --    Emitted when "has-tooltip" is TRUE and the "gtk-tooltip-timeout" has

2233.        --    expired with the cursor hovering "above" widget; or emitted when

2234.        --    widget got focus in keyboard mode.

2235.        --

2236.        --    Using the given coordinates, the signal handler should determine

2237.        --    whether a tooltip should be shown for widget. If this is the case TRUE

2238.        --    should be returned, FALSE otherwise. Note that if keyboard_mode is

2239.        --    TRUE, the values of x and y are undefined and should not be used.

2240.        --

2241.        --    The signal handler is free to manipulate tooltip with the therefore

2242.        --    destined function calls.

2243.        --  </signals>

2245.        Signal_Accel_Closures_Changed  : constant Glib.Signal_NameTo API docTo spec :=

2246.                                           "accel_closures_changed";

2247.        Signal_Button_Press_Event      : constant Glib.Signal_NameTo API docTo spec :=

2248.                                           "button_press_event";

2249.        Signal_Button_Release_Event    : constant Glib.Signal_NameTo API docTo spec :=

2250.                                           "button_release_event";

2251.        Signal_Can_Activate_Accel      : constant Glib.Signal_NameTo API docTo spec :=

2252.                                           "can_activate_accel";

2253.        Signal_Child_Notify            : constant Glib.Signal_NameTo API docTo spec :=

2254.                                           "child_notify";

2255.        Signal_Client_Event            : constant Glib.Signal_NameTo API docTo spec :=

2256.                                           "client_event";

2257.        Signal_Configure_Event         : constant Glib.Signal_NameTo API docTo spec :=

2258.                                           "configure_event";

2259.        Signal_Delete_Event            : constant Glib.Signal_NameTo API docTo spec :=

2260.                                           "delete_event";

2261.        Signal_Destroy                 : constant Glib.Signal_NameTo API docTo spec :=

2262.                                           "destroy";

2263.        Signal_Destroy_Event           : constant Glib.Signal_NameTo API docTo spec :=

2264.                                           "destroy_event";

2265.        Signal_Direction_Changed       : constant Glib.Signal_NameTo API docTo spec :=

2266.                                           "direction_changed";

2267.        Signal_Drag_Begin              : constant Glib.Signal_NameTo API docTo spec :=

2268.                                           "drag_begin";

2269.        Signal_Drag_Data_Delete        : constant Glib.Signal_NameTo API docTo spec :=

2270.                                           "drag_data_delete";

2271.        Signal_Drag_Data_Get           : constant Glib.Signal_NameTo API docTo spec :=

2272.                                           "drag_data_get";

2273.        Signal_Drag_Data_Received      : constant Glib.Signal_NameTo API docTo spec :=

2274.                                           "drag_data_received";

2275.        Signal_Drag_Drop               : constant Glib.Signal_NameTo API docTo spec :=

2276.                                           "drag_drop";

2277.        Signal_Drag_End                : constant Glib.Signal_NameTo API docTo spec :=

2278.                                           "drag_end";

2279.        Signal_Drag_Leave              : constant Glib.Signal_NameTo API docTo spec :=

2280.                                           "drag_leave";

2281.        Signal_Drag_Motion             : constant Glib.Signal_NameTo API docTo spec :=

2282.                                           "drag_motion";

2283.        Signal_Enter_Notify_Event      : constant Glib.Signal_NameTo API docTo spec :=

2284.                                           "enter_notify_event";

2285.        Signal_Event                   : constant Glib.Signal_NameTo API docTo spec :=

2286.                                           "event";

2287.        Signal_Event_After             : constant Glib.Signal_NameTo API docTo spec :=

2288.                                           "event-after";

2289.        Signal_Expose_Event            : constant Glib.Signal_NameTo API docTo spec :=

2290.                                           "expose_event";

2291.        Signal_Focus                   : constant Glib.Signal_NameTo API docTo spec :=

2292.                                           "focus";

2293.        Signal_Focus_In_Event          : constant Glib.Signal_NameTo API docTo spec :=

2294.                                           "focus_in_event";

2295.        Signal_Focus_Out_Event         : constant Glib.Signal_NameTo API docTo spec :=

2296.                                           "focus_out_event";

2297.        Signal_Grab_Broken_Event       : constant Glib.Signal_NameTo API docTo spec :=

2298.                                           "grab_broken_event";

2299.        Signal_Grab_Focus              : constant Glib.Signal_NameTo API docTo spec :=

2300.                                           "grab_focus";

2301.        Signal_Grab_Notify             : constant Glib.Signal_NameTo API docTo spec :=

2302.                                           "grab_notify";

2303.        Signal_Hide                    : constant Glib.Signal_NameTo API docTo spec :=

2304.                                           "hide";

2305.        Signal_Hierarchy_Changed       : constant Glib.Signal_NameTo API docTo spec :=

2306.                                           "hierarchy_changed";

2307.        Signal_Key_Press_Event         : constant Glib.Signal_NameTo API docTo spec :=

2308.                                           "key_press_event";

2309.        Signal_Key_Release_Event       : constant Glib.Signal_NameTo API docTo spec :=

2310.                                           "key_release_event";

2311.        Signal_Leave_Notify_Event      : constant Glib.Signal_NameTo API docTo spec :=

2312.                                           "leave_notify_event";

2313.        Signal_Map                     : constant Glib.Signal_NameTo API docTo spec :=

2314.                                           "map";

2315.        Signal_Map_Event               : constant Glib.Signal_NameTo API docTo spec :=

2316.                                           "map_event";

2317.        Signal_Mnemonic_Activate       : constant Glib.Signal_NameTo API docTo spec :=

2318.                                           "mnemonic_activate";

2319.        Signal_Motion_Notify_Event     : constant Glib.Signal_NameTo API docTo spec :=

2320.                                           "motion_notify_event";

2321.        Signal_No_Expose_Event         : constant Glib.Signal_NameTo API docTo spec :=

2322.                                           "no_expose_event";

2323.        Signal_Parent_Set              : constant Glib.Signal_NameTo API docTo spec :=

2324.                                           "parent_set";

2325.        Signal_Popup_Menu              : constant Glib.Signal_NameTo API docTo spec :=

2326.                                           "popup_menu";

2327.        Signal_Property_Notify_Event   : constant Glib.Signal_NameTo API docTo spec :=

2328.                                           "property_notify_event";

2329.        Signal_Proximity_In_Event      : constant Glib.Signal_NameTo API docTo spec :=

2330.                                           "proximity_in_event";

2331.        Signal_Proximity_Out_Event     : constant Glib.Signal_NameTo API docTo spec :=

2332.                                           "proximity_out_event";

2333.        Signal_Realize                 : constant Glib.Signal_NameTo API docTo spec :=

2334.                                           "realize";

2335.        Signal_Query_Tooltip           : constant Glib.Signal_NameTo API docTo spec :=

2336.                                           "query-tooltip";

2337.        Signal_Screen_Changed          : constant Glib.Signal_NameTo API docTo spec :=

2338.                                           "screen_changed";

2339.        Signal_Scroll_Event            : constant Glib.Signal_NameTo API docTo spec :=

2340.                                           "scroll_event";

2341.        Signal_Selection_Clear_Event   : constant Glib.Signal_NameTo API docTo spec :=

2342.                                           "selection_clear_event";

2343.        Signal_Selection_Get           : constant Glib.Signal_NameTo API docTo spec :=

2344.                                           "selection_get";

2345.        Signal_Selection_Notify_Event  : constant Glib.Signal_NameTo API docTo spec :=

2346.                                           "selection_notify_event";

2347.        Signal_Selection_Received      : constant Glib.Signal_NameTo API docTo spec :=

2348.                                           "selection_received";

2349.        Signal_Selection_Request_Event : constant Glib.Signal_NameTo API docTo spec :=

2350.                                           "selection_request_event";

2351.        Signal_Show                    : constant Glib.Signal_NameTo API docTo spec :=

2352.                                           "show";

2353.        Signal_Show_Help               : constant Glib.Signal_NameTo API docTo spec :=

2354.                                           "show_help";

2355.        Signal_Size_Allocate           : constant Glib.Signal_NameTo API docTo spec :=

2356.                                           "size_allocate";

2357.        Signal_Size_Request            : constant Glib.Signal_NameTo API docTo spec :=

2358.                                           "size_request";

2359.        Signal_State_Changed           : constant Glib.Signal_NameTo API docTo spec :=

2360.                                           "state_changed";

2361.        Signal_Style_Set               : constant Glib.Signal_NameTo API docTo spec :=

2362.                                           "style_set";

2363.        Signal_Unmap                   : constant Glib.Signal_NameTo API docTo spec :=

2364.                                           "unmap";

2365.        Signal_Unmap_Event             : constant Glib.Signal_NameTo API docTo spec :=

2366.                                           "unmap_event";

2367.        Signal_Unrealize               : constant Glib.Signal_NameTo API docTo spec :=

2368.                                           "unrealize";

2369.        Signal_Visibility_Notify_Event : constant Glib.Signal_NameTo API docTo spec :=

2370.                                           "visibility_notify_event";

2371.        Signal_Window_State_Event      : constant Glib.Signal_NameTo API docTo spec :=

2372.                                           "window_state_event";

2374.     private

2376.        type Gtk_Widget_RecordTo API docTo spec is new Glib.Object.GObject_RecordTo API docTo specTo body with null record;

2378.        Name_PropertyTo API docTo spec                : constant Glib.Properties.Property_StringTo API docTo spec :=

2379.          Glib.Properties.BuildTo API docTo specTo body ("name");

2380.        Parent_PropertyTo API docTo spec              : constant Glib.Properties.Property_ObjectTo API docTo spec :=

2381.          Glib.Properties.BuildTo API docTo specTo body ("parent");

2382.        X_PropertyTo API docTo spec                   : constant Glib.Properties.Property_IntTo API docTo spec :=

2383.          Glib.Properties.BuildTo API docTo specTo body ("x");

2384.        Y_PropertyTo API docTo spec                   : constant Glib.Properties.Property_IntTo API docTo spec :=

2385.          Glib.Properties.BuildTo API docTo specTo body ("y");

2386.        Width_PropertyTo API docTo spec               : constant Glib.Properties.Property_IntTo API docTo spec :=

2387.          Glib.Properties.BuildTo API docTo specTo body ("width");

2388.        Height_PropertyTo API docTo spec              : constant Glib.Properties.Property_IntTo API docTo spec :=

2389.          Glib.Properties.BuildTo API docTo specTo body ("height");

2390.        Visible_PropertyTo API docTo spec             : constant Glib.Properties.Property_BooleanTo API docTo spec :=

2391.          Glib.Properties.BuildTo API docTo specTo body ("visible");

2392.        Sensitive_PropertyTo API docTo spec           : constant Glib.Properties.Property_BooleanTo API docTo spec :=

2393.          Glib.Properties.BuildTo API docTo specTo body ("sensitive");

2394.        App_Paintable_PropertyTo API docTo spec       : constant Glib.Properties.Property_BooleanTo API docTo spec :=

2395.          Glib.Properties.BuildTo API docTo specTo body ("app_paintable");

2396.        Can_Focus_PropertyTo API docTo spec           : constant Glib.Properties.Property_BooleanTo API docTo spec :=

2397.          Glib.Properties.BuildTo API docTo specTo body ("can_focus");

2398.        Has_Focus_PropertyTo API docTo spec           : constant Glib.Properties.Property_BooleanTo API docTo spec :=

2399.          Glib.Properties.BuildTo API docTo specTo body ("has_focus");

2400.        Can_Default_PropertyTo API docTo spec         : constant Glib.Properties.Property_BooleanTo API docTo spec :=

2401.          Glib.Properties.BuildTo API docTo specTo body ("can_default");

2402.        Has_Default_PropertyTo API docTo spec         : constant Glib.Properties.Property_BooleanTo API docTo spec :=

2403.          Glib.Properties.BuildTo API docTo specTo body ("has_default");

2404.        Receives_Default_PropertyTo API docTo spec    : constant Glib.Properties.Property_BooleanTo API docTo spec :=

2405.          Glib.Properties.BuildTo API docTo specTo body ("receives_default");

2406.        Composite_Child_PropertyTo API docTo spec     : constant Glib.Properties.Property_BooleanTo API docTo spec :=

2407.          Glib.Properties.BuildTo API docTo specTo body ("composite_child");

2408.        Style_PropertyTo API docTo spec               : constant Glib.Properties.Property_ObjectTo API docTo spec :=

2409.          Glib.Properties.BuildTo API docTo specTo body ("style");

2410.        Events_PropertyTo API docTo spec              : constant Gdk.Event.Property_Gdk_Event_MaskTo API docTo spec :=

2411.          Gdk.Event.BuildTo API docTo specTo body ("events");

2412.        Prop_Extensions_Events_PropertyTo API docTo spec :

2413.          constant Gdk.Types.Property_Gdk_Extension_ModeTo API docTo spec :=

2414.          Gdk.Types.BuildTo API docTo specTo body ("extension_events");

2415.        Extension_Events_PropertyTo API docTo spec : constant Gdk.Types.Property_Gdk_Extension_ModeTo API docTo spec

2416.          := Gdk.Types.BuildTo API docTo specTo body ("extension-events");

2417.        Height_Request_PropertyTo API docTo spec : constant Glib.Properties.Property_IntTo API docTo spec :=

2418.          Glib.Properties.BuildTo API docTo specTo body ("height-request");

2419.        Is_Focus_PropertyTo API docTo spec : constant Glib.Properties.Property_BooleanTo API docTo spec :=

2420.          Glib.Properties.BuildTo API docTo specTo body ("is-focus");

2421.        No_Show_All_PropertyTo API docTo spec : constant Glib.Properties.Property_BooleanTo API docTo spec :=

2422.          Glib.Properties.BuildTo API docTo specTo body ("no-show-all");

2423.        Width_Request_PropertyTo API docTo spec : constant Glib.Properties.Property_IntTo API docTo spec :=

2424.          Glib.Properties.BuildTo API docTo specTo body ("width-request");

2425.        Tooltip_Markup_PropertyTo API docTo spec : constant Glib.Properties.Property_StringTo API docTo spec :=

2426.          Glib.Properties.BuildTo API docTo specTo body ("tooltip-markup");

2427.        Tooltip_Text_PropertyTo API docTo spec : constant Glib.Properties.Property_StringTo API docTo spec :=

2428.          Glib.Properties.BuildTo API docTo specTo body ("tooltip-text");

2429.        Has_Tooltip_PropertyTo API docTo spec : constant Glib.Properties.Property_BooleanTo API docTo spec :=

2430.          Glib.Properties.BuildTo API docTo specTo body ("has-tooltip");

2431.        Window_PropertyTo API docTo spec : constant Glib.Properties.Property_ObjectTo API docTo spec :=

2432.          Glib.Properties.BuildTo API docTo specTo body ("window");

2434.        Cursor_Aspect_Ratio_PropertyTo API docTo spec : constant Glib.Properties.Property_FloatTo API docTo spec :=

2435.          Glib.Properties.BuildTo API docTo specTo body ("cursor-aspect-ratio");

2436.     --     Cursor_Color_Property : constant Glib.Properties.Property_Boxed :=

2437.     --       Glib.Properties.Build ("cursor-color");

2438.     --     Draw_Border_Property : constant Glib.Properties.Property_Boxed :=

2439.     --       Glib.Properties.Build ("draw-border");

2440.        Focus_Line_Pattern_PropertyTo API docTo spec : constant Glib.Properties.Property_StringTo API docTo spec :=

2441.          Glib.Properties.BuildTo API docTo specTo body ("focus-line-pattern");

2442.        Focus_Line_Width_PropertyTo API docTo spec : constant Glib.Properties.Property_IntTo API docTo spec :=

2443.          Glib.Properties.BuildTo API docTo specTo body ("focus-line-width");

2444.        Focus_Padding_PropertyTo API docTo spec : constant Glib.Properties.Property_IntTo API docTo spec :=

2445.          Glib.Properties.BuildTo API docTo specTo body ("focus-padding");

2446.        Interior_Focus_PropertyTo API docTo spec : constant Glib.Properties.Property_BooleanTo API docTo spec :=

2447.          Glib.Properties.BuildTo API docTo specTo body ("interior-focus");

2448.        Link_Color_PropertyTo API docTo spec : constant Glib.Properties.Property_BoxedTo API docTo spec :=

2449.          Glib.Properties.BuildTo API docTo specTo body ("link-color");

2450.        Scroll_Arrow_Hlength_PropertyTo API docTo spec : constant Glib.Properties.Property_IntTo API docTo spec :=

2451.          Glib.Properties.BuildTo API docTo specTo body ("scroll-arrow-hlength");

2452.        Scroll_Arrow_Vlength_PropertyTo API docTo spec : constant Glib.Properties.Property_IntTo API docTo spec :=

2453.          Glib.Properties.BuildTo API docTo specTo body ("scroll-arrow-vlength");

2454.        --  Secondary_Cursor_Color_Property : constant

2455.        --    Glib.Properties.Property_Boxed :=

2456.        --    Glib.Properties.Build ("secondary-cursor-color");

2457.        Separator_Height_PropertyTo API docTo spec : constant Glib.Properties.Property_IntTo API docTo spec :=

2458.          Glib.Properties.BuildTo API docTo specTo body ("separator-height");

2459.        Separator_Width_PropertyTo API docTo spec : constant Glib.Properties.Property_IntTo API docTo spec :=

2460.          Glib.Properties.BuildTo API docTo specTo body ("separator-width");

2461.        Visited_Link_Color_PropertyTo API docTo spec : constant Glib.Properties.Property_BoxedTo API docTo spec :=

2462.          Glib.Properties.BuildTo API docTo specTo body ("visited-link-color");

2463.        Wide_Separators_PropertyTo API docTo spec : constant Glib.Properties.Property_BooleanTo API docTo spec :=

2464.          Glib.Properties.BuildTo API docTo specTo body ("wide-separators");

2466.        pragma Import (C, Pop_ColormapTo API docTo spec, "gtk_widget_pop_colormap");

2467.        pragma Import (C, Get_TypeTo API docTo spec, "gtk_widget_get_type");

2468.        pragma Import (C, Requisition_Get_TypeTo API docTo spec, "gtk_requisition_get_type");

2469.        pragma Import (C, Get_Default_ColormapTo API docTo spec, "gtk_widget_get_default_colormap");

2470.        pragma Import (C, Get_Default_VisualTo API docTo spec, "gtk_widget_get_default_visual");

2471.        pragma Import (C, Push_ColormapTo API docTo spec, "gtk_widget_push_colormap");

2472.        pragma Import (C, Set_Default_ColormapTo API docTo spec, "gtk_widget_set_default_colormap");

2473.        pragma Import (C, Set_Default_Size_Allocate_HandlerTo API docTo spec,

2474.                       "ada_gtk_widget_set_default_size_allocate_handler");

2475.        pragma Import (C, Default_Expose_Event_HandlerTo API docTo spec,

2476.                       "ada_gtk_default_expose_event_handler");

2477.        pragma Import (C, Push_Composite_ChildTo API docTo spec, "gtk_widget_push_composite_child");

2478.        pragma Import (C, Pop_Composite_ChildTo API docTo spec, "gtk_widget_pop_composite_child");

2479.        pragma Import

2480.          (C, Get_Default_DirectionTo API docTo spec, "gtk_widget_get_default_direction");

2481.        pragma Import

2482.          (C, Set_Default_DirectionTo API docTo spec, "gtk_widget_set_default_direction");

2483.        pragma Import

2484.          (C, Class_Install_Style_PropertyTo API docTo spec,

2485.           "gtk_widget_class_install_style_property");

2487.        pragma Inline (Toplevel_Is_SetTo API docTo specTo body);

2488.        pragma Inline (No_Window_Is_SetTo API docTo specTo body);

2489.        pragma Inline (Realized_Is_SetTo API docTo specTo body);

2490.        pragma Inline (Mapped_Is_SetTo API docTo specTo body);

2491.        pragma Inline (Visible_Is_SetTo API docTo specTo body);

2492.        pragma Inline (Drawable_Is_SetTo API docTo specTo body);

2493.        pragma Inline (Is_SensitiveTo API docTo specTo body);

2494.        pragma Inline (Can_Focus_Is_SetTo API docTo specTo body);

2495.        pragma Inline (Has_Focus_Is_SetTo API docTo specTo body);

2496.        pragma Inline (Has_Default_Is_SetTo API docTo specTo body);

2497.        pragma Inline (Has_Grab_Is_SetTo API docTo specTo body);

2498.        pragma Inline (Rc_Style_Is_SetTo API docTo specTo body);

2499.        pragma Inline (Double_Buffered_Is_SetTo API docTo specTo body);

2501.     end Gtk.WidgetTo API docTo specTo body;

2503.     --  Not needed, so not bound

2504.     --  No binding: gtk_requisition_copy

2505.     --  No binding: gtk_requisition_free

2506.     --  No binding: gtk_widget_ref

2507.     --  No binding: gtk_widget_unref

2508.     --  No binding: gtk_widget_new

2509.     --  No binding: gtk_widget_destroy

2510.     --  No binding: gtk_widget_destroyed

2511.     --  No binding: gtk_widget_get_accessible

2512.     --  No binding: gtk_widget_get_display

2513.     --  No binding: gtk_widget_get_screen

2514.     --  No binding: gtk_widget_style_get_valist

2515.     --  No binding: gtk_widget_set

2516.     --  No binding: gtk_widget_style_get

2518.     --  Might be useful, but very complex to explain

2519.     --  No binding: gtk_widget_list_accel_closures

2520.     --  No binding: gtk_widget_class_install_style_property_parser

2522.     --  Binding is in Gtk.RC

2523.     --  No binding: gtk_widget_modify_style

2524.     --  No binding: gtk_widget_get_modifier_style

2526.     --  Binding is in Gtk.Setting

2527.     --  No binding: gtk_widget_get_settings

2529.     --  Binding is in Gtk.Clipboard

2530.     --  No binding: gtk_widget_get_clipboard

2532.     --  Binding uses custom C glue

2533.     --  No binding: gtk_widget_get_window