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. -- -- -- -- -- -- -- -- -- -- -- --
  23. ----------------------------------------------------------------------- 
  24.  
  25. --  <description> 
  26. --  This package contains top-level subprograms that are used to initialize 
  27. --  GtkAda and interact with the main event loop. 
  28. -- 
  29. --  It also provides a set of packages to set up idle functions, timeout 
  30. --  functions, and functions to be called before and after entering the 
  31. --  main loop. 
  32. --  </description> 
  33. --  <c_version>2.8.17</c_version> 
  34.  
  35. with Gdk.Event; 
  36. with Gdk.Types; 
  37. with Gtk.Widget; 
  38. with Gtk.Object; 
  39. with Pango.Font; 
  40. with System; 
  41.  
  42. package Gtk.Main is 
  43.    pragma Elaborate_Body; 
  44.  
  45.    -------------------------------------- 
  46.    -- Initialization and exit routines -- 
  47.    -------------------------------------- 
  48.  
  49.    procedure Init; 
  50.    --  Initialize GtkAda's internal structures. 
  51.    --  This subprogram should be called before any other one in GtkAda. 
  52.    --  If GtkAda could not be initialized (no access to the display, etc.), the 
  53.    --  application exits with an error 
  54.  
  55.    function Init_Check return Boolean; 
  56.    --  Initialize GtkAda's internal structures. 
  57.    --  Return False if there was an error (no access to the display, etc.) 
  58.  
  59.    procedure Disable_Setlocale; 
  60.    --  Prevents Init, Init_Check and Parse_Args from automatic calling 
  61.    --  Set_Locale (LC_ALL, ""). You would want to use this function if you 
  62.    --  wanted to set the locale for your program to something other than the 
  63.    --  user's locale, or if you wanted to set different values for different 
  64.    --  locale categories. 
  65.    -- 
  66.    --  Most programs should not need to call this function. 
  67.  
  68.    function Check_Version 
  69.      (Required_Major : Guint := Gtk.Major_Version; 
  70.       Required_Minor : Guint := Gtk.Minor_Version; 
  71.       Required_Micro : Guint := Gtk.Micro_Version) 
  72.       return String; 
  73.    --  Checks that the GTK+ library in use is compatible with the given 
  74.    --  version. Generally you would pass in the constants Gtk.Major_Version, 
  75.    --  Gtk.Minor_Version, Gtk.Micro_Version as the three arguments to this 
  76.    --  function; that produces a check that the library in use is compatible 
  77.    --  with the version of GTK+ the application or module was compiled against. 
  78.    -- 
  79.    --  Compatibility is defined by two things: first the version of the running 
  80.    --  library is newer than the version 
  81.    --  required_major.required_minor.required_micro. Second the running library 
  82.    --  must be binary compatible with the version 
  83.    --  required_major.required_minor.required_micro (same major version.) 
  84.    -- 
  85.    --  This function is primarily for GTK+ modules; the module can call this 
  86.    --  function to check that it wasn't loaded into an incompatible version of 
  87.    --  GTK+. However, such a check isn't completely reliable, since the module 
  88.    --  may be linked against an old version of GTK+ and calling the old version 
  89.    --  of gtk_check_version(), but still get loaded into an application using a 
  90.    --  newer version of GTK+. 
  91.    -- 
  92.    --  Return value: %NULL if the GTK+ library is compatible with the given 
  93.    --  version, or a string describing the version mismatch. 
  94.  
  95.    function Get_Default_Language return Pango.Font.Pango_Language; 
  96.    --  Returns the Pango_Language for the default language currently in 
  97.    --  effect. (Note that this can change over the life of an 
  98.    --  application.)  The default language is derived from the current 
  99.    --  locale. It determines, for example, whether GTK+ uses the 
  100.    --  right-to-left or left-to-right text direction. 
  101.  
  102.    ----------------------------- 
  103.    -- Init and Quit functions -- 
  104.    ----------------------------- 
  105.  
  106.    type Init_Function is access procedure (Data : System.Address); 
  107.    pragma Convention (C, Init_Function); 
  108.    --  Function called just before starting the main loop. 
  109.    --  This can be registered with Init_Add below. 
  110.  
  111.    type Quit_Handler_Id is new Guint; 
  112.    --  registration ID for functions that will be called before the 
  113.    --  main loop exits. 
  114.  
  115.    type Quit_Function is access function return Boolean; 
  116.    --  Type of function that can be called when the main loop exits. 
  117.    --  It should return False if it should not be called again when another 
  118.    --  main loop exits. 
  119.  
  120.    --  <doc_ignore> 
  121.    generic 
  122.       type Data_Type (<>) is private; 
  123.    package Quit is 
  124.       type Quit_Function is access function (Data : Data_Type) return Boolean; 
  125.  
  126.       function Quit_Add 
  127.         (Main_Level : Guint; 
  128.          Func       : Quit_Function; 
  129.          Data       : Data_Type) return Quit_Handler_Id; 
  130.  
  131.    private 
  132.       procedure Free_Data (D : System.Address); 
  133.       pragma Convention (C, Free_Data); 
  134.  
  135.       function General_Cb (D : System.Address) return Gint; 
  136.       pragma Convention (C, General_Cb); 
  137.    end Quit; 
  138.    --  !!Warning!!: This package needs to be instantiated at library level 
  139.    --  since it calls some internal functions as callback. 
  140.    --  </doc_ignore> 
  141.  
  142.    ------------------- 
  143.    -- The main loop -- 
  144.    ------------------- 
  145.  
  146.    function Events_Pending return Boolean; 
  147.    --  Return True if there are some events waiting in the event queue. 
  148.  
  149.    procedure Main; 
  150.    --  Start the main loop, and returns only when the main loop is exited. 
  151.    --  This subprogram can be called recursively, to start new internal 
  152.    --  loops. Each of these loops is exited through a call to Main_Quit. 
  153.    --  This is the recommended method to use when you want to popup a dialog 
  154.    --  and wait for the user answer before going any further. 
  155.    --  Note that this procedure can only be called within a single task. 
  156.  
  157.    function Main_Level return Guint; 
  158.    --  Return the level of the current main loop. 
  159.    --  Since there can be nested loops, this returns the depth of the 
  160.    --  current one, starting from 1 (0 if there is none). 
  161.  
  162.    procedure Main_Quit; 
  163.    --  Quit the current main loop. 
  164.    --  If this was the last active main loop, no more events will be processed 
  165.    --  by GtkAda. 
  166.  
  167.    function Main_Iteration (Blocking : Boolean := True) return Boolean; 
  168.    --  Do one iteration of the main loop. 
  169.    --  Blocking indicates whether GtkAda should wait for an event to be 
  170.    --  available, or simply exit if there is none. 
  171.    --  Returns True if no main loop is running (ie Main_Quite was called for 
  172.    --  the innermost main loop). 
  173.    --  When doing some heavy calculations in an application, it is recommended 
  174.    --  that you check from time to time if there are any events pending and 
  175.    --  process them, so that your application still reacts to events. 
  176.    --  To do that, you would add a loop like: 
  177.    -- 
  178.    --    while Gtk.Main.Events_Pending loop 
  179.    --        Dead := Gtk.Main.Main_Iteration; 
  180.    --    end loop; 
  181.  
  182.    procedure Do_Event (Event : Gdk.Event.Gdk_Event); 
  183.    --  Process Event as if it was in the event queue. 
  184.    --  This function should almost never be used in your own application, this 
  185.    --  is the core function for event processing in GtkAda. 
  186.    --  The user should not free Event, this is already done by GtkAda. 
  187.    -- 
  188.    --  While you should not call this function directly, you might want to know 
  189.    --  how exactly events are handled. So here is what this function does with 
  190.    --  the event: 
  191.    --  * Compress enter/leave notify events. If the event passed build an 
  192.    --    enter/leave pair together with the next event (peeked from GDK) both 
  193.    --    events are thrown away. This is to avoid a backlog of 
  194.    --    (de-)highlighting widgets crossed by the pointer. 
  195.    -- 
  196.    --  * Find the widget which got the event. If the widget can't be determined 
  197.    --    the event is thrown away unless it belongs to a INCR transaction. In 
  198.    --    that case it is passed to gtk_selection_incr_event(). 
  199.    -- 
  200.    --  * Then the event is passed on a stack so you can query the currently 
  201.    --    handled event with gtk_get_current_event(). 
  202.    -- 
  203.    --  * The event is sent to a widget. If a grab is active all events for 
  204.    --    widgets that are not in the container in the grab widget are sent to 
  205.    --    the latter with a few exceptions: 
  206.    --       - Deletion and destruction events are still sent to the event 
  207.    --         widget for obvious reasons. 
  208.    --       - Events which directly relate to the visual representation of the 
  209.    --         event widget. 
  210.    --       - Leave events are delivered to the event widget if there was an 
  211.    --         enter event delivered to it before without the paired leave event 
  212.    --       - Drag events are not redirected because it is unclear what the 
  213.    --         semantics of that would be. 
  214.    --       - Another point of interest might be that all key events are first 
  215.    --         passed through the key snooper functions if there are any. Read 
  216.    --         the description of Key_Snooper_Install if you need this 
  217.    --         feature. 
  218.    -- 
  219.    --  * After finishing the delivery the event is popped from the event stack. 
  220.  
  221.    procedure Propagate_Event 
  222.      (Widget : access Gtk.Widget.Gtk_Widget_Record'Class; 
  223.       Event  : Gdk.Event.Gdk_Event); 
  224.    --  Sends an event to a widget, propagating the event to parent widgets 
  225.    --  if the event remains unhandled. Events received by GTK+ from GDK 
  226.    --  normally begin in Do_Event. Depending on the type of 
  227.    --  event, existence of modal dialogs, grabs, etc., the event may be 
  228.    --  propagated; if so, this function is used. Propagate_Event 
  229.    --  calls Gtk.Widget.Event on each widget it decides to send the 
  230.    --  event to.  So Gtk.Widget.Event is the lowest-level function; it 
  231.    --  simply emits the "event" and possibly an event-specific signal on a 
  232.    --  widget. Propagate_Event is a bit higher-level, and 
  233.    --  Do_Event is the highest level. 
  234.    -- 
  235.    --  All that said, you most likely don't want to use any of these 
  236.    --  functions; synthesizing events is rarely needed. Consider asking on 
  237.    --  the mailing list for better ways to achieve your goals. For 
  238.    --  example, use gdk_window_invalidate_rect() or 
  239.    --  gtk_widget_queue_draw() instead of making up expose events. 
  240.  
  241.    function Get_Event_Widget 
  242.      (Event : Gdk.Event.Gdk_Event) return Gtk.Widget.Gtk_Widget; 
  243.    --  Return the widget to which Event applies. 
  244.  
  245.    function Get_Current_Event return Gdk.Event.Gdk_Event; 
  246.    --  Return a copy of the event being processed by gtk+. The returned 
  247.    --  value must be freed by the caller. 
  248.    --  If there is no current event, null is returned. 
  249.  
  250.    procedure Get_Current_Event_State 
  251.      (State             : out Gdk.Types.Gdk_Modifier_Type; 
  252.       Had_Current_Event : out Boolean); 
  253.    --  If there is a current event and it has a state field, place 
  254.    --  that state field in State and set Had_Current_Event to True, otherwise 
  255.    --  to False. 
  256.  
  257.    function Get_Current_Event_Time return Guint32; 
  258.    --  If there is a current event and it has a timestamp, return that 
  259.    --  timestamp, otherwise return Gdk.Types.Current_Time 
  260.  
  261.    ---------- 
  262.    -- Keys -- 
  263.    ---------- 
  264.  
  265.    type Key_Snooper_Func is 
  266.      access function (Widget : System.Address; 
  267.                       Event  : Gdk.Event.Gdk_Event_Key; 
  268.                       Data   : System.Address) return Gboolean; 
  269.    pragma Convention (C, Key_Snooper_Func); 
  270.    --  This function is called before normal event delivery, and can be used to 
  271.    --  implement custom key event handling (for instance to create macros, or 
  272.    --  any other advanced feature). 
  273.    --  Since this is a fairly low-level function, no high-level interface is 
  274.    --  provided, and you need to convert Widget yourself to the appropriate 
  275.    --  Gtk_Widget type, with, for instance: 
  276.    --      Ada_Widget := Gtk.Widget.Convert (Widget); 
  277.    --  This function should return True to stop further event processing by 
  278.    --  gtk+ (ie no widget will receive it), or False to continue with normal 
  279.    --  event processing (for instance when you have handled the key). 
  280.  
  281.    type Key_Snooper_Id is new Guint; 
  282.  
  283.    function Key_Snooper_Install 
  284.      (Snooper   : Key_Snooper_Func; 
  285.       Func_Data : System.Address) return Key_Snooper_Id; 
  286.    --  Install a new key snooper function, which will get called before events 
  287.    --  are delivered normally. 
  288.  
  289.    procedure Key_Snooper_Remove 
  290.      (Snooper_Handler_Id : Key_Snooper_Id); 
  291.    --  Remove the snooper with the given Id 
  292.  
  293.    -------------------- 
  294.    -- Grab functions -- 
  295.    -------------------- 
  296.  
  297.    procedure Grab_Add (Widget : access Gtk.Widget.Gtk_Widget_Record'Class); 
  298.    --  Add a new widget to the grab list. 
  299.    --  The widget at the front of this list gets all the events even if it does 
  300.    --  not have the focus. This feature should be used with care. 
  301.    --  If you want a whole window to get the events, it is better to use 
  302.    --  Gtk.Window.Set_Modal instead which does the grabbing and ungrabbing for 
  303.    --  you. 
  304.    --  The grab is only done for the application. Events outside the 
  305.    --  application are still sent to their respective windows. 
  306.    -- 
  307.    --  See also Gtk.Window.Gtk_Window_Group 
  308.  
  309.    procedure Grab_Remove (Widget : access Gtk.Widget.Gtk_Widget_Record'Class); 
  310.    --  Remove a widget from the grab list. 
  311.  
  312.    function Grab_Get_Current return Gtk.Widget.Gtk_Widget; 
  313.    --  Return the widget that currently has the focus. 
  314.  
  315.    ----------------- 
  316.    -- Obsolescent -- 
  317.    ----------------- 
  318.    --  All subprograms below are now obsolescent in gtk+. They might be removed 
  319.    --  from future versions of gtk+ (and therefore GtkAda). 
  320.    --  To find out whether your code uses any of these, we recommend compiling 
  321.    --  with the -gnatwj switch 
  322.    --  <doc_ignore> 
  323.  
  324.    procedure Gtk_Exit (Error_Code : Gint); 
  325.    pragma Obsolescent (Gtk_Exit); 
  326.    --  Terminate GtkAda. 
  327.    --  Deprecated, use Main_Quit instead. 
  328.  
  329.    type Idle_Handler_Id is new Guint; 
  330.    --  pragma Obsolescent (Entity => Idle_Handler_Id); 
  331.    --  Id for Idle handlers. 
  332.  
  333.    type Idle_Priority   is new Guint; 
  334.    --  pragma Obsolescent (Entity => Idle_Priority); 
  335.    --  Priorities that can be set for idle handlers. 
  336.    --  The higher the priority, the less urgent the task. Handlers whose 
  337.    --  priority is lower will be called before others. 
  338.  
  339.    Priority_High_Idle    : constant Idle_Priority := 100; 
  340.    Priority_Default_Idle : constant Idle_Priority := 200; 
  341.    Priority_Low_Idle     : constant Idle_Priority := 300; 
  342.  
  343.    type Idle_Callback is access function return Boolean; 
  344.    --  pragma Obsolescent (Entity => Idle_Callback); 
  345.    --  Function that can be called automatically whenever GtkAda is not 
  346.    --  processing events. 
  347.    --  It should return True if the function should be called again as soon 
  348.    --  as possible, False if it should be unregistered. 
  349.  
  350.    function Idle_Add 
  351.      (Cb       : Idle_Callback; 
  352.       Priority : Idle_Priority := Priority_Default_Idle) 
  353.       return Idle_Handler_Id; 
  354.    pragma Obsolescent (Idle_Add, "Use Glib.Main.Idle_Add");  --  Idle_Add_Full 
  355.    --  Register an idle callback with no user data. 
  356.  
  357.    generic 
  358.       type Data_Type (<>) is private; 
  359.    package Idle is 
  360.       type Callback is access function (D : Data_Type) return Boolean; 
  361.       type Destroy_Callback is access procedure (D : in out Data_Type); 
  362.  
  363.       function Add 
  364.         (Cb       : Callback; 
  365.          D        : Data_Type; 
  366.          Priority : Idle_Priority := Priority_Default_Idle; 
  367.          Destroy  : Destroy_Callback := null) 
  368.          return Idle_Handler_Id; 
  369.       pragma Obsolescent (Add, "Use Glib.Main.Idle"); 
  370.  
  371.    private 
  372.       procedure Free_Data (D : System.Address); 
  373.       pragma Convention (C, Free_Data); 
  374.  
  375.       function General_Cb (D : System.Address) return Gint; 
  376.       pragma Convention (C, General_Cb); 
  377.    end Idle; 
  378.    --  Destroy will be called automatically just prior to the destruction of D. 
  379.    --  In particular, it is also called if the idle is destroyed through a call 
  380.    --  to Idle_Remove. 
  381.  
  382.    procedure Idle_Remove (Id : Idle_Handler_Id); 
  383.    pragma Obsolescent (Idle_Remove, "Use Glib.Main.Idle_Remove"); 
  384.    --  Remove an idle callback, when its Id is known. 
  385.  
  386.    type Timeout_Handler_Id is new Guint; 
  387.    --  pragma Obsolescent (Entity => Timeout_Handle_Id); 
  388.    --  Id for Timeout handlers. 
  389.  
  390.    type Timeout_Callback is access function return Boolean; 
  391.    --  pragma Obsolescent (Entity => Timeout_Callback); 
  392.    --  Function that can be called automatically at precise time intervals. 
  393.    --  It should return True if the function should be called again as soon 
  394.    --  as possible, False if it should be unregistered. 
  395.  
  396.    function Timeout_Add 
  397.      (Interval : Guint32; 
  398.       Func : Timeout_Callback) return Timeout_Handler_Id; 
  399.    pragma Obsolescent (Timeout_Add, "Use Glib.Main.Timeout_Add"); 
  400.    --  Add a new timeout. Func will be called after Interval milliseconds. 
  401.    --  The function will be called as long as it returns True. 
  402.  
  403.    generic 
  404.       type Data_Type (<>) is private; 
  405.    package Timeout is 
  406.       type Callback is access function (D : Data_Type) return Boolean; 
  407.       type Destroy_Callback is access procedure (D : in out Data_Type); 
  408.  
  409.       function Add 
  410.         (Interval : Guint32; 
  411.          Func     : Callback; 
  412.          D        : Data_Type; 
  413.          Destroy  : Destroy_Callback := null) return Timeout_Handler_Id; 
  414.       pragma Obsolescent (Add, "Use Glib.Main.Timeout"); 
  415.       --  Adds a new timeout. Func will be called after Interval milliseconds. 
  416.  
  417.    private 
  418.       procedure Free_Data (D : System.Address); 
  419.       pragma Convention (C, Free_Data); 
  420.  
  421.       function General_Cb (D : System.Address) return Gint; 
  422.       pragma Convention (C, General_Cb); 
  423.    end Timeout; 
  424.  
  425.    procedure Timeout_Remove (Id : Timeout_Handler_Id); 
  426.    pragma Obsolescent (Timeout_Remove, "Use Glib.Main.Timeout_Remove"); 
  427.    --  Unregister a timeout function. 
  428.  
  429.    function Set_Locale return String; 
  430.    pragma Obsolescent (Set_Locale); 
  431.    --  Read and parse the local settings, such as time format, ... 
  432.    --  Return the name of the local settings, which can also be set with 
  433.    --  the environment variable LOCALE 
  434.  
  435.    procedure Set_Locale; 
  436.    pragma Obsolescent (Set_Locale); 
  437.    --  Read and parse the local settings, such as time format, ... 
  438.  
  439.    procedure Init_Add (Func : Init_Function; Data : System.Address); 
  440.    pragma Obsolescent (Init_Add); 
  441.    --  Register a function to be called just before starting a main loop. 
  442.    --  This function is called only once, even if a new main loop is started 
  443.    --  recursively. 
  444.  
  445.    function Quit_Add 
  446.      (Main_Level : Guint; Func : Quit_Function) return Quit_Handler_Id; 
  447.    pragma Obsolescent (Quit_Add); 
  448.    --  Register a new function to be called when the current main loop exits. 
  449.    --  The function will be called once when the current main loop exists. 
  450.    --  If it returns False, it will then be deleted from the list of 
  451.    --  quit functions, and won't be called again next time a main loop is 
  452.    --  exited. 
  453.    --  The function will only be called when exiting a main loop at level 
  454.    --  Main_Level. If Main_Level is 0, the function will be called for the 
  455.    --  current main_loop. 
  456.  
  457.    function Quit_Add_Destroy 
  458.      (Main_Level : Guint; 
  459.       Object     : access Gtk.Object.Gtk_Object_Record'Class) 
  460.       return Quit_Handler_Id; 
  461.    pragma Obsolescent (Quit_Add_Destroy); 
  462.    --  Ensure that Object is destroyed when exiting the main loop at Main_Level 
  463.    --  (or the current main loop level is 0). 
  464.  
  465.    procedure Quit_Remove (Id : Quit_Handler_Id); 
  466.    pragma Obsolescent (Quit_Remove); 
  467.    --  Remove a Quit Handler, that has been previously set by Quit_Add. 
  468.  
  469.    --  </doc_ignore> 
  470.  
  471. private 
  472.    pragma Import (C, Gtk_Exit, "gtk_exit"); 
  473.    pragma Import (C, Main_Level, "gtk_main_level"); 
  474.    pragma Import (C, Main_Quit, "gtk_main_quit"); 
  475.    pragma Import (C, Main, "gtk_main"); 
  476.    pragma Import (C, Idle_Remove, "gtk_idle_remove"); 
  477.    pragma Import (C, Timeout_Remove, "gtk_timeout_remove"); 
  478.    pragma Import (C, Init_Add, "gtk_init_add"); 
  479.    pragma Import (C, Quit_Remove, "gtk_quit_remove"); 
  480.    pragma Import (C, Get_Current_Event, "gtk_get_current_event"); 
  481.    pragma Import (C, Disable_Setlocale, "gtk_disable_setlocale"); 
  482.    pragma Import (C, Get_Current_Event_Time, "gtk_get_current_event_time"); 
  483.    pragma Import (C, Get_Default_Language, "gtk_get_default_language"); 
  484.    pragma Import (C, Key_Snooper_Remove, "gtk_key_snooper_remove"); 
  485.    pragma Import (C, Key_Snooper_Install, "gtk_key_snooper_install"); 
  486.  
  487.    --  The following two subprograms are specific to Win32 
  488.    --  No binding: gtk_init_abi_check 
  489.    --  No binding: gtk_init_check_abi_check 
  490.  
  491.    --  No binding: gtk_get_option_group 
  492.    --  No binding: gtk_init_with_args 
  493.    --  No binding: gtk_parse_args 
  494.    --  No binding: gtk_main_iteration 
  495.  
  496.    --  These functions are not bound, we only use gtk_idle_add_full 
  497.    --  No binding: gtk_idle_add 
  498.    --  No binding: gtk_idle_add_priority 
  499.    --  No binding: gtk_idle_remove_by_data 
  500.    --  No binding: gtk_timeout_add 
  501.  
  502.    --  This function are not bound, we only use gtk_quit_add_full 
  503.    --  No binding: gtk_quit_add 
  504.    --  No binding: gtk_quit_remove_by_data 
  505.  
  506.    --  These functions are intended as callbacks, but do not apply to GtkAda 
  507.    --  No binding: gtk_true 
  508.    --  No binding: gtk_false 
  509.  
  510.    --  These functions were never bound, and are now obsolesent anyway 
  511.    --  No binding: gtk_input_add_full 
  512.    --  No binding: gtk_input_remove 
  513.  
  514. end Gtk.Main;