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-2013, 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. ----------------------------------------------------------------------- 
  29.  
  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> 
  39.  
  40. with Glib.Object; 
  41.  
  42. with Gdk.Event; 
  43. with Gdk.Types; 
  44. with Gtk.Widget; 
  45. with Pango.Font; 
  46. with System; 
  47.  
  48. package Gtk.Main is 
  49.    pragma Elaborate_Body; 
  50.  
  51.    -------------------------------------- 
  52.    -- Initialization and exit routines -- 
  53.    -------------------------------------- 
  54.  
  55.    procedure Init; 
  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 
  60.  
  61.    function Init_Check return Boolean; 
  62.    --  Initialize GtkAda's internal structures. 
  63.    --  Return False if there was an error (no access to the display, etc.) 
  64.  
  65.    procedure Disable_Setlocale; 
  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. 
  73.  
  74.    function Check_Version 
  75.      (Required_Major : Guint := Gtk.Major_Version; 
  76.       Required_Minor : Guint := Gtk.Minor_Version; 
  77.       Required_Micro : Guint := Gtk.Micro_Version) 
  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. 
  100.  
  101.    function Get_Default_Language return Pango.Font.Pango_Language; 
  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. 
  107.  
  108.    ----------------------------- 
  109.    -- Init and Quit functions -- 
  110.    ----------------------------- 
  111.  
  112.    type Init_Function is access procedure (Data : System.Address); 
  113.    pragma Convention (C, Init_Function); 
  114.    --  Function called just before starting the main loop. 
  115.    --  This can be registered with Init_Add below. 
  116.  
  117.    type Quit_Handler_Id is new Guint; 
  118.    --  registration ID for functions that will be called before the 
  119.    --  main loop exits. 
  120.  
  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. 
  125.  
  126.    --  <doc_ignore> 
  127.    generic 
  128.       type Data_Type (<>) is private; 
  129.    package Quit is 
  130.       type Quit_Function is access function (Data : Data_Type) return Boolean; 
  131.  
  132.       function Quit_Add 
  133.         (Main_Level : Guint; 
  134.          Func       : Quit_Function; 
  135.          Data       : Data_Type) return Quit_Handler_Id; 
  136.  
  137.    private 
  138.       procedure Free_Data (D : System.Address); 
  139.       pragma Convention (C, Free_Data); 
  140.  
  141.       function General_Cb (D : System.Address) return Gint; 
  142.       pragma Convention (C, General_Cb); 
  143.    end Quit; 
  144.    --  !!Warning!!: This package needs to be instantiated at library level 
  145.    --  since it calls some internal functions as callback. 
  146.    --  </doc_ignore> 
  147.  
  148.    ------------------- 
  149.    -- The main loop -- 
  150.    ------------------- 
  151.  
  152.    function Events_Pending return Boolean; 
  153.    --  Return True if there are some events waiting in the event queue. 
  154.  
  155.    procedure Main; 
  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. 
  162.  
  163.    function Main_Level return Guint; 
  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). 
  167.  
  168.    procedure Main_Quit; 
  169.    --  Quit the current main loop. 
  170.    --  If this was the last active main loop, no more events will be processed 
  171.    --  by GtkAda. 
  172.  
  173.    function Main_Iteration (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; 
  187.  
  188.    procedure Do_Event (Event : Gdk.Event.Gdk_Event); 
  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. 
  226.  
  227.    procedure Propagate_Event 
  228.      (Widget : access Gtk.Widget.Gtk_Widget_Record'Class; 
  229.       Event  : Gdk.Event.Gdk_Event); 
  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. 
  246.  
  247.    function Get_Event_Widget 
  248.      (Event : Gdk.Event.Gdk_Event) return Gtk.Widget.Gtk_Widget; 
  249.    --  Return the widget to which Event applies. 
  250.  
  251.    function Get_Current_Event return Gdk.Event.Gdk_Event; 
  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. 
  255.  
  256.    procedure Get_Current_Event_State 
  257.      (State             : out Gdk.Types.Gdk_Modifier_Type; 
  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. 
  262.  
  263.    function Get_Current_Event_Time return Guint32; 
  264.    --  If there is a current event and it has a timestamp, return that 
  265.    --  timestamp, otherwise return Gdk.Types.Current_Time 
  266.  
  267.    ---------- 
  268.    -- Keys -- 
  269.    ---------- 
  270.  
  271.    type Key_Snooper_Func is 
  272.      access function (Widget : System.Address; 
  273.                       Event  : Gdk.Event.Gdk_Event_Key; 
  274.                       Data   : System.Address) return Gboolean; 
  275.    pragma Convention (C, Key_Snooper_Func); 
  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). 
  286.  
  287.    type Key_Snooper_Id is new Guint; 
  288.  
  289.    function Key_Snooper_Install 
  290.      (Snooper   : Key_Snooper_Func; 
  291.       Func_Data : System.Address) return Key_Snooper_Id; 
  292.    --  Install a new key snooper function, which will get called before events 
  293.    --  are delivered normally. 
  294.  
  295.    procedure Key_Snooper_Remove 
  296.      (Snooper_Handler_Id : Key_Snooper_Id); 
  297.    --  Remove the snooper with the given Id 
  298.  
  299.    -------------------- 
  300.    -- Grab functions -- 
  301.    -------------------- 
  302.  
  303.    procedure Grab_Add (Widget : access Gtk.Widget.Gtk_Widget_Record'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 
  314.  
  315.    procedure Grab_Remove (Widget : access Gtk.Widget.Gtk_Widget_Record'Class); 
  316.    --  Remove a widget from the grab list. 
  317.  
  318.    function Grab_Get_Current return Gtk.Widget.Gtk_Widget; 
  319.    --  Return the widget that currently has the focus. 
  320.  
  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> 
  329.  
  330.    procedure Gtk_Exit (Error_Code : Gint); 
  331.    pragma Obsolescent (Gtk_Exit); 
  332.    --  Terminate GtkAda. 
  333.    --  Deprecated, use Main_Quit instead. 
  334.  
  335.    type Idle_Handler_Id is new Guint; 
  336.    --  pragma Obsolescent (Entity => Idle_Handler_Id); 
  337.    --  Id for Idle handlers. 
  338.  
  339.    type Idle_Priority   is new Guint; 
  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. 
  344.  
  345.    Priority_High_Idle    : constant Idle_Priority := 100; 
  346.    Priority_Default_Idle : constant Idle_Priority := 200; 
  347.    Priority_Low_Idle     : constant Idle_Priority := 300; 
  348.  
  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. 
  355.  
  356.    function Idle_Add 
  357.      (Cb       : Idle_Callback; 
  358.       Priority : Idle_Priority := Priority_Default_Idle) 
  359.       return Idle_Handler_Id; 
  360.    pragma Obsolescent (Idle_Add, "Use Glib.Main.Idle_Add");  --  Idle_Add_Full 
  361.    --  Register an idle callback with no user data. 
  362.  
  363.    generic 
  364.       type Data_Type (<>) is private; 
  365.    package Idle is 
  366.       type Callback is access function (D : Data_Type) return Boolean; 
  367.       type Destroy_Callback is access procedure (D : in out Data_Type); 
  368.  
  369.       function Add 
  370.         (Cb       : Callback; 
  371.          D        : Data_Type; 
  372.          Priority : Idle_Priority := Priority_Default_Idle; 
  373.          Destroy  : Destroy_Callback := null) 
  374.          return Idle_Handler_Id; 
  375.       pragma Obsolescent (Add, "Use Glib.Main.Idle"); 
  376.  
  377.    private 
  378.       procedure Free_Data (D : System.Address); 
  379.       pragma Convention (C, Free_Data); 
  380.  
  381.       function General_Cb (D : System.Address) return Gint; 
  382.       pragma Convention (C, General_Cb); 
  383.    end Idle; 
  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. 
  387.  
  388.    procedure Idle_Remove (Id : Idle_Handler_Id); 
  389.    pragma Obsolescent (Idle_Remove, "Use Glib.Main.Idle_Remove"); 
  390.    --  Remove an idle callback, when its Id is known. 
  391.  
  392.    type Timeout_Handler_Id is new Guint; 
  393.    --  pragma Obsolescent (Entity => Timeout_Handle_Id); 
  394.    --  Id for Timeout handlers. 
  395.  
  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. 
  401.  
  402.    function Timeout_Add 
  403.      (Interval : Guint32; 
  404.       Func : Timeout_Callback) return Timeout_Handler_Id; 
  405.    pragma Obsolescent (Timeout_Add, "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. 
  408.  
  409.    generic 
  410.       type Data_Type (<>) is private; 
  411.    package Timeout is 
  412.       type Callback is access function (D : Data_Type) return Boolean; 
  413.       type Destroy_Callback is access procedure (D : in out Data_Type); 
  414.  
  415.       function Add 
  416.         (Interval : Guint32; 
  417.          Func     : Callback; 
  418.          D        : Data_Type; 
  419.          Destroy  : Destroy_Callback := null) return Timeout_Handler_Id; 
  420.       pragma Obsolescent (Add, "Use Glib.Main.Timeout"); 
  421.       --  Adds a new timeout. Func will be called after Interval milliseconds. 
  422.  
  423.    private 
  424.       procedure Free_Data (D : System.Address); 
  425.       pragma Convention (C, Free_Data); 
  426.  
  427.       function General_Cb (D : System.Address) return Gint; 
  428.       pragma Convention (C, General_Cb); 
  429.    end Timeout; 
  430.  
  431.    procedure Timeout_Remove (Id : Timeout_Handler_Id); 
  432.    pragma Obsolescent (Timeout_Remove, "Use Glib.Main.Timeout_Remove"); 
  433.    --  Unregister a timeout function. 
  434.  
  435.    function Set_Locale return String; 
  436.    pragma Obsolescent (Set_Locale); 
  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 
  440.  
  441.    procedure Set_Locale; 
  442.    pragma Obsolescent (Set_Locale); 
  443.    --  Read and parse the local settings, such as time format, ... 
  444.  
  445.    procedure Init_Add (Func : Init_Function; Data : System.Address); 
  446.    pragma Obsolescent (Init_Add); 
  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. 
  450.  
  451.    function Quit_Add 
  452.      (Main_Level : Guint; Func : Quit_Function) return Quit_Handler_Id; 
  453.    pragma Obsolescent (Quit_Add); 
  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. 
  462.  
  463.    function Quit_Add_Destroy 
  464.      (Main_Level : Guint; 
  465.       Object     : access Glib.Object.GObject_Record'Class) 
  466.       return Quit_Handler_Id; 
  467.    pragma Obsolescent (Quit_Add_Destroy); 
  468.    --  Ensure that Object is destroyed when exiting the main loop at Main_Level 
  469.    --  (or the current main loop level is 0). 
  470.  
  471.    procedure Quit_Remove (Id : Quit_Handler_Id); 
  472.    pragma Obsolescent (Quit_Remove); 
  473.    --  Remove a Quit Handler, that has been previously set by Quit_Add. 
  474.  
  475.    --  </doc_ignore> 
  476.  
  477. private 
  478.    pragma Import (C, Gtk_Exit, "gtk_exit"); 
  479.    pragma Import (C, Main_Level, "gtk_main_level"); 
  480.    pragma Import (C, Main_Quit, "gtk_main_quit"); 
  481.    pragma Import (C, Main, "gtk_main"); 
  482.    pragma Import (C, Idle_Remove, "gtk_idle_remove"); 
  483.    pragma Import (C, Timeout_Remove, "gtk_timeout_remove"); 
  484.    pragma Import (C, Init_Add, "gtk_init_add"); 
  485.    pragma Import (C, Quit_Remove, "gtk_quit_remove"); 
  486.    pragma Import (C, Get_Current_Event, "gtk_get_current_event"); 
  487.    pragma Import (C, Disable_Setlocale, "gtk_disable_setlocale"); 
  488.    pragma Import (C, Get_Current_Event_Time, "gtk_get_current_event_time"); 
  489.    pragma Import (C, Get_Default_Language, "gtk_get_default_language"); 
  490.    pragma Import (C, Key_Snooper_Remove, "gtk_key_snooper_remove"); 
  491.    pragma Import (C, Key_Snooper_Install, "gtk_key_snooper_install"); 
  492.  
  493.    --  The following two subprograms are specific to Win32 
  494.    --  No binding: gtk_init_abi_check 
  495.    --  No binding: gtk_init_check_abi_check 
  496.  
  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 
  501.  
  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 
  507.  
  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 
  511.  
  512.    --  These functions are intended as callbacks, but do not apply to GtkAda 
  513.    --  No binding: gtk_true 
  514.    --  No binding: gtk_false 
  515.  
  516.    --  These functions were never bound, and are now obsolesent anyway 
  517.    --  No binding: gtk_input_add_full 
  518.    --  No binding: gtk_input_remove 
  519.  
  520. end Gtk.Main;