## 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.     --  This package contains top-level subprograms that are used to initialize

32.     --  GtkAda and interact with the main event loop.

33.     --

34.     --  It also provides a set of packages to set up idle functions, timeout

35.     --  functions, and functions to be called before and after entering the

36.     --  main loop.

37.     --  </description>

38.     --  <c_version>2.8.17</c_version>

40.     with Glib.ObjectTo API docTo specTo body;

42.     with Gdk.EventTo API docTo specTo body;

43.     with Gdk.TypesTo API docTo spec;

44.     with Gtk.WidgetTo API docTo specTo body;

45.     with Pango.FontTo API docTo specTo body;

46.     with System;

48.     package Gtk.MainTo API docTo specTo body is

49.        pragma Elaborate_Body;

51.        --------------------------------------

52.        -- Initialization and exit routines --

53.        --------------------------------------

55.        procedure InitTo API docTo body;

56.        --  Initialize GtkAda's internal structures.

57.        --  This subprogram should be called before any other one in GtkAda.

58.        --  If GtkAda could not be initialized (no access to the display, etc.), the

59.        --  application exits with an error

61.        function Init_CheckTo API docTo body return Boolean;

62.        --  Initialize GtkAda's internal structures.

63.        --  Return False if there was an error (no access to the display, etc.)

65.        procedure Disable_SetlocaleTo API docTo body;

66.        --  Prevents Init, Init_Check and Parse_Args from automatic calling

67.        --  Set_Locale (LC_ALL, ""). You would want to use this function if you

68.        --  wanted to set the locale for your program to something other than the

69.        --  user's locale, or if you wanted to set different values for different

70.        --  locale categories.

71.        --

72.        --  Most programs should not need to call this function.

74.        function Check_VersionTo API docTo body

75.          (Required_Major : GuintTo API docTo spec := Gtk.Major_VersionTo API docTo specTo body;

76.           Required_Minor : GuintTo API docTo spec := Gtk.Minor_VersionTo API docTo specTo body;

77.           Required_Micro : GuintTo API docTo spec := Gtk.Micro_VersionTo API docTo specTo body)

78.           return String;

79.        --  Checks that the GTK+ library in use is compatible with the given

80.        --  version. Generally you would pass in the constants Gtk.Major_Version,

81.        --  Gtk.Minor_Version, Gtk.Micro_Version as the three arguments to this

82.        --  function; that produces a check that the library in use is compatible

83.        --  with the version of GTK+ the application or module was compiled against.

84.        --

85.        --  Compatibility is defined by two things: first the version of the running

86.        --  library is newer than the version

87.        --  required_major.required_minor.required_micro. Second the running library

88.        --  must be binary compatible with the version

89.        --  required_major.required_minor.required_micro (same major version.)

90.        --

91.        --  This function is primarily for GTK+ modules; the module can call this

92.        --  function to check that it wasn't loaded into an incompatible version of

93.        --  GTK+. However, such a check isn't completely reliable, since the module

94.        --  may be linked against an old version of GTK+ and calling the old version

95.        --  of gtk_check_version(), but still get loaded into an application using a

96.        --  newer version of GTK+.

97.        --

98.        --  Return value: %NULL if the GTK+ library is compatible with the given

99.        --  version, or a string describing the version mismatch.

101.        function Get_Default_LanguageTo API docTo body return Pango.Font.Pango_LanguageTo API docTo spec;

102.        --  Returns the Pango_Language for the default language currently in

103.        --  effect. (Note that this can change over the life of an

104.        --  application.)  The default language is derived from the current

105.        --  locale. It determines, for example, whether GTK+ uses the

106.        --  right-to-left or left-to-right text direction.

108.        -----------------------------

109.        -- Init and Quit functions --

110.        -----------------------------

112.        type Init_Function is access procedure (Data : System.Address);

113.        pragma Convention (C, Init_FunctionTo API docTo spec);

114.        --  Function called just before starting the main loop.

115.        --  This can be registered with Init_Add below.

117.        type Quit_Handler_Id is new GuintTo API docTo spec;

118.        --  registration ID for functions that will be called before the

119.        --  main loop exits.

121.        type Quit_Function is access function return Boolean;

122.        --  Type of function that can be called when the main loop exits.

123.        --  It should return False if it should not be called again when another

124.        --  main loop exits.

126.        --  <doc_ignore>

127.        generic

128.           type Data_Type (<>) is private;

129.        package QuitTo API docTo body is

130.           type Quit_Function is access function (Data : Data_TypeTo API docTo spec) return Boolean;

132.           function Quit_AddTo API docTo body

133.             (Main_Level : GuintTo API docTo spec;

134.              Func       : Quit_FunctionTo API docTo spec;

135.              Data       : Data_TypeTo API docTo spec) return Quit_Handler_IdTo API docTo spec;

137.        private

138.           procedure Free_Data (D : System.Address);

139.           pragma Convention (C, Free_Data);

141.           function General_Cb (D : System.Address) return GintTo API docTo spec;

142.           pragma Convention (C, General_Cb);

143.        end QuitTo API docTo specTo body;

144.        --  !!Warning!!: This package needs to be instantiated at library level

145.        --  since it calls some internal functions as callback.

146.        --  </doc_ignore>

148.        -------------------

149.        -- The main loop --

150.        -------------------

152.        function Events_PendingTo API docTo body return Boolean;

153.        --  Return True if there are some events waiting in the event queue.

155.        procedure MainTo API docTo body;

156.        --  Start the main loop, and returns only when the main loop is exited.

157.        --  This subprogram can be called recursively, to start new internal

158.        --  loops. Each of these loops is exited through a call to Main_Quit.

159.        --  This is the recommended method to use when you want to popup a dialog

160.        --  and wait for the user answer before going any further.

161.        --  Note that this procedure can only be called within a single task.

163.        function Main_LevelTo API docTo body return GuintTo API docTo spec;

164.        --  Return the level of the current main loop.

165.        --  Since there can be nested loops, this returns the depth of the

166.        --  current one, starting from 1 (0 if there is none).

168.        procedure Main_QuitTo API docTo body;

169.        --  Quit the current main loop.

170.        --  If this was the last active main loop, no more events will be processed

171.        --  by GtkAda.

173.        function Main_IterationTo API docTo body (Blocking : Boolean := True) return Boolean;

174.        --  Do one iteration of the main loop.

175.        --  Blocking indicates whether GtkAda should wait for an event to be

176.        --  available, or simply exit if there is none.

177.        --  Returns True if no main loop is running (ie Main_Quite was called for

178.        --  the innermost main loop).

179.        --  When doing some heavy calculations in an application, it is recommended

180.        --  that you check from time to time if there are any events pending and

181.        --  process them, so that your application still reacts to events.

182.        --  To do that, you would add a loop like:

183.        --

184.        --    while Gtk.Main.Events_Pending loop

185.        --        Dead := Gtk.Main.Main_Iteration;

186.        --    end loop;

188.        procedure Do_EventTo API docTo body (Event : Gdk.Event.Gdk_EventTo API docTo spec);

189.        --  Process Event as if it was in the event queue.

190.        --  This function should almost never be used in your own application, this

191.        --  is the core function for event processing in GtkAda.

192.        --  The user should not free Event, this is already done by GtkAda.

193.        --

194.        --  While you should not call this function directly, you might want to know

195.        --  how exactly events are handled. So here is what this function does with

196.        --  the event:

197.        --  * Compress enter/leave notify events. If the event passed build an

198.        --    enter/leave pair together with the next event (peeked from GDK) both

199.        --    events are thrown away. This is to avoid a backlog of

200.        --    (de-)highlighting widgets crossed by the pointer.

201.        --

202.        --  * Find the widget which got the event. If the widget can't be determined

203.        --    the event is thrown away unless it belongs to a INCR transaction. In

204.        --    that case it is passed to gtk_selection_incr_event().

205.        --

206.        --  * Then the event is passed on a stack so you can query the currently

207.        --    handled event with gtk_get_current_event().

208.        --

209.        --  * The event is sent to a widget. If a grab is active all events for

210.        --    widgets that are not in the container in the grab widget are sent to

211.        --    the latter with a few exceptions:

212.        --       - Deletion and destruction events are still sent to the event

213.        --         widget for obvious reasons.

214.        --       - Events which directly relate to the visual representation of the

215.        --         event widget.

216.        --       - Leave events are delivered to the event widget if there was an

217.        --         enter event delivered to it before without the paired leave event

218.        --       - Drag events are not redirected because it is unclear what the

219.        --         semantics of that would be.

220.        --       - Another point of interest might be that all key events are first

221.        --         passed through the key snooper functions if there are any. Read

222.        --         the description of Key_Snooper_Install if you need this

223.        --         feature.

224.        --

225.        --  * After finishing the delivery the event is popped from the event stack.

227.        procedure Propagate_EventTo API docTo body

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

229.           Event  : Gdk.Event.Gdk_EventTo API docTo spec);

230.        --  Sends an event to a widget, propagating the event to parent widgets

231.        --  if the event remains unhandled. Events received by GTK+ from GDK

232.        --  normally begin in Do_Event. Depending on the type of

233.        --  event, existence of modal dialogs, grabs, etc., the event may be

234.        --  propagated; if so, this function is used. Propagate_Event

235.        --  calls Gtk.Widget.Event on each widget it decides to send the

236.        --  event to.  So Gtk.Widget.Event is the lowest-level function; it

237.        --  simply emits the "event" and possibly an event-specific signal on a

238.        --  widget. Propagate_Event is a bit higher-level, and

239.        --  Do_Event is the highest level.

240.        --

241.        --  All that said, you most likely don't want to use any of these

242.        --  functions; synthesizing events is rarely needed. Consider asking on

243.        --  the mailing list for better ways to achieve your goals. For

244.        --  example, use gdk_window_invalidate_rect() or

245.        --  gtk_widget_queue_draw() instead of making up expose events.

247.        function Get_Event_WidgetTo API docTo body

248.          (Event : Gdk.Event.Gdk_EventTo API docTo spec) return Gtk.Widget.Gtk_WidgetTo API docTo spec;

249.        --  Return the widget to which Event applies.

251.        function Get_Current_EventTo API docTo body return Gdk.Event.Gdk_EventTo API docTo spec;

252.        --  Return a copy of the event being processed by gtk+. The returned

253.        --  value must be freed by the caller.

254.        --  If there is no current event, null is returned.

256.        procedure Get_Current_Event_StateTo API docTo body

257.          (State             : out Gdk.Types.Gdk_Modifier_TypeTo API docTo spec;

258.           Had_Current_Event : out Boolean);

259.        --  If there is a current event and it has a state field, place

260.        --  that state field in State and set Had_Current_Event to True, otherwise

261.        --  to False.

263.        function Get_Current_Event_TimeTo API docTo body return Guint32To API docTo spec;

264.        --  If there is a current event and it has a timestamp, return that

265.        --  timestamp, otherwise return Gdk.Types.Current_Time

267.        ----------

268.        -- Keys --

269.        ----------

271.        type Key_Snooper_Func is

272.          access function (Widget : System.Address;

273.                           Event  : Gdk.Event.Gdk_Event_KeyTo API docTo spec;

274.                           Data   : System.Address) return GbooleanTo API docTo spec;

275.        pragma Convention (C, Key_Snooper_FuncTo API docTo spec);

276.        --  This function is called before normal event delivery, and can be used to

277.        --  implement custom key event handling (for instance to create macros, or

278.        --  any other advanced feature).

279.        --  Since this is a fairly low-level function, no high-level interface is

280.        --  provided, and you need to convert Widget yourself to the appropriate

281.        --  Gtk_Widget type, with, for instance:

282.        --      Ada_Widget := Gtk.Widget.Convert (Widget);

283.        --  This function should return True to stop further event processing by

284.        --  gtk+ (ie no widget will receive it), or False to continue with normal

285.        --  event processing (for instance when you have handled the key).

287.        type Key_Snooper_Id is new GuintTo API docTo spec;

289.        function Key_Snooper_InstallTo API docTo body

290.          (Snooper   : Key_Snooper_FuncTo API docTo spec;

291.           Func_Data : System.Address) return Key_Snooper_IdTo API docTo spec;

292.        --  Install a new key snooper function, which will get called before events

293.        --  are delivered normally.

295.        procedure Key_Snooper_RemoveTo API docTo body

296.          (Snooper_Handler_Id : Key_Snooper_IdTo API docTo spec);

297.        --  Remove the snooper with the given Id

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

300.        -- Grab functions --

301.        --------------------

303.        procedure Grab_AddTo API docTo body (Widget : access Gtk.Widget.Gtk_Widget_RecordTo API docTo specTo body'Class);

304.        --  Add a new widget to the grab list.

305.        --  The widget at the front of this list gets all the events even if it does

306.        --  not have the focus. This feature should be used with care.

307.        --  If you want a whole window to get the events, it is better to use

308.        --  Gtk.Window.Set_Modal instead which does the grabbing and ungrabbing for

309.        --  you.

310.        --  The grab is only done for the application. Events outside the

311.        --  application are still sent to their respective windows.

312.        --

313.        --  See also Gtk.Window.Gtk_Window_Group

315.        procedure Grab_RemoveTo API docTo body (Widget : access Gtk.Widget.Gtk_Widget_RecordTo API docTo specTo body'Class);

316.        --  Remove a widget from the grab list.

318.        function Grab_Get_CurrentTo API docTo body return Gtk.Widget.Gtk_WidgetTo API docTo spec;

319.        --  Return the widget that currently has the focus.

321.        -----------------

322.        -- Obsolescent --

323.        -----------------

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

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

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

327.        --  with the -gnatwj switch

328.        --  <doc_ignore>

330.        procedure Gtk_ExitTo API docTo body (Error_Code : GintTo API docTo spec);

331.        pragma Obsolescent (Gtk_ExitTo API docTo specTo body);

332.        --  Terminate GtkAda.

333.        --  Deprecated, use Main_Quit instead.

335.        type Idle_Handler_Id is new GuintTo API docTo spec;

336.        --  pragma Obsolescent (Entity => Idle_Handler_Id);

337.        --  Id for Idle handlers.

339.        type Idle_Priority   is new GuintTo API docTo spec;

340.        --  pragma Obsolescent (Entity => Idle_Priority);

341.        --  Priorities that can be set for idle handlers.

342.        --  The higher the priority, the less urgent the task. Handlers whose

343.        --  priority is lower will be called before others.

345.        Priority_High_Idle    : constant Idle_PriorityTo API docTo spec := 100;

346.        Priority_Default_Idle : constant Idle_PriorityTo API docTo spec := 200;

347.        Priority_Low_Idle     : constant Idle_PriorityTo API docTo spec := 300;

349.        type Idle_Callback is access function return Boolean;

350.        --  pragma Obsolescent (Entity => Idle_Callback);

351.        --  Function that can be called automatically whenever GtkAda is not

352.        --  processing events.

353.        --  It should return True if the function should be called again as soon

354.        --  as possible, False if it should be unregistered.

356.        function Idle_AddTo API docTo body

357.          (Cb       : Idle_CallbackTo API docTo spec;

358.           Priority : Idle_PriorityTo API docTo spec := Priority_Default_IdleTo API docTo spec)

359.           return Idle_Handler_IdTo API docTo spec;

360.        pragma Obsolescent (Idle_AddTo API docTo specTo body, "Use Glib.Main.Idle_Add");  --  Idle_Add_Full

361.        --  Register an idle callback with no user data.

363.        generic

364.           type Data_Type (<>) is private;

365.        package IdleTo API docTo body is

366.           type Callback is access function (D : Data_TypeTo API docTo spec) return Boolean;

367.           type Destroy_Callback is access procedure (D : in out Data_TypeTo API docTo spec);

369.           function AddTo API docTo body

370.             (Cb       : CallbackTo API docTo spec;

371.              D        : Data_TypeTo API docTo spec;

372.              Priority : Idle_PriorityTo API docTo spec := Priority_Default_IdleTo API docTo spec;

373.              Destroy  : Destroy_CallbackTo API docTo spec := null)

374.              return Idle_Handler_IdTo API docTo spec;

375.           pragma Obsolescent (AddTo API docTo specTo body, "Use Glib.Main.Idle");

377.        private

378.           procedure Free_Data (D : System.Address);

379.           pragma Convention (C, Free_Data);

381.           function General_Cb (D : System.Address) return GintTo API docTo spec;

382.           pragma Convention (C, General_Cb);

383.        end IdleTo API docTo specTo body;

384.        --  Destroy will be called automatically just prior to the destruction of D.

385.        --  In particular, it is also called if the idle is destroyed through a call

386.        --  to Idle_Remove.

388.        procedure Idle_RemoveTo API docTo body (Id : Idle_Handler_IdTo API docTo spec);

389.        pragma Obsolescent (Idle_RemoveTo API docTo specTo body, "Use Glib.Main.Idle_Remove");

390.        --  Remove an idle callback, when its Id is known.

392.        type Timeout_Handler_Id is new GuintTo API docTo spec;

393.        --  pragma Obsolescent (Entity => Timeout_Handle_Id);

394.        --  Id for Timeout handlers.

396.        type Timeout_Callback is access function return Boolean;

397.        --  pragma Obsolescent (Entity => Timeout_Callback);

398.        --  Function that can be called automatically at precise time intervals.

399.        --  It should return True if the function should be called again as soon

400.        --  as possible, False if it should be unregistered.

402.        function Timeout_AddTo API docTo body

403.          (Interval : Guint32To API docTo spec;

404.           Func : Timeout_CallbackTo API docTo spec) return Timeout_Handler_IdTo API docTo spec;

405.        pragma Obsolescent (Timeout_AddTo API docTo specTo body, "Use Glib.Main.Timeout_Add");

406.        --  Add a new timeout. Func will be called after Interval milliseconds.

407.        --  The function will be called as long as it returns True.

409.        generic

410.           type Data_Type (<>) is private;

411.        package TimeoutTo API docTo body is

412.           type Callback is access function (D : Data_TypeTo API docTo spec) return Boolean;

413.           type Destroy_Callback is access procedure (D : in out Data_TypeTo API docTo spec);

415.           function AddTo API docTo body

416.             (Interval : Guint32To API docTo spec;

417.              Func     : CallbackTo API docTo spec;

418.              D        : Data_TypeTo API docTo spec;

419.              Destroy  : Destroy_CallbackTo API docTo spec := null) return Timeout_Handler_IdTo API docTo spec;

420.           pragma Obsolescent (AddTo API docTo specTo body, "Use Glib.Main.Timeout");

421.           --  Adds a new timeout. Func will be called after Interval milliseconds.

423.        private

424.           procedure Free_Data (D : System.Address);

425.           pragma Convention (C, Free_Data);

427.           function General_Cb (D : System.Address) return GintTo API docTo spec;

428.           pragma Convention (C, General_Cb);

429.        end TimeoutTo API docTo specTo body;

431.        procedure Timeout_RemoveTo API docTo body (Id : Timeout_Handler_IdTo API docTo spec);

432.        pragma Obsolescent (Timeout_RemoveTo API docTo specTo body, "Use Glib.Main.Timeout_Remove");

433.        --  Unregister a timeout function.

435.        function Set_LocaleTo API docTo body return String;

436.        pragma Obsolescent (Set_LocaleTo API docTo specTo body);

437.        --  Read and parse the local settings, such as time format, ...

438.        --  Return the name of the local settings, which can also be set with

439.        --  the environment variable LOCALE

441.        procedure Set_LocaleTo API docTo body;

442.        pragma Obsolescent (Set_LocaleTo API docTo specTo body);

443.        --  Read and parse the local settings, such as time format, ...

445.        procedure Init_AddTo API docTo body (Func : Init_FunctionTo API docTo spec; Data : System.Address);

446.        pragma Obsolescent (Init_AddTo API docTo specTo body);

447.        --  Register a function to be called just before starting a main loop.

448.        --  This function is called only once, even if a new main loop is started

449.        --  recursively.

451.        function Quit_AddTo API docTo body

452.          (Main_Level : GuintTo API docTo spec; Func : Quit_FunctionTo API docTo spec) return Quit_Handler_IdTo API docTo spec;

453.        pragma Obsolescent (Quit_AddTo API docTo specTo body);

454.        --  Register a new function to be called when the current main loop exits.

455.        --  The function will be called once when the current main loop exists.

456.        --  If it returns False, it will then be deleted from the list of

457.        --  quit functions, and won't be called again next time a main loop is

458.        --  exited.

459.        --  The function will only be called when exiting a main loop at level

460.        --  Main_Level. If Main_Level is 0, the function will be called for the

461.        --  current main_loop.

463.        function Quit_Add_DestroyTo API docTo body

464.          (Main_Level : GuintTo API docTo spec;

465.           Object     : access Glib.Object.GObject_RecordTo API docTo specTo body'Class)

466.           return Quit_Handler_IdTo API docTo spec;

467.        pragma Obsolescent (Quit_Add_DestroyTo API docTo specTo body);

468.        --  Ensure that Object is destroyed when exiting the main loop at Main_Level

469.        --  (or the current main loop level is 0).

471.        procedure Quit_RemoveTo API docTo body (Id : Quit_Handler_IdTo API docTo spec);

472.        pragma Obsolescent (Quit_RemoveTo API docTo specTo body);

473.        --  Remove a Quit Handler, that has been previously set by Quit_Add.

475.        --  </doc_ignore>

477.     private

478.        pragma Import (C, Gtk_ExitTo API docTo spec, "gtk_exit");

479.        pragma Import (C, Main_LevelTo API docTo spec, "gtk_main_level");

480.        pragma Import (C, Main_QuitTo API docTo spec, "gtk_main_quit");

481.        pragma Import (C, MainTo API docTo spec, "gtk_main");

482.        pragma Import (C, Idle_RemoveTo API docTo spec, "gtk_idle_remove");

483.        pragma Import (C, Timeout_RemoveTo API docTo spec, "gtk_timeout_remove");

484.        pragma Import (C, Init_AddTo API docTo spec, "gtk_init_add");

485.        pragma Import (C, Quit_RemoveTo API docTo spec, "gtk_quit_remove");

486.        pragma Import (C, Get_Current_EventTo API docTo spec, "gtk_get_current_event");

487.        pragma Import (C, Disable_SetlocaleTo API docTo spec, "gtk_disable_setlocale");

488.        pragma Import (C, Get_Current_Event_TimeTo API docTo spec, "gtk_get_current_event_time");

489.        pragma Import (C, Get_Default_LanguageTo API docTo spec, "gtk_get_default_language");

490.        pragma Import (C, Key_Snooper_RemoveTo API docTo spec, "gtk_key_snooper_remove");

491.        pragma Import (C, Key_Snooper_InstallTo API docTo spec, "gtk_key_snooper_install");

493.        --  The following two subprograms are specific to Win32

494.        --  No binding: gtk_init_abi_check

495.        --  No binding: gtk_init_check_abi_check

497.        --  No binding: gtk_get_option_group

498.        --  No binding: gtk_init_with_args

499.        --  No binding: gtk_parse_args

500.        --  No binding: gtk_main_iteration

502.        --  These functions are not bound, we only use gtk_idle_add_full

503.        --  No binding: gtk_idle_add

504.        --  No binding: gtk_idle_add_priority

505.        --  No binding: gtk_idle_remove_by_data

506.        --  No binding: gtk_timeout_add

508.        --  This function are not bound, we only use gtk_quit_add_full

509.        --  No binding: gtk_quit_add

510.        --  No binding: gtk_quit_remove_by_data

512.        --  These functions are intended as callbacks, but do not apply to GtkAda

513.        --  No binding: gtk_true

514.        --  No binding: gtk_false

516.        --  These functions were never bound, and are now obsolesent anyway

517.        --  No binding: gtk_input_add_full

518.        --  No binding: gtk_input_remove

520.     end Gtk.MainTo API docTo specTo body;