1. ------------------------------------------------------------------------------ 
  2. --                                                                          -- 
  3. --      Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet       -- 
  4. --                     Copyright (C) 2000-2014, AdaCore                     -- 
  5. --                                                                          -- 
  6. -- This library is free software;  you can redistribute it and/or modify it -- 
  7. -- under terms of the  GNU General Public License  as published by the Free -- 
  8. -- Software  Foundation;  either version 3,  or (at your  option) any later -- 
  9. -- version. This library is distributed in the hope that it will be useful, -- 
  10. -- but WITHOUT ANY WARRANTY;  without even the implied warranty of MERCHAN- -- 
  11. -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE.                            -- 
  12. --                                                                          -- 
  13. -- As a special exception under Section 7 of GPL version 3, you are granted -- 
  14. -- additional permissions described in the GCC Runtime Library Exception,   -- 
  15. -- version 3.1, as published by the Free Software Foundation.               -- 
  16. --                                                                          -- 
  17. -- You should have received a copy of the GNU General Public License and    -- 
  18. -- a copy of the GCC Runtime Library Exception along with this program;     -- 
  19. -- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    -- 
  20. -- <http://www.gnu.org/licenses/>.                                          -- 
  21. --                                                                          -- 
  22. ------------------------------------------------------------------------------ 
  23.  
  24. --  <description> 
  25. --  GtkWidget is the base class all widgets in GTK+ derive from. It manages 
  26. --  the widget lifecycle, states and style. 
  27. -- 
  28. --  == Height-for-width Geometry Management == 
  29. -- 
  30. --  GTK+ uses a height-for-width (and width-for-height) geometry management 
  31. --  system. Height-for-width means that a widget can change how much vertical 
  32. --  space it needs, depending on the amount of horizontal space that it is 
  33. --  given (and similar for width-for-height). The most common example is a 
  34. --  label that reflows to fill up the available width, wraps to fewer lines, 
  35. --  and therefore needs less height. 
  36. -- 
  37. --  Height-for-width geometry management is implemented in GTK+ by way of five 
  38. --  virtual methods: 
  39. -- 
  40. --  
  41. -- 
  42. --     * Gtk.Widget.GObject_Class.get_request_mode 
  43. -- 
  44. --     * Gtk.Widget.GObject_Class.get_preferred_width 
  45. -- 
  46. --     * Gtk.Widget.GObject_Class.get_preferred_height 
  47. -- 
  48. --     * Gtk.Widget.GObject_Class.get_preferred_height_for_width 
  49. -- 
  50. --     * Gtk.Widget.GObject_Class.get_preferred_width_for_height 
  51. -- 
  52. --  There are some important things to keep in mind when implementing 
  53. --  height-for-width and when using it in container implementations. 
  54. -- 
  55. --  The geometry management system will query a widget hierarchy in only one 
  56. --  orientation at a time. When widgets are initially queried for their minimum 
  57. --  sizes it is generally done in two initial passes in the 
  58. --  Gtk.Enums.Gtk_Size_Request_Mode chosen by the toplevel. 
  59. -- 
  60. --  For example, when queried in the normal Gtk.Enums.Height_For_Width mode: 
  61. --  First, the default minimum and natural width for each widget in the 
  62. --  interface will be computed using Gtk.Widget.Get_Preferred_Width. Because 
  63. --  the preferred widths for each container depend on the preferred widths of 
  64. --  their children, this information propagates up the hierarchy, and finally a 
  65. --  minimum and natural width is determined for the entire toplevel. Next, the 
  66. --  toplevel will use the minimum width to query for the minimum height 
  67. --  contextual to that width using Gtk.Widget.Get_Preferred_Height_For_Width, 
  68. --  which will also be a highly recursive operation. The minimum height for the 
  69. --  minimum width is normally used to set the minimum size constraint on the 
  70. --  toplevel (unless Gtk.Window.Set_Geometry_Hints is explicitly used instead). 
  71. -- 
  72. --  After the toplevel window has initially requested its size in both 
  73. --  dimensions it can go on to allocate itself a reasonable size (or a size 
  74. --  previously specified with Gtk.Window.Set_Default_Size). During the 
  75. --  recursive allocation process it's important to note that request cycles 
  76. --  will be recursively executed while container widgets allocate their 
  77. --  children. Each container widget, once allocated a size, will go on to first 
  78. --  share the space in one orientation among its children and then request each 
  79. --  child's height for its target allocated width or its width for allocated 
  80. --  height, depending. In this way a Gtk.Widget.Gtk_Widget will typically be 
  81. --  requested its size a number of times before actually being allocated a 
  82. --  size. The size a widget is finally allocated can of course differ from the 
  83. --  size it has requested. For this reason, Gtk.Widget.Gtk_Widget caches a 
  84. --  small number of results to avoid re-querying for the same sizes in one 
  85. --  allocation cycle. 
  86. -- 
  87. --  See <link linkend="container-geometry-management">GtkContainer's geometry 
  88. --  management section</link> to learn more about how height-for-width 
  89. --  allocations are performed by container widgets. 
  90. -- 
  91. --  If a widget does move content around to intelligently use up the allocated 
  92. --  size then it must support the request in both Gtk_Size_Request_Modes even 
  93. --  if the widget in question only trades sizes in a single orientation. 
  94. -- 
  95. --  For instance, a Gtk.Label.Gtk_Label that does height-for-width word 
  96. --  wrapping will not expect to have 
  97. --  Gtk.Widget.GObject_Class.get_preferred_height called because that call is 
  98. --  specific to a width-for-height request. In this case the label must return 
  99. --  the height required for its own minimum possible width. By following this 
  100. --  rule any widget that handles height-for-width or width-for-height requests 
  101. --  will always be allocated at least enough space to fit its own content. 
  102. -- 
  103. --  Here are some examples of how a Gtk.Enums.Height_For_Width widget 
  104. --  generally deals with width-for-height requests, for 
  105. --  Gtk.Widget.GObject_Class.get_preferred_height it will do: 
  106. -- 
  107. --    static void 
  108. --    foo_widget_get_preferred_height (GtkWidget *widget, gint *min_height, gint *nat_height) 
  109. --    { 
  110. --       if (i_am_in_height_for_width_mode) 
  111. --       { 
  112. --          gint min_width; 
  113. --          GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, &min_width, NULL); 
  114. --          GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width (widget, min_width, 
  115. --             min_height, nat_height); 
  116. --       } 
  117. --    else 
  118. --       { 
  119. --          ... some widgets do both. For instance, if a GtkLabel is rotated to 90 degrees 
  120. --          it will return the minimum and natural height for the rotated label here. 
  121. --       } 
  122. --    } 
  123. -- 
  124. --  And in Gtk.Widget.GObject_Class.get_preferred_width_for_height it will 
  125. --  simply return the minimum and natural width: 
  126. -- 
  127. --    static void 
  128. --    foo_widget_get_preferred_width_for_height (GtkWidget *widget, gint for_height, 
  129. --       gint *min_width, gint *nat_width) 
  130. --    { 
  131. --       if (i_am_in_height_for_width_mode) 
  132. --       { 
  133. --          GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, min_width, nat_width); 
  134. --       } 
  135. --    else 
  136. --       { 
  137. --          ... again if a widget is sometimes operating in width-for-height mode 
  138. --            (like a rotated GtkLabel) it can go ahead and do its real width for 
  139. --          height calculation here. 
  140. --       } 
  141. --    } 
  142. -- 
  143. --  Often a widget needs to get its own request during size request or 
  144. --  allocation. For example, when computing height it may need to also compute 
  145. --  width. Or when deciding how to use an allocation, the widget may need to 
  146. --  know its natural size. In these cases, the widget should be careful to call 
  147. --  its virtual methods directly, like this: 
  148. -- 
  149. --  
  150. -- 
  151. --  == Widget calling its own size request method. == 
  152. -- 
  153. --  
  154. -- 
  155. --    GTK_WIDGET_GET_CLASS(widget)->get_preferred_width (widget), 
  156. --    &min, &natural); 
  157. -- 
  158. --  It will not work to use the wrapper functions, such as 
  159. --  Gtk.Widget.Get_Preferred_Width inside your own size request implementation. 
  160. --  These return a request adjusted by Gtk.Size_Group.Gtk_Size_Group and by the 
  161. --  Gtk.Widget.GObject_Class.adjust_size_request virtual method. If a widget 
  162. --  used the wrappers inside its virtual method implementations, then the 
  163. --  adjustments (such as widget margins) would be applied twice. GTK+ therefore 
  164. --  does not allow this and will warn if you try to do it. 
  165. -- 
  166. --  Of course if you are getting the size request for *another* widget, such 
  167. --  as a child of a container, you *must* use the wrapper APIs. Otherwise, you 
  168. --  would not properly consider widget margins, Gtk.Size_Group.Gtk_Size_Group, 
  169. --  and so forth. 
  170. -- 
  171. --  == Style Properties == 
  172. -- 
  173. --  <structname>GtkWidget</structname> introduces 'style properties' - these 
  174. --  are basically object properties that are stored not on the object, but in 
  175. --  the style object associated to the widget. Style properties are set in 
  176. --  <link linkend="gtk-Resource-Files">resource files</link>. This mechanism is 
  177. --  used for configuring such things as the location of the scrollbar arrows 
  178. --  through the theme, giving theme authors more control over the look of 
  179. --  applications without the need to write a theme engine in C. 
  180. --  Use Gtk.Widget.Install_Style_Property to install style properties for a 
  181. --  widget class, Gtk.Widget.Find_Style_Property or 
  182. --  gtk_widget_class_list_style_properties to get information about existing 
  183. --  style properties and Gtk.Widget.Style_Get_Property, gtk_widget_style_get or 
  184. --  gtk_widget_style_get_valist to obtain the value of a style property. 
  185. -- 
  186. --  == GtkWidget as GtkBuildable == 
  187. -- 
  188. --  The GtkWidget implementation of the GtkBuildable interface supports a 
  189. --  custom <accelerator> element, which has attributes named key, modifiers and 
  190. --  signal and allows to specify accelerators. 
  191. -- 
  192. --  == A UI definition fragment specifying an accelerator == 
  193. -- 
  194. --    <object class="GtkButton"> 
  195. --    <accelerator key="q" modifiers="GDK_CONTROL_MASK" signal="clicked"/> 
  196. --    </object> 
  197. --  In addition to accelerators, <structname>GtkWidget</structname> also 
  198. --  support a custom <accessible> element, which supports actions and 
  199. --  relations. Properties on the accessible implementation of an object can be 
  200. --  set by accessing the internal child "accessible" of a 
  201. --  <structname>GtkWidget</structname>. 
  202. -- 
  203. --  == A UI definition fragment specifying an accessible == 
  204. -- 
  205. --    <object class="GtkButton" id="label1"/> 
  206. --    <property name="label">I am a Label for a Button</property> 
  207. --    </object> 
  208. --    <object class="GtkButton" id="button1"> 
  209. --    <accessibility> 
  210. --    <action action_name="click" translatable="yes">Click the button.</action> 
  211. --    <relation target="label1" type="labelled-by"/> 
  212. --    </accessibility> 
  213. --    <child internal-child="accessible"> 
  214. --    <object class="AtkObject" id="a11y-button1"> 
  215. --    <property name="accessible-name">Clickable Button</property> 
  216. --    </object> 
  217. --    </child> 
  218. --    </object> 
  219. --  Finally, GtkWidget allows style information such as style classes to be 
  220. --  associated with widgets, using the custom <style> element: 
  221. -- 
  222. --  == A UI definition fragment specifying an style class == 
  223. -- 
  224. --    <object class="GtkButton" id="button1"> 
  225. --    <style> 
  226. --    <class name="my-special-button-class"/> 
  227. --    <class name="dark-button"/> 
  228. --    </style> 
  229. --    </object> 
  230. --  </description> 
  231. pragma Ada_2005; 
  232.  
  233. pragma Warnings (Off, "*is already use-visible*"); 
  234. with Cairo;                   use Cairo; 
  235. with Cairo.Region;            use Cairo.Region; 
  236. with Gdk;                     use Gdk; 
  237. with Gdk.Color;               use Gdk.Color; 
  238. with Gdk.Device;              use Gdk.Device; 
  239. with Gdk.Display;             use Gdk.Display; 
  240. with Gdk.Drag_Contexts;       use Gdk.Drag_Contexts; 
  241. with Gdk.Event;               use Gdk.Event; 
  242. with Gdk.Frame_Clock;         use Gdk.Frame_Clock; 
  243. with Gdk.Pixbuf;              use Gdk.Pixbuf; 
  244. with Gdk.RGBA;                use Gdk.RGBA; 
  245. with Gdk.Rectangle;           use Gdk.Rectangle; 
  246. with Gdk.Screen;              use Gdk.Screen; 
  247. with Gdk.Types;               use Gdk.Types; 
  248. with Gdk.Visual;              use Gdk.Visual; 
  249. with Glib;                    use Glib; 
  250. with Glib.GSlist;             use Glib.GSlist; 
  251. with Glib.Generic_Properties; use Glib.Generic_Properties; 
  252. with Glib.Glist;              use Glib.Glist; 
  253. with Glib.Object;             use Glib.Object; 
  254. with Glib.Properties;         use Glib.Properties; 
  255. with Glib.Values;             use Glib.Values; 
  256. with Gtk.Accel_Group;         use Gtk.Accel_Group; 
  257. with Gtk.Enums;               use Gtk.Enums; 
  258. with Gtk.Selection_Data;      use Gtk.Selection_Data; 
  259. with Gtk.Style;               use Gtk.Style; 
  260. with Pango.Context;           use Pango.Context; 
  261. with Pango.Font;              use Pango.Font; 
  262. with Pango.Layout;            use Pango.Layout; 
  263.  
  264. package Gtk.Widget is 
  265.  
  266.    type Gtk_Widget_Record is new GObject_Record with null record; 
  267.    type Gtk_Widget is access all Gtk_Widget_Record'Class; 
  268.  
  269.    type Gtk_Align is ( 
  270.       Align_Fill, 
  271.       Align_Start, 
  272.       Align_End, 
  273.       Align_Center); 
  274.    pragma Convention (C, Gtk_Align); 
  275.    --  Controls how a widget deals with extra space in a single (x or y) 
  276.    --  dimension. 
  277.    -- 
  278.    --  Alignment only matters if the widget receives a "too large" allocation, 
  279.    --  for example if you packed the widget with the 
  280.    --  Gtk.Widget.Gtk_Widget:expand flag inside a Gtk.Box.Gtk_Box, then the 
  281.    --  widget might get extra space. If you have for example a 16x16 icon 
  282.    --  inside a 32x32 space, the icon could be scaled and stretched, it could 
  283.    --  be centered, or it could be positioned to one side of the space. 
  284.    -- 
  285.    --  Note that in horizontal context Gtk_Align_Start and Gtk_Align_End are 
  286.    --  interpreted relative to text direction. 
  287.  
  288.    type Gtk_Widget_Help_Type is ( 
  289.       Widget_Help_Tooltip, 
  290.       Widget_Help_Whats_This); 
  291.    pragma Convention (C, Gtk_Widget_Help_Type); 
  292.  
  293.  
  294.    type Gtk_Requisition is record 
  295.       Width : Gint; 
  296.       Height : Gint; 
  297.    end record; 
  298.    pragma Convention (C, Gtk_Requisition); 
  299.  
  300.    function From_Object_Free (B : access Gtk_Requisition) return Gtk_Requisition; 
  301.    pragma Inline (From_Object_Free); 
  302.    --  A <structname>GtkRequisition</structname> represents the desired size 
  303.    --  of a widget. See <xref linkend="geometry-management"/> for more 
  304.    --  information. 
  305.  
  306.    type Gtk_Widget_Path is new Glib.C_Proxy; 
  307.    function From_Object_Free (B : access Gtk_Widget_Path) return Gtk_Widget_Path; 
  308.    pragma Inline (From_Object_Free); 
  309.    --  GtkWidgetPath is a boxed type that represents a widget hierarchy from 
  310.    --  the topmost widget, typically a toplevel, to any child. This widget path 
  311.    --  abstraction is used in Gtk.Style_Context.Gtk_Style_Context on behalf of 
  312.    --  the real widget in order to query style information. 
  313.    -- 
  314.    --  If you are using GTK+ widgets, you probably will not need to use this 
  315.    --  API directly, as there is Gtk.Widget.Get_Path, and the style context 
  316.    --  returned by gtk_widget_get_style_context will be automatically updated 
  317.    --  on widget hierarchy changes. 
  318.    -- 
  319.    --  The widget path generation is generally simple: 
  320.    -- 
  321.    --  == Defining a button within a window == 
  322.    -- 
  323.    --    { 
  324.    --       GtkWidgetPath *path; 
  325.    --       path = gtk_widget_path_new (); 
  326.    --       gtk_widget_path_append_type (path, GTK_TYPE_WINDOW); 
  327.    --       gtk_widget_path_append_type (path, GTK_TYPE_BUTTON); 
  328.    --    } 
  329.    -- 
  330.    --  Although more complex information, such as widget names, or different 
  331.    --  classes (property that may be used by other widget types) and 
  332.    --  intermediate regions may be included: 
  333.    -- 
  334.    --  == Defining the first tab widget in a notebook == 
  335.    -- 
  336.    --    { 
  337.    --       GtkWidgetPath *path; 
  338.    --       guint pos; 
  339.    --       path = gtk_widget_path_new (); 
  340.    --       pos = gtk_widget_path_append_type (path, GTK_TYPE_NOTEBOOK); 
  341.    --       gtk_widget_path_iter_add_region (path, pos, "tab", GTK_REGION_EVEN | GTK_REGION_FIRST); 
  342.    --       pos = gtk_widget_path_append_type (path, GTK_TYPE_LABEL); 
  343.    --       gtk_widget_path_iter_set_name (path, pos, "first tab label"); 
  344.    --    } 
  345.    -- 
  346.    --  All this information will be used to match the style information that 
  347.    --  applies to the described widget. 
  348.  
  349.    function Convert (R : Gtk.Widget.Gtk_Widget) return System.Address; 
  350.    function Convert (R : System.Address) return Gtk.Widget.Gtk_Widget; 
  351.    package Widget_List is new Generic_List (Gtk.Widget.Gtk_Widget); 
  352.  
  353.    package Widget_SList is new Generic_SList (Gtk.Widget.Gtk_Widget); 
  354.  
  355.    subtype Gtk_Allocation is Gdk.Rectangle.Gdk_Rectangle; 
  356.  
  357.    --------------- 
  358.    -- Callbacks -- 
  359.    --------------- 
  360.  
  361.    type Gtk_Tick_Callback is access function 
  362.      (Widget      : not null access Gtk_Widget_Record'Class; 
  363.       Frame_Clock : not null access Gdk.Frame_Clock.Gdk_Frame_Clock_Record'Class) 
  364.    return Boolean; 
  365.    --  Callback type for adding a function to update animations. See 
  366.    --  Gtk.Widget.Add_Tick_Callback. 
  367.    --  Since: gtk+ 3.8 
  368.    --  "widget": the widget 
  369.    --  "frame_clock": the frame clock for the widget (same as calling 
  370.    --  gtk_widget_get_frame_clock) 
  371.  
  372.    ---------------------------- 
  373.    -- Enumeration Properties -- 
  374.    ---------------------------- 
  375.  
  376.    package Gtk_Align_Properties is 
  377.       new Generic_Internal_Discrete_Property (Gtk_Align); 
  378.    type Property_Gtk_Align is new Gtk_Align_Properties.Property; 
  379.  
  380.    package Gtk_Widget_Help_Type_Properties is 
  381.       new Generic_Internal_Discrete_Property (Gtk_Widget_Help_Type); 
  382.    type Property_Gtk_Widget_Help_Type is new Gtk_Widget_Help_Type_Properties.Property; 
  383.  
  384.    ------------------ 
  385.    -- Constructors -- 
  386.    ------------------ 
  387.  
  388.    function Get_Type return Glib.GType; 
  389.    pragma Import (C, Get_Type, "gtk_widget_get_type"); 
  390.  
  391.    ------------- 
  392.    -- Methods -- 
  393.    ------------- 
  394.  
  395.    function Activate 
  396.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  397.    --  For widgets that can be "activated" (buttons, menu items, etc.) this 
  398.    --  function activates them. Activation is what happens when you press Enter 
  399.    --  on a widget during key navigation. If Widget isn't activatable, the 
  400.    --  function returns False. 
  401.  
  402.    procedure Add_Accelerator 
  403.       (Widget       : not null access Gtk_Widget_Record; 
  404.        Accel_Signal : UTF8_String; 
  405.        Accel_Group  : not null access Gtk.Accel_Group.Gtk_Accel_Group_Record'Class; 
  406.        Accel_Key    : Gdk.Types.Gdk_Key_Type; 
  407.        Accel_Mods   : Gdk.Types.Gdk_Modifier_Type; 
  408.        Accel_Flags  : Gtk.Accel_Group.Gtk_Accel_Flags); 
  409.    --  Installs an accelerator for this Widget in Accel_Group that causes 
  410.    --  Accel_Signal to be emitted if the accelerator is activated. The 
  411.    --  Accel_Group needs to be added to the widget's toplevel via 
  412.    --  Gtk.Window.Add_Accel_Group, and the signal must be of type 
  413.    --  G_SIGNAL_ACTION. Accelerators added through this function are not user 
  414.    --  changeable during runtime. If you want to support accelerators that can 
  415.    --  be changed by the user, use Gtk.Accel_Map.Add_Entry and 
  416.    --  Gtk.Widget.Set_Accel_Path or Gtk.Menu_Item.Set_Accel_Path instead. 
  417.    --  "accel_signal": widget signal to emit on accelerator activation 
  418.    --  "accel_group": accel group for this widget, added to its toplevel 
  419.    --  "accel_key": GDK keyval of the accelerator 
  420.    --  "accel_mods": modifier key combination of the accelerator 
  421.    --  "accel_flags": flag accelerators, e.g. Gtk.Target_List.Accel_Visible 
  422.  
  423.    procedure Add_Device_Events 
  424.       (Widget : not null access Gtk_Widget_Record; 
  425.        Device : not null access Gdk.Device.Gdk_Device_Record'Class; 
  426.        Events : Gdk.Event.Gdk_Event_Mask); 
  427.    --  Adds the device events in the bitfield Events to the event mask for 
  428.    --  Widget. See Gtk.Widget.Set_Device_Events for details. 
  429.    --  Since: gtk+ 3.0 
  430.    --  "device": a Gdk.Device.Gdk_Device 
  431.    --  "events": an event mask, see Gdk.Event.Gdk_Event_Mask 
  432.  
  433.    procedure Add_Events 
  434.       (Widget : not null access Gtk_Widget_Record; 
  435.        Events : Gdk.Event.Gdk_Event_Mask); 
  436.    --  Adds the events in the bitfield Events to the event mask for Widget. 
  437.    --  See Gtk.Widget.Set_Events for details. 
  438.    --  "events": an event mask, see Gdk.Event.Gdk_Event_Mask 
  439.  
  440.    procedure Add_Mnemonic_Label 
  441.       (Widget : not null access Gtk_Widget_Record; 
  442.        Label  : not null access Gtk_Widget_Record'Class); 
  443.    --  Adds a widget to the list of mnemonic labels for this widget. (See 
  444.    --  Gtk.Widget.List_Mnemonic_Labels). Note the list of mnemonic labels for 
  445.    --  the widget is cleared when the widget is destroyed, so the caller must 
  446.    --  make sure to update its internal state at this point as well, by using a 
  447.    --  connection to the Gtk.Widget.Gtk_Widget::destroy signal or a weak 
  448.    --  notifier. 
  449.    --  Since: gtk+ 2.4 
  450.    --  "label": a Gtk.Widget.Gtk_Widget that acts as a mnemonic label for 
  451.    --  Widget 
  452.  
  453.    function Add_Tick_Callback 
  454.       (Widget   : not null access Gtk_Widget_Record; 
  455.        Callback : Gtk_Tick_Callback; 
  456.        Notify   : Glib.G_Destroy_Notify_Address) return Guint; 
  457.    --  Queues a animation frame update and adds a callback to be called before 
  458.    --  each frame. Until the tick callback is removed, it will be called 
  459.    --  frequently (usually at the frame rate of the output device or as quickly 
  460.    --  as the application an be repainted, whichever is slower). For this 
  461.    --  reason, is most suitable for handling graphics that change every frame 
  462.    --  or every few frames. The tick callback does not automatically imply a 
  463.    --  relayout or repaint. If you want a repaint or relayout, and aren't 
  464.    --  changing widget properties that would trigger that (for example, 
  465.    --  changing the text of a Gtk.Label.Gtk_Label), then you will have to call 
  466.    --  Gtk.Widget.Queue_Resize or Gtk.Widget.Queue_Draw_Area yourself. 
  467.    --  Gdk.Frame_Clock.Get_Frame_Time should generally be used for timing 
  468.    --  continuous animations and 
  469.    --  Gdk.Frame_Timings.Get_Predicted_Presentation_Time if you are trying to 
  470.    --  display isolated frames at particular times. 
  471.    --  This is a more convenient alternative to connecting directly to the 
  472.    --  Gdk.Frame_Clock.Gdk_Frame_Clock::update signal of 
  473.    --  Gdk.Frame_Clock.Gdk_Frame_Clock, since you don't have to worry about 
  474.    --  when a Gdk.Frame_Clock.Gdk_Frame_Clock is assigned to a widget. 
  475.    --  Since: gtk+ 3.8 
  476.    --  "callback": function to call for updating animations 
  477.    --  "notify": function to call to free User_Data when the callback is 
  478.    --  removed. 
  479.  
  480.    generic 
  481.       type User_Data_Type (<>) is private; 
  482.       with procedure Destroy (Data : in out User_Data_Type) is null; 
  483.    package Add_Tick_Callback_User_Data is 
  484.  
  485.       type Gtk_Tick_Callback is access function 
  486.         (Widget      : not null access Gtk.Widget.Gtk_Widget_Record'Class; 
  487.          Frame_Clock : not null access Gdk.Frame_Clock.Gdk_Frame_Clock_Record'Class; 
  488.          User_Data   : User_Data_Type) return Boolean; 
  489.       --  Callback type for adding a function to update animations. See 
  490.       --  Gtk.Widget.Add_Tick_Callback. 
  491.       --  Since: gtk+ 3.8 
  492.       --  "widget": the widget 
  493.       --  "frame_clock": the frame clock for the widget (same as calling 
  494.       --  gtk_widget_get_frame_clock) 
  495.       --  "user_data": user data passed to Gtk.Widget.Add_Tick_Callback. 
  496.  
  497.       function Add_Tick_Callback 
  498.          (Widget    : not null access Gtk.Widget.Gtk_Widget_Record'Class; 
  499.           Callback  : Gtk_Tick_Callback; 
  500.           User_Data : User_Data_Type; 
  501.           Notify    : Glib.G_Destroy_Notify_Address) return Guint; 
  502.       --  Queues a animation frame update and adds a callback to be called 
  503.       --  before each frame. Until the tick callback is removed, it will be 
  504.       --  called frequently (usually at the frame rate of the output device or 
  505.       --  as quickly as the application an be repainted, whichever is slower). 
  506.       --  For this reason, is most suitable for handling graphics that change 
  507.       --  every frame or every few frames. The tick callback does not 
  508.       --  automatically imply a relayout or repaint. If you want a repaint or 
  509.       --  relayout, and aren't changing widget properties that would trigger 
  510.       --  that (for example, changing the text of a Gtk.Label.Gtk_Label), then 
  511.       --  you will have to call Gtk.Widget.Queue_Resize or 
  512.       --  Gtk.Widget.Queue_Draw_Area yourself. 
  513.       --  Gdk.Frame_Clock.Get_Frame_Time should generally be used for timing 
  514.       --  continuous animations and 
  515.       --  Gdk.Frame_Timings.Get_Predicted_Presentation_Time if you are trying 
  516.       --  to display isolated frames at particular times. 
  517.       --  This is a more convenient alternative to connecting directly to the 
  518.       --  Gdk.Frame_Clock.Gdk_Frame_Clock::update signal of 
  519.       --  Gdk.Frame_Clock.Gdk_Frame_Clock, since you don't have to worry about 
  520.       --  when a Gdk.Frame_Clock.Gdk_Frame_Clock is assigned to a widget. 
  521.       --  Since: gtk+ 3.8 
  522.       --  "callback": function to call for updating animations 
  523.       --  "user_data": data to pass to Callback 
  524.       --  "notify": function to call to free User_Data when the callback is 
  525.       --  removed. 
  526.  
  527.    end Add_Tick_Callback_User_Data; 
  528.  
  529.    function Can_Activate_Accel 
  530.       (Widget    : not null access Gtk_Widget_Record; 
  531.        Signal_Id : Guint) return Boolean; 
  532.    --  Determines whether an accelerator that activates the signal identified 
  533.    --  by Signal_Id can currently be activated. This is done by emitting the 
  534.    --  Gtk.Widget.Gtk_Widget::can-activate-accel signal on Widget; if the 
  535.    --  signal isn't overridden by a handler or in a derived widget, then the 
  536.    --  default check is that the widget must be sensitive, and the widget and 
  537.    --  all its ancestors mapped. 
  538.    --  Since: gtk+ 2.4 
  539.    --  "signal_id": the ID of a signal installed on Widget 
  540.  
  541.    function Child_Focus 
  542.       (Widget    : not null access Gtk_Widget_Record; 
  543.        Direction : Gtk.Enums.Gtk_Direction_Type) return Boolean; 
  544.    --  This function is used by custom widget implementations; if you're 
  545.    --  writing an app, you'd use Gtk.Widget.Grab_Focus to move the focus to a 
  546.    --  particular widget, and Gtk.Container.Set_Focus_Chain to change the focus 
  547.    --  tab order. So you may want to investigate those functions instead. 
  548.    --  Gtk.Widget.Child_Focus is called by containers as the user moves around 
  549.    --  the window using keyboard shortcuts. Direction indicates what kind of 
  550.    --  motion is taking place (up, down, left, right, tab forward, tab 
  551.    --  backward). Gtk.Widget.Child_Focus emits the Gtk.Widget.Gtk_Widget::focus 
  552.    --  signal; widgets override the default handler for this signal in order to 
  553.    --  implement appropriate focus behavior. 
  554.    --  The default ::focus handler for a widget should return True if moving 
  555.    --  in Direction left the focus on a focusable location inside that widget, 
  556.    --  and False if moving in Direction moved the focus outside the widget. If 
  557.    --  returning True, widgets normally call Gtk.Widget.Grab_Focus to place the 
  558.    --  focus accordingly; if returning False, they don't modify the current 
  559.    --  focus location. 
  560.    --  "direction": direction of focus movement 
  561.  
  562.    procedure Child_Notify 
  563.       (Widget         : not null access Gtk_Widget_Record; 
  564.        Child_Property : UTF8_String); 
  565.    --  Emits a Gtk.Widget.Gtk_Widget::child-notify signal for the <link 
  566.    --  linkend="child-properties">child property</link> Child_Property on 
  567.    --  Widget. 
  568.    --  This is the analogue of g_object_notify for child properties. 
  569.    --  Also see Gtk.Container.Child_Notify. 
  570.    --  "child_property": the name of a child property installed on the class 
  571.    --  of Widget<!-- -->'s parent 
  572.  
  573.    function Compute_Expand 
  574.       (Widget      : not null access Gtk_Widget_Record; 
  575.        Orientation : Gtk.Enums.Gtk_Orientation) return Boolean; 
  576.    --  Computes whether a container should give this widget extra space when 
  577.    --  possible. Containers should check this, rather than looking at 
  578.    --  Gtk.Widget.Get_Hexpand or Gtk.Widget.Get_Vexpand. 
  579.    --  This function already checks whether the widget is visible, so 
  580.    --  visibility does not need to be checked separately. Non-visible widgets 
  581.    --  are not expanded. 
  582.    --  The computed expand value uses either the expand setting explicitly set 
  583.    --  on the widget itself, or, if none has been explicitly set, the widget 
  584.    --  may expand if some of its children do. 
  585.    --  "orientation": expand direction 
  586.  
  587.    function Create_Pango_Context 
  588.       (Widget : not null access Gtk_Widget_Record) 
  589.        return Pango.Context.Pango_Context; 
  590.    --  Creates a new Pango.Context.Pango_Context with the appropriate font 
  591.    --  map, font description, and base direction for drawing text for this 
  592.    --  widget. See also Gtk.Widget.Get_Pango_Context. 
  593.  
  594.    function Create_Pango_Layout 
  595.       (Widget : not null access Gtk_Widget_Record; 
  596.        Text   : UTF8_String := "") return Pango.Layout.Pango_Layout; 
  597.    --  Creates a new Pango.Layout.Pango_Layout with the appropriate font map, 
  598.    --  font description, and base direction for drawing text for this widget. 
  599.    --  If you keep a Pango.Layout.Pango_Layout created in this way around, you 
  600.    --  need to re-create it when the widget Pango.Context.Pango_Context is 
  601.    --  replaced. This can be tracked by using the 
  602.    --  Gtk.Widget.Gtk_Widget::screen-changed signal on the widget. 
  603.    --  "text": text to set on the layout (can be null) 
  604.  
  605.    procedure Destroy (Widget : not null access Gtk_Widget_Record); 
  606.    --  Destroys a widget. 
  607.    --  When a widget is destroyed, it will break any references it holds to 
  608.    --  other objects. If the widget is inside a container, the widget will be 
  609.    --  removed from the container. If the widget is a toplevel (derived from 
  610.    --  Gtk.Window.Gtk_Window), it will be removed from the list of toplevels, 
  611.    --  and the reference GTK+ holds to it will be removed. Removing a widget 
  612.    --  from its container or the list of toplevels results in the widget being 
  613.    --  finalized, unless you've added additional references to the widget with 
  614.    --  g_object_ref. 
  615.    --  In most cases, only toplevel widgets (windows) require explicit 
  616.    --  destruction, because when you destroy a toplevel its children will be 
  617.    --  destroyed as well. 
  618.  
  619.    procedure Destroyed 
  620.       (Widget         : not null access Gtk_Widget_Record; 
  621.        Widget_Pointer : in out Gtk_Widget); 
  622.    --  This function sets *Widget_Pointer to null if Widget_Pointer != null. 
  623.    --  It's intended to be used as a callback connected to the "destroy" signal 
  624.    --  of a widget. You connect Gtk.Widget.Destroyed as a signal handler, and 
  625.    --  pass the address of your widget variable as user data. Then when the 
  626.    --  widget is destroyed, the variable will be set to null. Useful for 
  627.    --  example to avoid multiple copies of the same dialog. 
  628.    --  "widget_pointer": address of a variable that contains Widget 
  629.  
  630.    function Device_Is_Shadowed 
  631.       (Widget : not null access Gtk_Widget_Record; 
  632.        Device : not null access Gdk.Device.Gdk_Device_Record'Class) 
  633.        return Boolean; 
  634.    --  Returns True if Device has been shadowed by a GTK+ device grab on 
  635.    --  another widget, so it would stop sending events to Widget. This may be 
  636.    --  used in the Gtk.Widget.Gtk_Widget::grab-notify signal to check for 
  637.    --  specific devices. See Gtk.Main.Device_Grab_Add. 
  638.    --  Since: gtk+ 3.0 
  639.    --  "device": a Gdk.Device.Gdk_Device 
  640.  
  641.    function Drag_Check_Threshold 
  642.       (Widget    : not null access Gtk_Widget_Record; 
  643.        Start_X   : Gint; 
  644.        Start_Y   : Gint; 
  645.        Current_X : Gint; 
  646.        Current_Y : Gint) return Boolean; 
  647.    --  "start_x": X coordinate of start of drag 
  648.    --  "start_y": Y coordinate of start of drag 
  649.    --  "current_x": current X coordinate 
  650.    --  "current_y": current Y coordinate 
  651.  
  652.    procedure Drag_Dest_Add_Image_Targets 
  653.       (Widget : not null access Gtk_Widget_Record); 
  654.  
  655.    procedure Drag_Dest_Add_Text_Targets 
  656.       (Widget : not null access Gtk_Widget_Record); 
  657.  
  658.    procedure Drag_Dest_Add_Uri_Targets 
  659.       (Widget : not null access Gtk_Widget_Record); 
  660.  
  661.    function Drag_Dest_Get_Track_Motion 
  662.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  663.  
  664.    procedure Drag_Dest_Set_Track_Motion 
  665.       (Widget       : not null access Gtk_Widget_Record; 
  666.        Track_Motion : Boolean); 
  667.    --  "track_motion": whether to accept all targets 
  668.  
  669.    procedure Drag_Dest_Set_Proxy 
  670.       (Widget          : not null access Gtk_Widget_Record; 
  671.        Proxy_Window    : Gdk.Gdk_Window; 
  672.        Protocol        : Gdk.Drag_Contexts.Gdk_Drag_Protocol; 
  673.        Use_Coordinates : Boolean); 
  674.    --  "proxy_window": the window to which to forward drag events 
  675.    --  "protocol": the drag protocol which the Proxy_Window accepts (You can 
  676.    --  use gdk_drag_get_protocol to determine this) 
  677.    --  "use_coordinates": If True, send the same coordinates to the 
  678.    --  destination, because it is an embedded subwindow. 
  679.  
  680.    procedure Drag_Dest_Unset (Widget : not null access Gtk_Widget_Record); 
  681.  
  682.    procedure Drag_Get_Data 
  683.       (Widget  : not null access Gtk_Widget_Record; 
  684.        Context : not null access Gdk.Drag_Contexts.Drag_Context_Record'Class; 
  685.        Target  : Gdk.Types.Gdk_Atom; 
  686.        Time    : Guint32); 
  687.    --  "context": the drag context 
  688.    --  "target": the target (form of the data) to retrieve. 
  689.    --  "time_": a timestamp for retrieving the data. This will generally be 
  690.    --  the time received in a Gtk.Widget.Gtk_Widget::drag-motion" or 
  691.    --  Gtk.Widget.Gtk_Widget::drag-drop" signal. 
  692.  
  693.    procedure Drag_Highlight (Widget : not null access Gtk_Widget_Record); 
  694.  
  695.    procedure Drag_Source_Add_Image_Targets 
  696.       (Widget : not null access Gtk_Widget_Record); 
  697.  
  698.    procedure Drag_Source_Add_Uri_Targets 
  699.       (Widget : not null access Gtk_Widget_Record); 
  700.  
  701.    procedure Drag_Source_Set_Icon_Pixbuf 
  702.       (Widget : not null access Gtk_Widget_Record; 
  703.        Pixbuf : not null access Gdk.Pixbuf.Gdk_Pixbuf_Record'Class); 
  704.    --  "pixbuf": the Gdk.Pixbuf.Gdk_Pixbuf for the drag icon 
  705.  
  706.    procedure Drag_Source_Unset (Widget : not null access Gtk_Widget_Record); 
  707.  
  708.    procedure Drag_Unhighlight (Widget : not null access Gtk_Widget_Record); 
  709.  
  710.    procedure Draw 
  711.       (Widget : not null access Gtk_Widget_Record; 
  712.        Cr     : Cairo.Cairo_Context); 
  713.    --  Draws Widget to Cr. The top left corner of the widget will be drawn to 
  714.    --  the currently set origin point of Cr. 
  715.    --  You should pass a cairo context as Cr argument that is in an original 
  716.    --  state. Otherwise the resulting drawing is undefined. For example 
  717.    --  changing the operator using cairo_set_operator or the line width using 
  718.    --  cairo_set_line_width might have unwanted side effects. You may however 
  719.    --  change the context's transform matrix - like with cairo_scale, 
  720.    --  cairo_translate or cairo_set_matrix and clip region with cairo_clip 
  721.    --  prior to calling this function. Also, it is fine to modify the context 
  722.    --  with cairo_save and cairo_push_group prior to calling this function. 
  723.    --  Note: 
  724.    --  Special purpose widgets may contain special code for rendering to the 
  725.    --  screen and might appear differently on screen and when rendered using 
  726.    --  Gtk.Widget.Draw. 
  727.    --  Since: gtk+ 3.0 
  728.    --  "cr": a cairo context to draw to 
  729.  
  730.    procedure Ensure_Style (Widget : not null access Gtk_Widget_Record); 
  731.    pragma Obsolescent (Ensure_Style); 
  732.    --  Ensures that Widget has a style (Widget->style). 
  733.    --  Not a very useful function; most of the time, if you want the style, 
  734.    --  the widget is realized, and realized widgets are guaranteed to have a 
  735.    --  style already. 
  736.    --  Deprecated since 3.0, Use Gtk.Style_Context.Gtk_Style_Context instead 
  737.  
  738.    procedure Error_Bell (Widget : not null access Gtk_Widget_Record); 
  739.    --  Notifies the user about an input-related error on this widget. If the 
  740.    --  Gtk.Settings.Gtk_Settings:gtk-error-bell setting is True, it calls 
  741.    --  Gdk.Window.Beep, otherwise it does nothing. 
  742.    --  Note that the effect of Gdk.Window.Beep can be configured in many ways, 
  743.    --  depending on the windowing backend and the desktop environment or window 
  744.    --  manager that is used. 
  745.    --  Since: gtk+ 2.12 
  746.  
  747.    function Event 
  748.       (Widget : not null access Gtk_Widget_Record; 
  749.        Event  : Gdk.Event.Gdk_Event) return Boolean; 
  750.    --  Rarely-used function. This function is used to emit the event signals 
  751.    --  on a widget (those signals should never be emitted without using this 
  752.    --  function to do so). If you want to synthesize an event though, don't use 
  753.    --  this function; instead, use Gtk.Main.Main_Do_Event so the event will 
  754.    --  behave as if it were in the event queue. Don't synthesize expose events; 
  755.    --  instead, use Gdk.Window.Invalidate_Rect to invalidate a region of the 
  756.    --  window. 
  757.    --  "event": a Gdk.Event.Gdk_Event 
  758.  
  759.    procedure Freeze_Child_Notify 
  760.       (Widget : not null access Gtk_Widget_Record); 
  761.    --  Stops emission of Gtk.Widget.Gtk_Widget::child-notify signals on 
  762.    --  Widget. The signals are queued until Gtk.Widget.Thaw_Child_Notify is 
  763.    --  called on Widget. 
  764.    --  This is the analogue of g_object_freeze_notify for child properties. 
  765.  
  766.    function Get_Allocated_Height 
  767.       (Widget : not null access Gtk_Widget_Record) return Gint; 
  768.    --  Returns the height that has currently been allocated to Widget. This 
  769.    --  function is intended to be used when implementing handlers for the 
  770.    --  Gtk.Widget.Gtk_Widget::draw function. 
  771.  
  772.    function Get_Allocated_Width 
  773.       (Widget : not null access Gtk_Widget_Record) return Gint; 
  774.    --  Returns the width that has currently been allocated to Widget. This 
  775.    --  function is intended to be used when implementing handlers for the 
  776.    --  Gtk.Widget.Gtk_Widget::draw function. 
  777.  
  778.    procedure Get_Allocation 
  779.       (Widget     : not null access Gtk_Widget_Record; 
  780.        Allocation : out Gtk_Allocation); 
  781.    --  Retrieves the widget's allocation. 
  782.    --  Note, when implementing a Gtk.Container.Gtk_Container: a widget's 
  783.    --  allocation will be its "adjusted" allocation, that is, the widget's 
  784.    --  parent container typically calls Gtk.Widget.Size_Allocate with an 
  785.    --  allocation, and that allocation is then adjusted (to handle margin and 
  786.    --  alignment for example) before assignment to the widget. 
  787.    --  Gtk.Widget.Get_Allocation returns the adjusted allocation that was 
  788.    --  actually assigned to the widget. The adjusted allocation is guaranteed 
  789.    --  to be completely contained within the Gtk.Widget.Size_Allocate 
  790.    --  allocation, however. So a Gtk.Container.Gtk_Container is guaranteed that 
  791.    --  its children stay inside the assigned bounds, but not that they have 
  792.    --  exactly the bounds the container assigned. There is no way to get the 
  793.    --  original allocation assigned by Gtk.Widget.Size_Allocate, since it isn't 
  794.    --  stored; if a container implementation needs that information it will 
  795.    --  have to track it itself. 
  796.    --  Since: gtk+ 2.18 
  797.    --  "allocation": a pointer to a Gtk_Allocation to copy to 
  798.  
  799.    procedure Set_Allocation 
  800.       (Widget     : not null access Gtk_Widget_Record; 
  801.        Allocation : in out Gtk_Allocation); 
  802.    --  Sets the widget's allocation. This should not be used directly, but 
  803.    --  from within a widget's size_allocate method. 
  804.    --  The allocation set should be the "adjusted" or actual allocation. If 
  805.    --  you're implementing a Gtk.Container.Gtk_Container, you want to use 
  806.    --  Gtk.Widget.Size_Allocate instead of Gtk.Widget.Set_Allocation. The 
  807.    --  GtkWidgetClass::adjust_size_allocation virtual method adjusts the 
  808.    --  allocation inside Gtk.Widget.Size_Allocate to create an adjusted 
  809.    --  allocation. 
  810.    --  Since: gtk+ 2.18 
  811.    --  "allocation": a pointer to a Gtk_Allocation to copy from 
  812.  
  813.    function Get_Ancestor 
  814.       (Widget      : not null access Gtk_Widget_Record; 
  815.        Widget_Type : GType) return Gtk_Widget; 
  816.    --  Gets the first ancestor of Widget with type Widget_Type. For example, 
  817.    --  'gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)' gets the first 
  818.    --  Gtk.Box.Gtk_Box that's an ancestor of Widget. No reference will be added 
  819.    --  to the returned widget; it should not be unreferenced. See note about 
  820.    --  checking for a toplevel Gtk.Window.Gtk_Window in the docs for 
  821.    --  Gtk.Widget.Get_Toplevel. 
  822.    --  Note that unlike Gtk.Widget.Is_Ancestor, Gtk.Widget.Get_Ancestor 
  823.    --  considers Widget to be an ancestor of itself. 
  824.    --  "widget_type": ancestor type 
  825.  
  826.    function Get_App_Paintable 
  827.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  828.    --  Determines whether the application intends to draw on the widget in an 
  829.    --  Gtk.Widget.Gtk_Widget::draw handler. 
  830.    --  See Gtk.Widget.Set_App_Paintable 
  831.    --  Since: gtk+ 2.18 
  832.  
  833.    procedure Set_App_Paintable 
  834.       (Widget        : not null access Gtk_Widget_Record; 
  835.        App_Paintable : Boolean); 
  836.    --  Sets whether the application intends to draw on the widget in an 
  837.    --  Gtk.Widget.Gtk_Widget::draw handler. 
  838.    --  This is a hint to the widget and does not affect the behavior of the 
  839.    --  GTK+ core; many widgets ignore this flag entirely. For widgets that do 
  840.    --  pay attention to the flag, such as Gtk.Event_Box.Gtk_Event_Box and 
  841.    --  Gtk.Window.Gtk_Window, the effect is to suppress default themed drawing 
  842.    --  of the widget's background. (Children of the widget will still be 
  843.    --  drawn.) The application is then entirely responsible for drawing the 
  844.    --  widget background. 
  845.    --  Note that the background is still drawn when the widget is mapped. 
  846.    --  "app_paintable": True if the application will paint on the widget 
  847.  
  848.    function Get_Can_Default 
  849.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  850.    --  Determines whether Widget can be a default widget. See 
  851.    --  Gtk.Widget.Set_Can_Default. 
  852.    --  Since: gtk+ 2.18 
  853.  
  854.    procedure Set_Can_Default 
  855.       (Widget      : not null access Gtk_Widget_Record; 
  856.        Can_Default : Boolean); 
  857.    --  Specifies whether Widget can be a default widget. See 
  858.    --  Gtk.Widget.Grab_Default for details about the meaning of "default". 
  859.    --  Since: gtk+ 2.18 
  860.    --  "can_default": whether or not Widget can be a default widget. 
  861.  
  862.    function Get_Can_Focus 
  863.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  864.    --  Determines whether Widget can own the input focus. See 
  865.    --  Gtk.Widget.Set_Can_Focus. 
  866.    --  Since: gtk+ 2.18 
  867.  
  868.    procedure Set_Can_Focus 
  869.       (Widget    : not null access Gtk_Widget_Record; 
  870.        Can_Focus : Boolean); 
  871.    --  Specifies whether Widget can own the input focus. See 
  872.    --  Gtk.Widget.Grab_Focus for actually setting the input focus on a widget. 
  873.    --  Since: gtk+ 2.18 
  874.    --  "can_focus": whether or not Widget can own the input focus. 
  875.  
  876.    procedure Get_Child_Requisition 
  877.       (Widget      : not null access Gtk_Widget_Record; 
  878.        Requisition : out Gtk_Requisition); 
  879.    pragma Obsolescent (Get_Child_Requisition); 
  880.    --  This function is only for use in widget implementations. Obtains 
  881.    --  Widget->requisition, unless someone has forced a particular geometry on 
  882.    --  the widget (e.g. with Gtk.Widget.Set_Size_Request), in which case it 
  883.    --  returns that geometry instead of the widget's requisition. 
  884.    --  This function differs from Gtk.Widget.Size_Request in that it retrieves 
  885.    --  the last size request value from Widget->requisition, while 
  886.    --  Gtk.Widget.Size_Request actually calls the "size_request" method on 
  887.    --  Widget to compute the size request and fill in Widget->requisition, and 
  888.    --  only then returns Widget->requisition. 
  889.    --  Because this function does not call the "size_request" method, it can 
  890.    --  only be used when you know that Widget->requisition is up-to-date, that 
  891.    --  is, Gtk.Widget.Size_Request has been called since the last time a resize 
  892.    --  was queued. In general, only container implementations have this 
  893.    --  information; applications should use Gtk.Widget.Size_Request. 
  894.    --  Deprecated since 3.0, Use Gtk.Widget.Get_Preferred_Size instead. 
  895.    --  "requisition": a Gtk.Widget.Gtk_Requisition to be filled in 
  896.  
  897.    function Get_Child_Visible 
  898.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  899.    --  Gets the value set with Gtk.Widget.Set_Child_Visible. If you feel a 
  900.    --  need to use this function, your code probably needs reorganization. 
  901.    --  This function is only useful for container implementations and never 
  902.    --  should be called by an application. 
  903.  
  904.    procedure Set_Child_Visible 
  905.       (Widget     : not null access Gtk_Widget_Record; 
  906.        Is_Visible : Boolean); 
  907.    --  Sets whether Widget should be mapped along with its when its parent is 
  908.    --  mapped and Widget has been shown with Gtk.Widget.Show. 
  909.    --  The child visibility can be set for widget before it is added to a 
  910.    --  container with Gtk.Widget.Set_Parent, to avoid mapping children 
  911.    --  unnecessary before immediately unmapping them. However it will be reset 
  912.    --  to its default state of True when the widget is removed from a 
  913.    --  container. 
  914.    --  Note that changing the child visibility of a widget does not queue a 
  915.    --  resize on the widget. Most of the time, the size of a widget is computed 
  916.    --  from all visible children, whether or not they are mapped. If this is 
  917.    --  not the case, the container can queue a resize itself. 
  918.    --  This function is only useful for container implementations and never 
  919.    --  should be called by an application. 
  920.    --  "is_visible": if True, Widget should be mapped along with its parent. 
  921.  
  922.    function Get_Composite_Name 
  923.       (Widget : not null access Gtk_Widget_Record) return UTF8_String; 
  924.    --  Obtains the composite name of a widget. 
  925.  
  926.    procedure Set_Composite_Name 
  927.       (Widget : not null access Gtk_Widget_Record; 
  928.        Name   : UTF8_String); 
  929.    --  Sets a widgets composite name. The widget must be a composite child of 
  930.    --  its parent; see Gtk.Widget.Push_Composite_Child. 
  931.    --  "name": the name to set 
  932.  
  933.    function Get_Device_Enabled 
  934.       (Widget : not null access Gtk_Widget_Record; 
  935.        Device : not null access Gdk.Device.Gdk_Device_Record'Class) 
  936.        return Boolean; 
  937.    --  Returns whether Device can interact with Widget and its children. See 
  938.    --  Gtk.Widget.Set_Device_Enabled. 
  939.    --  Since: gtk+ 3.0 
  940.    --  "device": a Gdk.Device.Gdk_Device 
  941.  
  942.    procedure Set_Device_Enabled 
  943.       (Widget  : not null access Gtk_Widget_Record; 
  944.        Device  : not null access Gdk.Device.Gdk_Device_Record'Class; 
  945.        Enabled : Boolean); 
  946.    --  Enables or disables a Gdk.Device.Gdk_Device to interact with Widget and 
  947.    --  all its children. 
  948.    --  It does so by descending through the Gdk.Gdk_Window hierarchy and 
  949.    --  enabling the same mask that is has for core events (i.e. the one that 
  950.    --  Gdk.Window.Get_Events returns). 
  951.    --  Since: gtk+ 3.0 
  952.    --  "device": a Gdk.Device.Gdk_Device 
  953.    --  "enabled": whether to enable the device 
  954.  
  955.    function Get_Device_Events 
  956.       (Widget : not null access Gtk_Widget_Record; 
  957.        Device : not null access Gdk.Device.Gdk_Device_Record'Class) 
  958.        return Gdk.Event.Gdk_Event_Mask; 
  959.    --  Returns the events mask for the widget corresponding to an specific 
  960.    --  device. These are the events that the widget will receive when Device 
  961.    --  operates on it. 
  962.    --  Since: gtk+ 3.0 
  963.    --  "device": a Gdk.Device.Gdk_Device 
  964.  
  965.    procedure Set_Device_Events 
  966.       (Widget : not null access Gtk_Widget_Record; 
  967.        Device : not null access Gdk.Device.Gdk_Device_Record'Class; 
  968.        Events : Gdk.Event.Gdk_Event_Mask); 
  969.    --  Sets the device event mask (see Gdk.Event.Gdk_Event_Mask) for a widget. 
  970.    --  The event mask determines which events a widget will receive from 
  971.    --  Device. Keep in mind that different widgets have different default event 
  972.    --  masks, and by changing the event mask you may disrupt a widget's 
  973.    --  functionality, so be careful. This function must be called while a 
  974.    --  widget is unrealized. Consider Gtk.Widget.Add_Device_Events for widgets 
  975.    --  that are already realized, or if you want to preserve the existing event 
  976.    --  mask. This function can't be used with GTK_NO_WINDOW widgets; to get 
  977.    --  events on those widgets, place them inside a Gtk.Event_Box.Gtk_Event_Box 
  978.    --  and receive events on the event box. 
  979.    --  Since: gtk+ 3.0 
  980.    --  "device": a Gdk.Device.Gdk_Device 
  981.    --  "events": event mask 
  982.  
  983.    function Get_Direction 
  984.       (Widget : not null access Gtk_Widget_Record) 
  985.        return Gtk.Enums.Gtk_Text_Direction; 
  986.    --  Gets the reading direction for a particular widget. See 
  987.    --  Gtk.Widget.Set_Direction. 
  988.  
  989.    procedure Set_Direction 
  990.       (Widget : not null access Gtk_Widget_Record; 
  991.        Dir    : Gtk.Enums.Gtk_Text_Direction); 
  992.    --  Sets the reading direction on a particular widget. This direction 
  993.    --  controls the primary direction for widgets containing text, and also the 
  994.    --  direction in which the children of a container are packed. The ability 
  995.    --  to set the direction is present in order so that correct localization 
  996.    --  into languages with right-to-left reading directions can be done. 
  997.    --  Generally, applications will let the default reading direction present, 
  998.    --  except for containers where the containers are arranged in an order that 
  999.    --  is explicitely visual rather than logical (such as buttons for text 
  1000.    --  justification). 
  1001.    --  If the direction is set to Gtk.Enums.Text_Dir_None, then the value set 
  1002.    --  by Gtk.Widget.Set_Default_Direction will be used. 
  1003.    --  "dir": the new direction 
  1004.  
  1005.    function Get_Display 
  1006.       (Widget : not null access Gtk_Widget_Record) 
  1007.        return Gdk.Display.Gdk_Display; 
  1008.    --  Get the Gdk.Display.Gdk_Display for the toplevel window associated with 
  1009.    --  this widget. This function can only be called after the widget has been 
  1010.    --  added to a widget hierarchy with a Gtk.Window.Gtk_Window at the top. 
  1011.    --  In general, you should only create display specific resources when a 
  1012.    --  widget has been realized, and you should free those resources when the 
  1013.    --  widget is unrealized. 
  1014.    --  Since: gtk+ 2.2 
  1015.  
  1016.    function Get_Double_Buffered 
  1017.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  1018.    --  Determines whether the widget is double buffered. 
  1019.    --  See Gtk.Widget.Set_Double_Buffered 
  1020.    --  Since: gtk+ 2.18 
  1021.  
  1022.    procedure Set_Double_Buffered 
  1023.       (Widget          : not null access Gtk_Widget_Record; 
  1024.        Double_Buffered : Boolean); 
  1025.    --  Widgets are double buffered by default; you can use this function to 
  1026.    --  turn off the buffering. "Double buffered" simply means that 
  1027.    --  Gdk.Window.Begin_Paint_Region and Gdk.Window.End_Paint are called 
  1028.    --  automatically around expose events sent to the widget. 
  1029.    --  Gdk.Window.Begin_Paint_Region diverts all drawing to a widget's window 
  1030.    --  to an offscreen buffer, and Gdk.Window.End_Paint draws the buffer to the 
  1031.    --  screen. The result is that users see the window update in one smooth 
  1032.    --  step, and don't see individual graphics primitives being rendered. 
  1033.    --  In very simple terms, double buffered widgets don't flicker, so you 
  1034.    --  would only use this function to turn off double buffering if you had 
  1035.    --  special needs and really knew what you were doing. 
  1036.    --  Note: if you turn off double-buffering, you have to handle expose 
  1037.    --  events, since even the clearing to the background color or pixmap will 
  1038.    --  not happen automatically (as it is done in 
  1039.    --  Gdk.Window.Begin_Paint_Region). 
  1040.    --  "double_buffered": True to double-buffer a widget 
  1041.  
  1042.    function Get_Events 
  1043.       (Widget : not null access Gtk_Widget_Record) 
  1044.        return Gdk.Event.Gdk_Event_Mask; 
  1045.    --  Returns the event mask for the widget (a bitfield containing flags from 
  1046.    --  the Gdk.Event.Gdk_Event_Mask enumeration). These are the events that the 
  1047.    --  widget will receive. 
  1048.  
  1049.    procedure Set_Events 
  1050.       (Widget : not null access Gtk_Widget_Record; 
  1051.        Events : Gdk.Event.Gdk_Event_Mask); 
  1052.    --  Sets the event mask (see Gdk.Event.Gdk_Event_Mask) for a widget. The 
  1053.    --  event mask determines which events a widget will receive. Keep in mind 
  1054.    --  that different widgets have different default event masks, and by 
  1055.    --  changing the event mask you may disrupt a widget's functionality, so be 
  1056.    --  careful. This function must be called while a widget is unrealized. 
  1057.    --  Consider Gtk.Widget.Add_Events for widgets that are already realized, or 
  1058.    --  if you want to preserve the existing event mask. This function can't be 
  1059.    --  used with GTK_NO_WINDOW widgets; to get events on those widgets, place 
  1060.    --  them inside a Gtk.Event_Box.Gtk_Event_Box and receive events on the 
  1061.    --  event box. 
  1062.    --  "events": event mask 
  1063.  
  1064.    function Get_Frame_Clock 
  1065.       (Widget : not null access Gtk_Widget_Record) 
  1066.        return Gdk.Frame_Clock.Gdk_Frame_Clock; 
  1067.    --  Obtains the frame clock for a widget. The frame clock is a global 
  1068.    --  "ticker" that can be used to drive animations and repaints. The most 
  1069.    --  common reason to get the frame clock is to call 
  1070.    --  Gdk.Frame_Clock.Get_Frame_Time, in order to get a time to use for 
  1071.    --  animating. For example you might record the start of the animation with 
  1072.    --  an initial value from Gdk.Frame_Clock.Get_Frame_Time, and then update 
  1073.    --  the animation by calling Gdk.Frame_Clock.Get_Frame_Time again during 
  1074.    --  each repaint. 
  1075.    --  Gdk.Frame_Clock.Request_Phase will result in a new frame on the clock, 
  1076.    --  but won't necessarily repaint any widgets. To repaint a widget, you have 
  1077.    --  to use Gtk.Widget.Queue_Draw which invalidates the widget (thus 
  1078.    --  scheduling it to receive a draw on the next frame). 
  1079.    --  Gtk.Widget.Queue_Draw will also end up requesting a frame on the 
  1080.    --  appropriate frame clock. 
  1081.    --  A widget's frame clock will not change while the widget is mapped. 
  1082.    --  Reparenting a widget (which implies a temporary unmap) can change the 
  1083.    --  widget's frame clock. 
  1084.    --  Unrealized widgets do not have a frame clock. 
  1085.    --  Since: gtk+ 3.8 
  1086.  
  1087.    function Get_Halign 
  1088.       (Widget : not null access Gtk_Widget_Record) return Gtk_Align; 
  1089.    --  Gets the value of the Gtk.Widget.Gtk_Widget:halign property. 
  1090.  
  1091.    procedure Set_Halign 
  1092.       (Widget : not null access Gtk_Widget_Record; 
  1093.        Align  : Gtk_Align); 
  1094.    --  Sets the horizontal alignment of Widget. See the 
  1095.    --  Gtk.Widget.Gtk_Widget:halign property. 
  1096.    --  "align": the horizontal alignment 
  1097.  
  1098.    function Get_Has_Tooltip 
  1099.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  1100.    --  Returns the current value of the has-tooltip property. See 
  1101.    --  Gtk.Widget.Gtk_Widget:has-tooltip for more information. 
  1102.    --  Since: gtk+ 2.12 
  1103.  
  1104.    procedure Set_Has_Tooltip 
  1105.       (Widget      : not null access Gtk_Widget_Record; 
  1106.        Has_Tooltip : Boolean); 
  1107.    --  Sets the has-tooltip property on Widget to Has_Tooltip. See 
  1108.    --  Gtk.Widget.Gtk_Widget:has-tooltip for more information. 
  1109.    --  Since: gtk+ 2.12 
  1110.    --  "has_tooltip": whether or not Widget has a tooltip. 
  1111.  
  1112.    function Get_Has_Window 
  1113.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  1114.    --  Determines whether Widget has a Gdk.Gdk_Window of its own. See 
  1115.    --  Gtk.Widget.Set_Has_Window. 
  1116.    --  Since: gtk+ 2.18 
  1117.  
  1118.    procedure Set_Has_Window 
  1119.       (Widget     : not null access Gtk_Widget_Record; 
  1120.        Has_Window : Boolean); 
  1121.    --  Specifies whether Widget has a Gdk.Gdk_Window of its own. Note that all 
  1122.    --  realized widgets have a non-null "window" pointer (gtk_widget_get_window 
  1123.    --  never returns a null window when a widget is realized), but for many of 
  1124.    --  them it's actually the Gdk.Gdk_Window of one of its parent widgets. 
  1125.    --  Widgets that do not create a %window for themselves in 
  1126.    --  Gtk.Widget.Gtk_Widget::realize must announce this by calling this 
  1127.    --  function with Has_Window = False. 
  1128.    --  This function should only be called by widget implementations, and they 
  1129.    --  should call it in their init function. 
  1130.    --  Since: gtk+ 2.18 
  1131.    --  "has_window": whether or not Widget has a window. 
  1132.  
  1133.    function Get_Hexpand 
  1134.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  1135.    --  Gets whether the widget would like any available extra horizontal 
  1136.    --  space. When a user resizes a Gtk.Window.Gtk_Window, widgets with 
  1137.    --  expand=TRUE generally receive the extra space. For example, a list or 
  1138.    --  scrollable area or document in your window would often be set to expand. 
  1139.    --  Containers should use Gtk.Widget.Compute_Expand rather than this 
  1140.    --  function, to see whether a widget, or any of its children, has the 
  1141.    --  expand flag set. If any child of a widget wants to expand, the parent 
  1142.    --  may ask to expand also. 
  1143.    --  This function only looks at the widget's own hexpand flag, rather than 
  1144.    --  computing whether the entire widget tree rooted at this widget wants to 
  1145.    --  expand. 
  1146.  
  1147.    procedure Set_Hexpand 
  1148.       (Widget : not null access Gtk_Widget_Record; 
  1149.        Expand : Boolean); 
  1150.    --  Sets whether the widget would like any available extra horizontal 
  1151.    --  space. When a user resizes a Gtk.Window.Gtk_Window, widgets with 
  1152.    --  expand=TRUE generally receive the extra space. For example, a list or 
  1153.    --  scrollable area or document in your window would often be set to expand. 
  1154.    --  Call this function to set the expand flag if you would like your widget 
  1155.    --  to become larger horizontally when the window has extra room. 
  1156.    --  By default, widgets automatically expand if any of their children want 
  1157.    --  to expand. (To see if a widget will automatically expand given its 
  1158.    --  current children and state, call Gtk.Widget.Compute_Expand. A container 
  1159.    --  can decide how the expandability of children affects the expansion of 
  1160.    --  the container by overriding the compute_expand virtual method on 
  1161.    --  Gtk.Widget.Gtk_Widget.). 
  1162.    --  Setting hexpand explicitly with this function will override the 
  1163.    --  automatic expand behavior. 
  1164.    --  This function forces the widget to expand or not to expand, regardless 
  1165.    --  of children. The override occurs because Gtk.Widget.Set_Hexpand sets the 
  1166.    --  hexpand-set property (see Gtk.Widget.Set_Hexpand_Set) which causes the 
  1167.    --  widget's hexpand value to be used, rather than looking at children and 
  1168.    --  widget state. 
  1169.    --  "expand": whether to expand 
  1170.  
  1171.    function Get_Hexpand_Set 
  1172.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  1173.    --  Gets whether Gtk.Widget.Set_Hexpand has been used to explicitly set the 
  1174.    --  expand flag on this widget. 
  1175.    --  If hexpand is set, then it overrides any computed expand value based on 
  1176.    --  child widgets. If hexpand is not set, then the expand value depends on 
  1177.    --  whether any children of the widget would like to expand. 
  1178.    --  There are few reasons to use this function, but it's here for 
  1179.    --  completeness and consistency. 
  1180.  
  1181.    procedure Set_Hexpand_Set 
  1182.       (Widget : not null access Gtk_Widget_Record; 
  1183.        Set    : Boolean); 
  1184.    --  Sets whether the hexpand flag (see Gtk.Widget.Get_Hexpand) will be 
  1185.    --  used. 
  1186.    --  The hexpand-set property will be set automatically when you call 
  1187.    --  Gtk.Widget.Set_Hexpand to set hexpand, so the most likely reason to use 
  1188.    --  this function would be to unset an explicit expand flag. 
  1189.    --  If hexpand is set, then it overrides any computed expand value based on 
  1190.    --  child widgets. If hexpand is not set, then the expand value depends on 
  1191.    --  whether any children of the widget would like to expand. 
  1192.    --  There are few reasons to use this function, but it's here for 
  1193.    --  completeness and consistency. 
  1194.    --  "set": value for hexpand-set property 
  1195.  
  1196.    function Get_Mapped 
  1197.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  1198.    --  Whether the widget is mapped. 
  1199.    --  Since: gtk+ 2.20 
  1200.  
  1201.    procedure Set_Mapped 
  1202.       (Widget : not null access Gtk_Widget_Record; 
  1203.        Mapped : Boolean); 
  1204.    --  Marks the widget as being realized. 
  1205.    --  This function should only ever be called in a derived widget's "map" or 
  1206.    --  "unmap" implementation. 
  1207.    --  Since: gtk+ 2.20 
  1208.    --  "mapped": True to mark the widget as mapped 
  1209.  
  1210.    function Get_Margin_Bottom 
  1211.       (Widget : not null access Gtk_Widget_Record) return Gint; 
  1212.    --  Gets the value of the Gtk.Widget.Gtk_Widget:margin-bottom property. 
  1213.    --  Since: gtk+ 3.0 
  1214.  
  1215.    procedure Set_Margin_Bottom 
  1216.       (Widget : not null access Gtk_Widget_Record; 
  1217.        Margin : Gint); 
  1218.    --  Sets the bottom margin of Widget. See the 
  1219.    --  Gtk.Widget.Gtk_Widget:margin-bottom property. 
  1220.    --  Since: gtk+ 3.0 
  1221.    --  "margin": the bottom margin 
  1222.  
  1223.    function Get_Margin_Left 
  1224.       (Widget : not null access Gtk_Widget_Record) return Gint; 
  1225.    --  Gets the value of the Gtk.Widget.Gtk_Widget:margin-left property. 
  1226.    --  Since: gtk+ 3.0 
  1227.  
  1228.    procedure Set_Margin_Left 
  1229.       (Widget : not null access Gtk_Widget_Record; 
  1230.        Margin : Gint); 
  1231.    --  Sets the left margin of Widget. See the 
  1232.    --  Gtk.Widget.Gtk_Widget:margin-left property. 
  1233.    --  Since: gtk+ 3.0 
  1234.    --  "margin": the left margin 
  1235.  
  1236.    function Get_Margin_Right 
  1237.       (Widget : not null access Gtk_Widget_Record) return Gint; 
  1238.    --  Gets the value of the Gtk.Widget.Gtk_Widget:margin-right property. 
  1239.    --  Since: gtk+ 3.0 
  1240.  
  1241.    procedure Set_Margin_Right 
  1242.       (Widget : not null access Gtk_Widget_Record; 
  1243.        Margin : Gint); 
  1244.    --  Sets the right margin of Widget. See the 
  1245.    --  Gtk.Widget.Gtk_Widget:margin-right property. 
  1246.    --  Since: gtk+ 3.0 
  1247.    --  "margin": the right margin 
  1248.  
  1249.    function Get_Margin_Top 
  1250.       (Widget : not null access Gtk_Widget_Record) return Gint; 
  1251.    --  Gets the value of the Gtk.Widget.Gtk_Widget:margin-top property. 
  1252.    --  Since: gtk+ 3.0 
  1253.  
  1254.    procedure Set_Margin_Top 
  1255.       (Widget : not null access Gtk_Widget_Record; 
  1256.        Margin : Gint); 
  1257.    --  Sets the top margin of Widget. See the Gtk.Widget.Gtk_Widget:margin-top 
  1258.    --  property. 
  1259.    --  Since: gtk+ 3.0 
  1260.    --  "margin": the top margin 
  1261.  
  1262.    function Get_Modifier_Mask 
  1263.       (Widget : not null access Gtk_Widget_Record; 
  1264.        Intent : Gdk_Modifier_Intent) return Gdk.Types.Gdk_Modifier_Type; 
  1265.    --  Returns the modifier mask the Widget's windowing system backend uses 
  1266.    --  for a particular purpose. 
  1267.    --  See gdk_keymap_get_modifier_mask. 
  1268.    --  Since: gtk+ 3.4 
  1269.    --  "intent": the use case for the modifier mask 
  1270.  
  1271.    function Get_Name 
  1272.       (Widget : not null access Gtk_Widget_Record) return UTF8_String; 
  1273.    --  Retrieves the name of a widget. See Gtk.Widget.Set_Name for the 
  1274.    --  significance of widget names. 
  1275.  
  1276.    procedure Set_Name 
  1277.       (Widget : not null access Gtk_Widget_Record; 
  1278.        Name   : UTF8_String); 
  1279.    --  Widgets can be named, which allows you to refer to them from a CSS 
  1280.    --  file. You can apply a style to widgets with a particular name in the CSS 
  1281.    --  file. See the documentation for the CSS syntax (on the same page as the 
  1282.    --  docs for Gtk.Style_Context.Gtk_Style_Context). 
  1283.    --  Note that the CSS syntax has certain special characters to delimit and 
  1284.    --  represent elements in a selector (period, &num;, >, *...), so using 
  1285.    --  these will make your widget impossible to match by name. Any combination 
  1286.    --  of alphanumeric symbols, dashes and underscores will suffice. 
  1287.    --  "name": name for the widget 
  1288.  
  1289.    function Get_No_Show_All 
  1290.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  1291.    --  Returns the current value of the Gtk.Widget.Gtk_Widget:no-show-all 
  1292.    --  property, which determines whether calls to Gtk.Widget.Show_All will 
  1293.    --  affect this widget. 
  1294.    --  Since: gtk+ 2.4 
  1295.  
  1296.    procedure Set_No_Show_All 
  1297.       (Widget      : not null access Gtk_Widget_Record; 
  1298.        No_Show_All : Boolean); 
  1299.    --  Sets the Gtk.Widget.Gtk_Widget:no-show-all property, which determines 
  1300.    --  whether calls to Gtk.Widget.Show_All will affect this widget. 
  1301.    --  This is mostly for use in constructing widget hierarchies with 
  1302.    --  externally controlled visibility, see Gtk.UI_Manager.Gtk_UI_Manager. 
  1303.    --  Since: gtk+ 2.4 
  1304.    --  "no_show_all": the new value for the "no-show-all" property 
  1305.  
  1306.    function Get_Opacity 
  1307.       (Widget : not null access Gtk_Widget_Record) return Gdouble; 
  1308.    --  Fetches the requested opacity for this widget. See 
  1309.    --  Gtk.Widget.Set_Opacity. 
  1310.    --  Since: gtk+ 3.8 
  1311.  
  1312.    procedure Set_Opacity 
  1313.       (Widget  : not null access Gtk_Widget_Record; 
  1314.        Opacity : Gdouble); 
  1315.    --  Request the Widget to be rendered partially transparent, with opacity 0 
  1316.    --  being fully transparent and 1 fully opaque. (Opacity values are clamped 
  1317.    --  to the [0,1] range.). This works on both toplevel widget, and child 
  1318.    --  widgets, although there are some limitations: 
  1319.    --  For toplevel widgets this depends on the capabilities of the windowing 
  1320.    --  system. On X11 this has any effect only on X screens with a compositing 
  1321.    --  manager running. See Gtk.Widget.Is_Composited. On Windows it should work 
  1322.    --  always, although setting a window's opacity after the window has been 
  1323.    --  shown causes it to flicker once on Windows. 
  1324.    --  For child widgets it doesn't work if any affected widget has a native 
  1325.    --  window, or disables double buffering. 
  1326.    --  Since: gtk+ 3.8 
  1327.    --  "opacity": desired opacity, between 0 and 1 
  1328.  
  1329.    function Get_Pango_Context 
  1330.       (Widget : not null access Gtk_Widget_Record) 
  1331.        return Pango.Context.Pango_Context; 
  1332.    --  Gets a Pango.Context.Pango_Context with the appropriate font map, font 
  1333.    --  description, and base direction for this widget. Unlike the context 
  1334.    --  returned by Gtk.Widget.Create_Pango_Context, this context is owned by 
  1335.    --  the widget (it can be used until the screen for the widget changes or 
  1336.    --  the widget is removed from its toplevel), and will be updated to match 
  1337.    --  any changes to the widget's attributes. This can be tracked by using the 
  1338.    --  Gtk.Widget.Gtk_Widget::screen-changed signal on the widget. 
  1339.  
  1340.    function Get_Parent 
  1341.       (Widget : not null access Gtk_Widget_Record) return Gtk_Widget; 
  1342.    --  Returns the parent container of Widget. 
  1343.  
  1344.    procedure Set_Parent 
  1345.       (Widget : not null access Gtk_Widget_Record; 
  1346.        Parent : not null access Gtk_Widget_Record'Class); 
  1347.    --  This function is useful only when implementing subclasses of 
  1348.    --  Gtk.Container.Gtk_Container. Sets the container as the parent of Widget, 
  1349.    --  and takes care of some details such as updating the state and style of 
  1350.    --  the child to reflect its new location. The opposite function is 
  1351.    --  Gtk.Widget.Unparent. 
  1352.    --  "parent": parent container 
  1353.  
  1354.    function Get_Parent_Window 
  1355.       (Widget : not null access Gtk_Widget_Record) return Gdk.Gdk_Window; 
  1356.    --  Gets Widget's parent window. 
  1357.  
  1358.    procedure Set_Parent_Window 
  1359.       (Widget        : not null access Gtk_Widget_Record; 
  1360.        Parent_Window : Gdk.Gdk_Window); 
  1361.    --  Sets a non default parent window for Widget. 
  1362.    --  For GtkWindow classes, setting a Parent_Window effects whether the 
  1363.    --  window is a toplevel window or can be embedded into other widgets. 
  1364.    --  Note: 
  1365.    --  For GtkWindow classes, this needs to be called before the window is 
  1366.    --  realized. 
  1367.    --  "parent_window": the new parent window. 
  1368.  
  1369.    function Get_Path 
  1370.       (Widget : not null access Gtk_Widget_Record) return Gtk_Widget_Path; 
  1371.    --  Returns the Gtk.Widget.Gtk_Widget_Path representing Widget, if the 
  1372.    --  widget is not connected to a toplevel widget, a partial path will be 
  1373.    --  created. 
  1374.  
  1375.    procedure Get_Pointer 
  1376.       (Widget : not null access Gtk_Widget_Record; 
  1377.        X      : out Gint; 
  1378.        Y      : out Gint); 
  1379.    pragma Obsolescent (Get_Pointer); 
  1380.    --  Obtains the location of the mouse pointer in widget coordinates. Widget 
  1381.    --  coordinates are a bit odd; for historical reasons, they are defined as 
  1382.    --  Widget->window coordinates for widgets that are not GTK_NO_WINDOW 
  1383.    --  widgets, and are relative to Widget->allocation.x, Widget->allocation.y 
  1384.    --  for widgets that are GTK_NO_WINDOW widgets. 
  1385.    --  Deprecated since 3.4, Use Gdk.Window.Get_Device_Position instead. 
  1386.    --  "x": return location for the X coordinate, or null 
  1387.    --  "y": return location for the Y coordinate, or null 
  1388.  
  1389.    procedure Get_Preferred_Height 
  1390.       (Widget         : not null access Gtk_Widget_Record; 
  1391.        Minimum_Height : out Gint; 
  1392.        Natural_Height : out Gint); 
  1393.    --  Retrieves a widget's initial minimum and natural height. 
  1394.    --  Note: 
  1395.    --  This call is specific to width-for-height requests. 
  1396.    --  The returned request will be modified by the 
  1397.    --  GtkWidgetClass::adjust_size_request virtual method and by any 
  1398.    --  Gtk.Size_Group.Gtk_Size_Group<!-- -->s that have been applied. That is, 
  1399.    --  the returned request is the one that should be used for layout, not 
  1400.    --  necessarily the one returned by the widget itself. 
  1401.    --  Since: gtk+ 3.0 
  1402.    --  "minimum_height": location to store the minimum height, or null 
  1403.    --  "natural_height": location to store the natural height, or null 
  1404.  
  1405.    procedure Get_Preferred_Height_For_Width 
  1406.       (Widget         : not null access Gtk_Widget_Record; 
  1407.        Width          : Gint; 
  1408.        Minimum_Height : out Gint; 
  1409.        Natural_Height : out Gint); 
  1410.    --  Retrieves a widget's minimum and natural height if it would be given 
  1411.    --  the specified Width. 
  1412.    --  The returned request will be modified by the 
  1413.    --  GtkWidgetClass::adjust_size_request virtual method and by any 
  1414.    --  Gtk.Size_Group.Gtk_Size_Group<!-- -->s that have been applied. That is, 
  1415.    --  the returned request is the one that should be used for layout, not 
  1416.    --  necessarily the one returned by the widget itself. 
  1417.    --  Since: gtk+ 3.0 
  1418.    --  "width": the width which is available for allocation 
  1419.    --  "minimum_height": location for storing the minimum height, or null 
  1420.    --  "natural_height": location for storing the natural height, or null 
  1421.  
  1422.    procedure Get_Preferred_Size 
  1423.       (Widget       : not null access Gtk_Widget_Record; 
  1424.        Minimum_Size : out Gtk_Requisition; 
  1425.        Natural_Size : out Gtk_Requisition); 
  1426.    --  Retrieves the minimum and natural size of a widget, taking into account 
  1427.    --  the widget's preference for height-for-width management. 
  1428.    --  This is used to retrieve a suitable size by container widgets which do 
  1429.    --  not impose any restrictions on the child placement. It can be used to 
  1430.    --  deduce toplevel window and menu sizes as well as child widgets in 
  1431.    --  free-form containers such as GtkLayout. 
  1432.    --  Note: 
  1433.    --  Handle with care. Note that the natural height of a height-for-width 
  1434.    --  widget will generally be a smaller size than the minimum height, since 
  1435.    --  the required height for the natural width is generally smaller than the 
  1436.    --  required height for the minimum width. 
  1437.    --  Since: gtk+ 3.0 
  1438.    --  "minimum_size": location for storing the minimum size, or null 
  1439.    --  "natural_size": location for storing the natural size, or null 
  1440.  
  1441.    procedure Get_Preferred_Width 
  1442.       (Widget        : not null access Gtk_Widget_Record; 
  1443.        Minimum_Width : out Gint; 
  1444.        Natural_Width : out Gint); 
  1445.    --  Retrieves a widget's initial minimum and natural width. 
  1446.    --  Note: 
  1447.    --  This call is specific to height-for-width requests. 
  1448.    --  The returned request will be modified by the 
  1449.    --  GtkWidgetClass::adjust_size_request virtual method and by any 
  1450.    --  Gtk.Size_Group.Gtk_Size_Group<!-- -->s that have been applied. That is, 
  1451.    --  the returned request is the one that should be used for layout, not 
  1452.    --  necessarily the one returned by the widget itself. 
  1453.    --  Since: gtk+ 3.0 
  1454.    --  "minimum_width": location to store the minimum width, or null 
  1455.    --  "natural_width": location to store the natural width, or null 
  1456.  
  1457.    procedure Get_Preferred_Width_For_Height 
  1458.       (Widget        : not null access Gtk_Widget_Record; 
  1459.        Height        : Gint; 
  1460.        Minimum_Width : out Gint; 
  1461.        Natural_Width : out Gint); 
  1462.    --  Retrieves a widget's minimum and natural width if it would be given the 
  1463.    --  specified Height. 
  1464.    --  The returned request will be modified by the 
  1465.    --  GtkWidgetClass::adjust_size_request virtual method and by any 
  1466.    --  Gtk.Size_Group.Gtk_Size_Group<!-- -->s that have been applied. That is, 
  1467.    --  the returned request is the one that should be used for layout, not 
  1468.    --  necessarily the one returned by the widget itself. 
  1469.    --  Since: gtk+ 3.0 
  1470.    --  "height": the height which is available for allocation 
  1471.    --  "minimum_width": location for storing the minimum width, or null 
  1472.    --  "natural_width": location for storing the natural width, or null 
  1473.  
  1474.    function Get_Realized 
  1475.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  1476.    --  Determines whether Widget is realized. 
  1477.    --  Since: gtk+ 2.20 
  1478.  
  1479.    procedure Set_Realized 
  1480.       (Widget   : not null access Gtk_Widget_Record; 
  1481.        Realized : Boolean); 
  1482.    --  Marks the widget as being realized. 
  1483.    --  This function should only ever be called in a derived widget's 
  1484.    --  "realize" or "unrealize" implementation. 
  1485.    --  Since: gtk+ 2.20 
  1486.    --  "realized": True to mark the widget as realized 
  1487.  
  1488.    function Get_Receives_Default 
  1489.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  1490.    --  Determines whether Widget is always treated as the default widget 
  1491.    --  within its toplevel when it has the focus, even if another widget is the 
  1492.    --  default. 
  1493.    --  See Gtk.Widget.Set_Receives_Default. 
  1494.    --  Since: gtk+ 2.18 
  1495.  
  1496.    procedure Set_Receives_Default 
  1497.       (Widget           : not null access Gtk_Widget_Record; 
  1498.        Receives_Default : Boolean); 
  1499.    --  Specifies whether Widget will be treated as the default widget within 
  1500.    --  its toplevel when it has the focus, even if another widget is the 
  1501.    --  default. 
  1502.    --  See Gtk.Widget.Grab_Default for details about the meaning of "default". 
  1503.    --  Since: gtk+ 2.18 
  1504.    --  "receives_default": whether or not Widget can be a default widget. 
  1505.  
  1506.    function Get_Request_Mode 
  1507.       (Widget : not null access Gtk_Widget_Record) 
  1508.        return Gtk.Enums.Gtk_Size_Request_Mode; 
  1509.    --  Gets whether the widget prefers a height-for-width layout or a 
  1510.    --  width-for-height layout. 
  1511.    --  Note: 
  1512.    --  Gtk.Bin.Gtk_Bin widgets generally propagate the preference of their 
  1513.    --  child, container widgets need to request something either in context of 
  1514.    --  their children or in context of their allocation capabilities. 
  1515.    --  Since: gtk+ 3.0 
  1516.  
  1517.    procedure Get_Requisition 
  1518.       (Widget      : not null access Gtk_Widget_Record; 
  1519.        Requisition : out Gtk_Requisition); 
  1520.    pragma Obsolescent (Get_Requisition); 
  1521.    --  Retrieves the widget's requisition. 
  1522.    --  This function should only be used by widget implementations in order to 
  1523.    --  figure whether the widget's requisition has actually changed after some 
  1524.    --  internal state change (so that they can call Gtk.Widget.Queue_Resize 
  1525.    --  instead of Gtk.Widget.Queue_Draw). 
  1526.    --  Normally, Gtk.Widget.Size_Request should be used. 
  1527.    --  Since: gtk+ 2.20 
  1528.    --  Deprecated since 3.0, The Gtk.Widget.Gtk_Requisition cache on the 
  1529.    --  widget was removed, If you need to cache sizes across requests and 
  1530.    --  allocations, add an explicit cache to the widget in question instead. 
  1531.    --  "requisition": a pointer to a Gtk.Widget.Gtk_Requisition to copy to 
  1532.  
  1533.    function Get_Root_Window 
  1534.       (Widget : not null access Gtk_Widget_Record) return Gdk.Gdk_Window; 
  1535.    --  Get the root window where this widget is located. This function can 
  1536.    --  only be called after the widget has been added to a widget hierarchy 
  1537.    --  with Gtk.Window.Gtk_Window at the top. 
  1538.    --  The root window is useful for such purposes as creating a popup 
  1539.    --  Gdk.Gdk_Window associated with the window. In general, you should only 
  1540.    --  create display specific resources when a widget has been realized, and 
  1541.    --  you should free those resources when the widget is unrealized. 
  1542.    --  Since: gtk+ 2.2 
  1543.  
  1544.    function Get_Screen 
  1545.       (Widget : not null access Gtk_Widget_Record) 
  1546.        return Gdk.Screen.Gdk_Screen; 
  1547.    --  Get the Gdk.Screen.Gdk_Screen from the toplevel window associated with 
  1548.    --  this widget. This function can only be called after the widget has been 
  1549.    --  added to a widget hierarchy with a Gtk.Window.Gtk_Window at the top. 
  1550.    --  In general, you should only create screen specific resources when a 
  1551.    --  widget has been realized, and you should free those resources when the 
  1552.    --  widget is unrealized. 
  1553.    --  Since: gtk+ 2.2 
  1554.  
  1555.    function Get_Sensitive 
  1556.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  1557.    --  Returns the widget's sensitivity (in the sense of returning the value 
  1558.    --  that has been set using Gtk.Widget.Set_Sensitive). 
  1559.    --  The effective sensitivity of a widget is however determined by both its 
  1560.    --  own and its parent widget's sensitivity. See Gtk.Widget.Is_Sensitive. 
  1561.    --  Since: gtk+ 2.18 
  1562.  
  1563.    procedure Set_Sensitive 
  1564.       (Widget    : not null access Gtk_Widget_Record; 
  1565.        Sensitive : Boolean := True); 
  1566.    --  Sets the sensitivity of a widget. A widget is sensitive if the user can 
  1567.    --  interact with it. Insensitive widgets are "grayed out" and the user 
  1568.    --  can't interact with them. Insensitive widgets are known as "inactive", 
  1569.    --  "disabled", or "ghosted" in some other toolkits. 
  1570.    --  "sensitive": True to make the widget sensitive 
  1571.  
  1572.    procedure Get_Size_Request 
  1573.       (Widget : not null access Gtk_Widget_Record; 
  1574.        Width  : out Gint; 
  1575.        Height : out Gint); 
  1576.    --  Gets the size request that was explicitly set for the widget using 
  1577.    --  Gtk.Widget.Set_Size_Request. A value of -1 stored in Width or Height 
  1578.    --  indicates that that dimension has not been set explicitly and the 
  1579.    --  natural requisition of the widget will be used intead. See 
  1580.    --  Gtk.Widget.Set_Size_Request. To get the size a widget will actually 
  1581.    --  request, call Gtk.Widget.Get_Preferred_Size instead of this function. 
  1582.    --  "width": return location for width, or null 
  1583.    --  "height": return location for height, or null 
  1584.  
  1585.    procedure Set_Size_Request 
  1586.       (Widget : not null access Gtk_Widget_Record; 
  1587.        Width  : Gint := -1; 
  1588.        Height : Gint := -1); 
  1589.    --  Sets the minimum size of a widget; that is, the widget's size request 
  1590.    --  will be at least Width by Height. You can use this function to force a 
  1591.    --  widget to be larger than it normally would be. 
  1592.    --  In most cases, Gtk.Window.Set_Default_Size is a better choice for 
  1593.    --  toplevel windows than this function; setting the default size will still 
  1594.    --  allow users to shrink the window. Setting the size request will force 
  1595.    --  them to leave the window at least as large as the size request. When 
  1596.    --  dealing with window sizes, Gtk.Window.Set_Geometry_Hints can be a useful 
  1597.    --  function as well. 
  1598.    --  Note the inherent danger of setting any fixed size - themes, 
  1599.    --  translations into other languages, different fonts, and user action can 
  1600.    --  all change the appropriate size for a given widget. So, it's basically 
  1601.    --  impossible to hardcode a size that will always be correct. 
  1602.    --  The size request of a widget is the smallest size a widget can accept 
  1603.    --  while still functioning well and drawing itself correctly. However in 
  1604.    --  some strange cases a widget may be allocated less than its requested 
  1605.    --  size, and in many cases a widget may be allocated more space than it 
  1606.    --  requested. 
  1607.    --  If the size request in a given direction is -1 (unset), then the 
  1608.    --  "natural" size request of the widget will be used instead. 
  1609.    --  The size request set here does not include any margin from the 
  1610.    --  Gtk.Widget.Gtk_Widget properties margin-left, margin-right, margin-top, 
  1611.    --  and margin-bottom, but it does include pretty much all other padding or 
  1612.    --  border properties set by any subclass of Gtk.Widget.Gtk_Widget. 
  1613.    --  "width": width Widget should request, or -1 to unset 
  1614.    --  "height": height Widget should request, or -1 to unset 
  1615.  
  1616.    procedure Size_Request 
  1617.       (Widget      : not null access Gtk_Widget_Record; 
  1618.        Requisition : out Gtk_Requisition); 
  1619.    pragma Obsolescent (Size_Request); 
  1620.    --  This function is typically used when implementing a 
  1621.    --  Gtk.Container.Gtk_Container subclass. Obtains the preferred size of a 
  1622.    --  widget. The container uses this information to arrange its child widgets 
  1623.    --  and decide what size allocations to give them with 
  1624.    --  Gtk.Widget.Size_Allocate. 
  1625.    --  You can also call this function from an application, with some caveats. 
  1626.    --  Most notably, getting a size request requires the widget to be 
  1627.    --  associated with a screen, because font information may be needed. 
  1628.    --  Multihead-aware applications should keep this in mind. 
  1629.    --  Also remember that the size request is not necessarily the size a 
  1630.    --  widget will actually be allocated. 
  1631.    --  Deprecated since 3.0, Use Gtk.Widget.Get_Preferred_Size instead. 
  1632.    --  "requisition": a Gtk.Widget.Gtk_Requisition to be filled in 
  1633.  
  1634.    function Get_State 
  1635.       (Widget : not null access Gtk_Widget_Record) 
  1636.        return Gtk.Enums.Gtk_State_Type; 
  1637.    pragma Obsolescent (Get_State); 
  1638.    --  Returns the widget's state. See Gtk.Widget.Set_State. 
  1639.    --  Since: gtk+ 2.18 
  1640.    --  Deprecated since None, 3.0. Use Gtk.Widget.Get_State_Flags instead. 
  1641.  
  1642.    procedure Set_State 
  1643.       (Widget : not null access Gtk_Widget_Record; 
  1644.        State  : Gtk.Enums.Gtk_State_Type); 
  1645.    pragma Obsolescent (Set_State); 
  1646.    --  This function is for use in widget implementations. Sets the state of a 
  1647.    --  widget (insensitive, prelighted, etc.) Usually you should set the state 
  1648.    --  using wrapper functions such as Gtk.Widget.Set_Sensitive. 
  1649.    --  Deprecated since None, 3.0. Use Gtk.Widget.Set_State_Flags instead. 
  1650.    --  "state": new state for Widget 
  1651.  
  1652.    function Get_State_Flags 
  1653.       (Widget : not null access Gtk_Widget_Record) 
  1654.        return Gtk.Enums.Gtk_State_Flags; 
  1655.    --  Returns the widget state as a flag set. It is worth mentioning that the 
  1656.    --  effective Gtk.Enums.Gtk_State_Flag_Insensitive state will be returned, 
  1657.    --  that is, also based on parent insensitivity, even if Widget itself is 
  1658.    --  sensitive. 
  1659.    --  Since: gtk+ 3.0 
  1660.  
  1661.    procedure Set_State_Flags 
  1662.       (Widget : not null access Gtk_Widget_Record; 
  1663.        Flags  : Gtk.Enums.Gtk_State_Flags; 
  1664.        Clear  : Boolean); 
  1665.    --  This function is for use in widget implementations. Turns on flag 
  1666.    --  values in the current widget state (insensitive, prelighted, etc.). 
  1667.    --  It is worth mentioning that any other state than 
  1668.    --  Gtk.Enums.Gtk_State_Flag_Insensitive, will be propagated down to all 
  1669.    --  non-internal children if Widget is a Gtk.Container.Gtk_Container, while 
  1670.    --  Gtk.Enums.Gtk_State_Flag_Insensitive itself will be propagated down to 
  1671.    --  all Gtk.Container.Gtk_Container children by different means than turning 
  1672.    --  on the state flag down the hierarchy, both Gtk.Widget.Get_State_Flags 
  1673.    --  and Gtk.Widget.Is_Sensitive will make use of these. 
  1674.    --  Since: gtk+ 3.0 
  1675.    --  "flags": State flags to turn on 
  1676.    --  "clear": Whether to clear state before turning on Flags 
  1677.  
  1678.    function Get_Style 
  1679.       (Widget : not null access Gtk_Widget_Record) 
  1680.        return Gtk.Style.Gtk_Style; 
  1681.    pragma Obsolescent (Get_Style); 
  1682.    --  Simply an accessor function that returns Widget->style. 
  1683.    --  Deprecated since 3.0, Use Gtk.Style_Context.Gtk_Style_Context instead 
  1684.  
  1685.    procedure Set_Style 
  1686.       (Widget : not null access Gtk_Widget_Record; 
  1687.        Style  : access Gtk.Style.Gtk_Style_Record'Class); 
  1688.    pragma Obsolescent (Set_Style); 
  1689.    --  Used to set the Gtk.Style.Gtk_Style for a widget (Widget->style). Since 
  1690.    --  GTK 3, this function does nothing, the passed in style is ignored. 
  1691.    --  Deprecated since 3.0, Use Gtk.Style_Context.Gtk_Style_Context instead 
  1692.    --  "style": a Gtk.Style.Gtk_Style, or null to remove the effect of a 
  1693.    --  previous call to Gtk.Widget.Set_Style and go back to the default style 
  1694.  
  1695.    function Get_Support_Multidevice 
  1696.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  1697.    --  Returns True if Widget is multiple pointer aware. See 
  1698.    --  Gtk.Widget.Set_Support_Multidevice for more information. 
  1699.  
  1700.    procedure Set_Support_Multidevice 
  1701.       (Widget              : not null access Gtk_Widget_Record; 
  1702.        Support_Multidevice : Boolean); 
  1703.    --  Enables or disables multiple pointer awareness. If this setting is 
  1704.    --  True, Widget will start receiving multiple, per device enter/leave 
  1705.    --  events. Note that if custom Gdk.Gdk_Window<!-- -->s are created in 
  1706.    --  Gtk.Widget.Gtk_Widget::realize, Gdk.Window.Set_Support_Multidevice will 
  1707.    --  have to be called manually on them. 
  1708.    --  Since: gtk+ 3.0 
  1709.    --  "support_multidevice": True to support input from multiple devices. 
  1710.  
  1711.    function Get_Tooltip_Markup 
  1712.       (Widget : not null access Gtk_Widget_Record) return UTF8_String; 
  1713.    --  Gets the contents of the tooltip for Widget. 
  1714.    --  Since: gtk+ 2.12 
  1715.  
  1716.    procedure Set_Tooltip_Markup 
  1717.       (Widget : not null access Gtk_Widget_Record; 
  1718.        Markup : UTF8_String := ""); 
  1719.    --  Sets Markup as the contents of the tooltip, which is marked up with the 
  1720.    --  <link linkend="PangoMarkupFormat">Pango text markup language</link>. 
  1721.    --  This function will take care of setting 
  1722.    --  Gtk.Widget.Gtk_Widget:has-tooltip to True and of the default handler for 
  1723.    --  the Gtk.Widget.Gtk_Widget::query-tooltip signal. 
  1724.    --  See also the Gtk.Widget.Gtk_Widget:tooltip-markup property and 
  1725.    --  Gtk.Tooltip.Set_Markup. 
  1726.    --  Since: gtk+ 2.12 
  1727.    --  "markup": the contents of the tooltip for Widget, or null 
  1728.  
  1729.    function Get_Tooltip_Text 
  1730.       (Widget : not null access Gtk_Widget_Record) return UTF8_String; 
  1731.    --  Gets the contents of the tooltip for Widget. 
  1732.    --  Since: gtk+ 2.12 
  1733.  
  1734.    procedure Set_Tooltip_Text 
  1735.       (Widget : not null access Gtk_Widget_Record; 
  1736.        Text   : UTF8_String := ""); 
  1737.    --  Sets Text as the contents of the tooltip. This function will take care 
  1738.    --  of setting Gtk.Widget.Gtk_Widget:has-tooltip to True and of the default 
  1739.    --  handler for the Gtk.Widget.Gtk_Widget::query-tooltip signal. 
  1740.    --  See also the Gtk.Widget.Gtk_Widget:tooltip-text property and 
  1741.    --  Gtk.Tooltip.Set_Text. 
  1742.    --  Since: gtk+ 2.12 
  1743.    --  "text": the contents of the tooltip for Widget 
  1744.  
  1745.    function Get_Tooltip_Window 
  1746.       (Widget : not null access Gtk_Widget_Record) return Gtk_Widget; 
  1747.    --  Returns the Gtk.Window.Gtk_Window of the current tooltip. This can be 
  1748.    --  the GtkWindow created by default, or the custom tooltip window set using 
  1749.    --  Gtk.Widget.Set_Tooltip_Window. 
  1750.    --  Since: gtk+ 2.12 
  1751.  
  1752.    procedure Set_Tooltip_Window 
  1753.       (Widget        : not null access Gtk_Widget_Record; 
  1754.        Custom_Window : access Gtk_Widget_Record'Class); 
  1755.    --  Replaces the default, usually yellow, window used for displaying 
  1756.    --  tooltips with Custom_Window. GTK+ will take care of showing and hiding 
  1757.    --  Custom_Window at the right moment, to behave likewise as the default 
  1758.    --  tooltip window. If Custom_Window is null, the default tooltip window 
  1759.    --  will be used. 
  1760.    --  If the custom window should have the default theming it needs to have 
  1761.    --  the name "gtk-tooltip", see Gtk.Widget.Set_Name. 
  1762.    --  Since: gtk+ 2.12 
  1763.    --  "custom_window": a Gtk.Window.Gtk_Window, or null 
  1764.  
  1765.    function Get_Toplevel 
  1766.       (Widget : not null access Gtk_Widget_Record) return Gtk_Widget; 
  1767.    --  This function returns the topmost widget in the container hierarchy 
  1768.    --  Widget is a part of. If Widget has no parent widgets, it will be 
  1769.    --  returned as the topmost widget. No reference will be added to the 
  1770.    --  returned widget; it should not be unreferenced. 
  1771.    --  Note the difference in behavior vs. Gtk.Widget.Get_Ancestor; 
  1772.    --  'gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)' would return null if 
  1773.    --  Widget wasn't inside a toplevel window, and if the window was inside a 
  1774.    --  Gtk.Window.Gtk_Window<!-- -->-derived widget which was in turn inside 
  1775.    --  the toplevel Gtk.Window.Gtk_Window. While the second case may seem 
  1776.    --  unlikely, it actually happens when a Gtk_Plug is embedded inside a 
  1777.    --  Gtk_Socket within the same application. 
  1778.    --  To reliably find the toplevel Gtk.Window.Gtk_Window, use 
  1779.    --  Gtk.Widget.Get_Toplevel and check if the TOPLEVEL flags is set on the 
  1780.    --  result. |[ GtkWidget *toplevel = gtk_widget_get_toplevel (widget); if 
  1781.    --  (gtk_widget_is_toplevel (toplevel)) { /* Perform action on toplevel. */ 
  1782.    --  } ]| 
  1783.  
  1784.    function Get_Valign 
  1785.       (Widget : not null access Gtk_Widget_Record) return Gtk_Align; 
  1786.    --  Gets the value of the Gtk.Widget.Gtk_Widget:valign property. 
  1787.  
  1788.    procedure Set_Valign 
  1789.       (Widget : not null access Gtk_Widget_Record; 
  1790.        Align  : Gtk_Align); 
  1791.    --  Sets the vertical alignment of Widget. See the 
  1792.    --  Gtk.Widget.Gtk_Widget:valign property. 
  1793.    --  "align": the vertical alignment 
  1794.  
  1795.    function Get_Vexpand 
  1796.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  1797.    --  Gets whether the widget would like any available extra vertical space. 
  1798.    --  See Gtk.Widget.Get_Hexpand for more detail. 
  1799.  
  1800.    procedure Set_Vexpand 
  1801.       (Widget : not null access Gtk_Widget_Record; 
  1802.        Expand : Boolean); 
  1803.    --  Sets whether the widget would like any available extra vertical space. 
  1804.    --  See Gtk.Widget.Set_Hexpand for more detail. 
  1805.    --  "expand": whether to expand 
  1806.  
  1807.    function Get_Vexpand_Set 
  1808.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  1809.    --  Gets whether Gtk.Widget.Set_Vexpand has been used to explicitly set the 
  1810.    --  expand flag on this widget. 
  1811.    --  See Gtk.Widget.Get_Hexpand_Set for more detail. 
  1812.  
  1813.    procedure Set_Vexpand_Set 
  1814.       (Widget : not null access Gtk_Widget_Record; 
  1815.        Set    : Boolean); 
  1816.    --  Sets whether the vexpand flag (see Gtk.Widget.Get_Vexpand) will be 
  1817.    --  used. 
  1818.    --  See Gtk.Widget.Set_Hexpand_Set for more detail. 
  1819.    --  "set": value for vexpand-set property 
  1820.  
  1821.    function Get_Visible 
  1822.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  1823.    --  Determines whether the widget is visible. If you want to take into 
  1824.    --  account whether the widget's parent is also marked as visible, use 
  1825.    --  Gtk.Widget.Is_Visible instead. 
  1826.    --  This function does not check if the widget is obscured in any way. 
  1827.    --  See Gtk.Widget.Set_Visible. 
  1828.    --  Since: gtk+ 2.18 
  1829.  
  1830.    procedure Set_Visible 
  1831.       (Widget  : not null access Gtk_Widget_Record; 
  1832.        Visible : Boolean); 
  1833.    --  Sets the visibility state of Widget. Note that setting this to True 
  1834.    --  doesn't mean the widget is actually viewable, see 
  1835.    --  Gtk.Widget.Get_Visible. 
  1836.    --  This function simply calls Gtk.Widget.Show or Gtk.Widget.Hide but is 
  1837.    --  nicer to use when the visibility of the widget depends on some 
  1838.    --  condition. 
  1839.    --  Since: gtk+ 2.18 
  1840.    --  "visible": whether the widget should be shown or not 
  1841.  
  1842.    function Get_Visual 
  1843.       (Widget : not null access Gtk_Widget_Record) 
  1844.        return Gdk.Visual.Gdk_Visual; 
  1845.    --  Gets the visual that will be used to render Widget. 
  1846.  
  1847.    procedure Set_Visual 
  1848.       (Widget : not null access Gtk_Widget_Record; 
  1849.        Visual : Gdk.Visual.Gdk_Visual); 
  1850.    --  Sets the visual that should be used for by widget and its children for 
  1851.    --  creating Gdk_Windows. The visual must be on the same 
  1852.    --  Gdk.Screen.Gdk_Screen as returned by Gtk.Widget.Get_Screen, so handling 
  1853.    --  the Gtk.Widget.Gtk_Widget::screen-changed signal is necessary. 
  1854.    --  Setting a new Visual will not cause Widget to recreate its windows, so 
  1855.    --  you should call this function before Widget is realized. 
  1856.    --  "visual": visual to be used or null to unset a previous one 
  1857.  
  1858.    function Get_Window 
  1859.       (Widget : not null access Gtk_Widget_Record) return Gdk.Gdk_Window; 
  1860.    --  Returns the widget's window if it is realized, null otherwise 
  1861.    --  Since: gtk+ 2.14 
  1862.  
  1863.    procedure Set_Window 
  1864.       (Widget : not null access Gtk_Widget_Record; 
  1865.        Window : Gdk.Gdk_Window); 
  1866.    --  Sets a widget's window. This function should only be used in a widget's 
  1867.    --  Gtk.Widget.Gtk_Widget::realize implementation. The %window passed is 
  1868.    --  usually either new window created with gdk_window_new, or the window of 
  1869.    --  its parent widget as returned by Gtk.Widget.Get_Parent_Window. 
  1870.    --  Widgets must indicate whether they will create their own Gdk.Gdk_Window 
  1871.    --  by calling Gtk.Widget.Set_Has_Window. This is usually done in the 
  1872.    --  widget's init function. 
  1873.    --  Note: 
  1874.    --  This function does not add any reference to Window. 
  1875.    --  Since: gtk+ 2.18 
  1876.    --  "window": a Gdk.Gdk_Window 
  1877.  
  1878.    procedure Grab_Add (Widget : not null access Gtk_Widget_Record); 
  1879.    --  Makes Widget the current grabbed widget. 
  1880.    --  This means that interaction with other widgets in the same application 
  1881.    --  is blocked and mouse as well as keyboard events are delivered to this 
  1882.    --  widget. 
  1883.    --  If Widget is not sensitive, it is not set as the current grabbed widget 
  1884.    --  and this function does nothing. 
  1885.  
  1886.    procedure Grab_Default (Widget : not null access Gtk_Widget_Record); 
  1887.    --  Causes Widget to become the default widget. Widget must be able to be a 
  1888.    --  default widget; typically you would ensure this yourself by calling 
  1889.    --  Gtk.Widget.Set_Can_Default with a True value. The default widget is 
  1890.    --  activated when the user presses Enter in a window. Default widgets must 
  1891.    --  be activatable, that is, Gtk.Widget.Activate should affect them. Note 
  1892.    --  that Gtk.GEntry.Gtk_Entry widgets require the "activates-default" 
  1893.    --  property set to True before they activate the default widget when Enter 
  1894.    --  is pressed and the Gtk.GEntry.Gtk_Entry is focused. 
  1895.  
  1896.    procedure Grab_Focus (Widget : not null access Gtk_Widget_Record); 
  1897.    --  Causes Widget to have the keyboard focus for the Gtk.Window.Gtk_Window 
  1898.    --  it's inside. Widget must be a focusable widget, such as a 
  1899.    --  Gtk.GEntry.Gtk_Entry; something like Gtk.Frame.Gtk_Frame won't work. 
  1900.    --  More precisely, it must have the GTK_CAN_FOCUS flag set. Use 
  1901.    --  Gtk.Widget.Set_Can_Focus to modify that flag. 
  1902.    --  The widget also needs to be realized and mapped. This is indicated by 
  1903.    --  the related signals. Grabbing the focus immediately after creating the 
  1904.    --  widget will likely fail and cause critical warnings. 
  1905.  
  1906.    procedure Grab_Remove (Widget : not null access Gtk_Widget_Record); 
  1907.    --  Removes the grab from the given widget. 
  1908.    --  You have to pair calls to Gtk.Widget.Grab_Add and 
  1909.    --  Gtk.Widget.Grab_Remove. 
  1910.    --  If Widget does not have the grab, this function does nothing. 
  1911.  
  1912.    function Has_Default 
  1913.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  1914.    --  Determines whether Widget is the current default widget within its 
  1915.    --  toplevel. See Gtk.Widget.Set_Can_Default. 
  1916.    --  Since: gtk+ 2.18 
  1917.  
  1918.    function Has_Focus 
  1919.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  1920.    --  Determines if the widget has the global input focus. See 
  1921.    --  Gtk.Widget.Is_Focus for the difference between having the global input 
  1922.    --  focus, and only having the focus within a toplevel. 
  1923.    --  Since: gtk+ 2.18 
  1924.  
  1925.    function Has_Grab 
  1926.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  1927.    --  Determines whether the widget is currently grabbing events, so it is 
  1928.    --  the only widget receiving input events (keyboard and mouse). 
  1929.    --  See also Gtk.Widget.Grab_Add. 
  1930.    --  Since: gtk+ 2.18 
  1931.  
  1932.    function Has_Rc_Style 
  1933.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  1934.    pragma Obsolescent (Has_Rc_Style); 
  1935.    --  Determines if the widget style has been looked up through the rc 
  1936.    --  mechanism. 
  1937.    --  Since: gtk+ 2.20 
  1938.    --  Deprecated since 3.0, Use Gtk.Style_Context.Gtk_Style_Context instead 
  1939.  
  1940.    function Has_Screen 
  1941.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  1942.    --  Checks whether there is a Gdk.Screen.Gdk_Screen is associated with this 
  1943.    --  widget. All toplevel widgets have an associated screen, and all widgets 
  1944.    --  added into a hierarchy with a toplevel window at the top. 
  1945.    --  Since: gtk+ 2.2 
  1946.  
  1947.    function Has_Visible_Focus 
  1948.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  1949.    --  Determines if the widget should show a visible indication that it has 
  1950.    --  the global input focus. This is a convenience function for use in ::draw 
  1951.    --  handlers that takes into account whether focus indication should 
  1952.    --  currently be shown in the toplevel window of Widget. See 
  1953.    --  Gtk.Window.Get_Focus_Visible for more information about focus 
  1954.    --  indication. 
  1955.    --  To find out if the widget has the global input focus, use 
  1956.    --  Gtk.Widget.Has_Focus. 
  1957.    --  Since: gtk+ 3.2 
  1958.  
  1959.    procedure Hide (Widget : not null access Gtk_Widget_Record); 
  1960.    --  Reverses the effects of Gtk.Widget.Show, causing the widget to be 
  1961.    --  hidden (invisible to the user). 
  1962.  
  1963.    function Hide_On_Delete 
  1964.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  1965.    --  Utility function; intended to be connected to the 
  1966.    --  Gtk.Widget.Gtk_Widget::delete-event signal on a Gtk.Window.Gtk_Window. 
  1967.    --  The function calls Gtk.Widget.Hide on its argument, then returns True. 
  1968.    --  If connected to ::delete-event, the result is that clicking the close 
  1969.    --  button for a window (on the window frame, top right corner usually) will 
  1970.    --  hide but not destroy the window. By default, GTK+ destroys windows when 
  1971.    --  ::delete-event is received. 
  1972.  
  1973.    function In_Destruction 
  1974.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  1975.    --  Returns whether the widget is currently being destroyed. This 
  1976.    --  information can sometimes be used to avoid doing unnecessary work. 
  1977.  
  1978.    procedure Input_Shape_Combine_Region 
  1979.       (Widget : not null access Gtk_Widget_Record; 
  1980.        Region : Cairo.Region.Cairo_Region); 
  1981.    --  Sets an input shape for this widget's GDK window. This allows for 
  1982.    --  windows which react to mouse click in a nonrectangular region, see 
  1983.    --  Gdk.Window.Input_Shape_Combine_Region for more information. 
  1984.    --  Since: gtk+ 3.0 
  1985.    --  "region": shape to be added, or null to remove an existing shape 
  1986.  
  1987.    function Intersect 
  1988.       (Widget       : not null access Gtk_Widget_Record; 
  1989.        Area         : Gdk.Rectangle.Gdk_Rectangle; 
  1990.        Intersection : access Gdk.Rectangle.Gdk_Rectangle) return Boolean; 
  1991.    --  Computes the intersection of a Widget's area and Area, storing the 
  1992.    --  intersection in Intersection, and returns True if there was an 
  1993.    --  intersection. Intersection may be null if you're only interested in 
  1994.    --  whether there was an intersection. 
  1995.    --  "area": a rectangle 
  1996.    --  "intersection": rectangle to store intersection of Widget and Area 
  1997.  
  1998.    function Is_Ancestor 
  1999.       (Widget   : not null access Gtk_Widget_Record; 
  2000.        Ancestor : not null access Gtk_Widget_Record'Class) return Boolean; 
  2001.    --  Determines whether Widget is somewhere inside Ancestor, possibly with 
  2002.    --  intermediate containers. 
  2003.    --  "ancestor": another Gtk.Widget.Gtk_Widget 
  2004.  
  2005.    function Is_Composited 
  2006.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  2007.    --  Whether Widget can rely on having its alpha channel drawn correctly. On 
  2008.    --  X11 this function returns whether a compositing manager is running for 
  2009.    --  Widget's screen. 
  2010.    --  Please note that the semantics of this call will change in the future 
  2011.    --  if used on a widget that has a composited window in its hierarchy (as 
  2012.    --  set by Gdk.Window.Set_Composited). 
  2013.    --  Since: gtk+ 2.10 
  2014.  
  2015.    function Is_Drawable 
  2016.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  2017.    --  Determines whether Widget can be drawn to. A widget can be drawn to if 
  2018.    --  it is mapped and visible. 
  2019.    --  Since: gtk+ 2.18 
  2020.  
  2021.    function Is_Focus 
  2022.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  2023.    --  Determines if the widget is the focus widget within its toplevel. (This 
  2024.    --  does not mean that the HAS_FOCUS flag is necessarily set; HAS_FOCUS will 
  2025.    --  only be set if the toplevel widget additionally has the global input 
  2026.    --  focus.) 
  2027.  
  2028.    function Is_Sensitive 
  2029.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  2030.    --  Returns the widget's effective sensitivity, which means it is sensitive 
  2031.    --  itself and also its parent widget is sensitive 
  2032.    --  Since: gtk+ 2.18 
  2033.  
  2034.    function Is_Toplevel 
  2035.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  2036.    --  Determines whether Widget is a toplevel widget. 
  2037.    --  Currently only Gtk.Window.Gtk_Window and Gtk.Invisible.Gtk_Invisible 
  2038.    --  (and out-of-process Gtk_Plugs) are toplevel widgets. Toplevel widgets 
  2039.    --  have no parent widget. 
  2040.    --  Since: gtk+ 2.18 
  2041.  
  2042.    function Is_Visible 
  2043.       (Widget : not null access Gtk_Widget_Record) return Boolean; 
  2044.    --  Determines whether the widget and all its parents are marked as 
  2045.    --  visible. 
  2046.    --  This function does not check if the widget is obscured in any way. 
  2047.    --  See also Gtk.Widget.Get_Visible and Gtk.Widget.Set_Visible 
  2048.    --  Since: gtk+ 3.8 
  2049.  
  2050.    function Keynav_Failed 
  2051.       (Widget    : not null access Gtk_Widget_Record; 
  2052.        Direction : Gtk.Enums.Gtk_Direction_Type) return Boolean; 
  2053.    --  This function should be called whenever keyboard navigation within a 
  2054.    --  single widget hits a boundary. The function emits the 
  2055.    --  Gtk.Widget.Gtk_Widget::keynav-failed signal on the widget and its return 
  2056.    --  value should be interpreted in a way similar to the return value of 
  2057.    --  Gtk.Widget.Child_Focus: 
  2058.    --  When True is returned, stay in the widget, the failed keyboard 
  2059.    --  navigation is Ok and/or there is nowhere we can/should move the focus 
  2060.    --  to. 
  2061.    --  When False is returned, the caller should continue with keyboard 
  2062.    --  navigation outside the widget, e.g. by calling Gtk.Widget.Child_Focus on 
  2063.    --  the widget's toplevel. 
  2064.    --  The default ::keynav-failed handler returns True for 
  2065.    --  Gtk.Enums.Dir_Tab_Forward and Gtk.Enums.Dir_Tab_Backward. For the other 
  2066.    --  values of Gtk.Enums.Gtk_Direction_Type, it looks at the 
  2067.    --  Gtk.Settings.Gtk_Settings:gtk-keynav-cursor-only setting and returns 
  2068.    --  False if the setting is True. This way the entire user interface becomes 
  2069.    --  cursor-navigatable on input devices such as mobile phones which only 
  2070.    --  have cursor keys but no tab key. 
  2071.    --  Whenever the default handler returns True, it also calls 
  2072.    --  Gtk.Widget.Error_Bell to notify the user of the failed keyboard 
  2073.    --  navigation. 
  2074.    --  A use case for providing an own implementation of ::keynav-failed 
  2075.    --  (either by connecting to it or by overriding it) would be a row of 
  2076.    --  Gtk.GEntry.Gtk_Entry widgets where the user should be able to navigate 
  2077.    --  the entire row with the cursor keys, as e.g. known from user interfaces 
  2078.    --  that require entering license keys. 
  2079.    --  Since: gtk+ 2.12 
  2080.    --  "direction": direction of focus movement 
  2081.  
  2082.    function List_Mnemonic_Labels 
  2083.       (Widget : not null access Gtk_Widget_Record) return Widget_List.Glist; 
  2084.    --  Returns a newly allocated list of the widgets, normally labels, for 
  2085.    --  which this widget is the target of a mnemonic (see for example, 
  2086.    --  Gtk.Label.Set_Mnemonic_Widget). 
  2087.    --  The widgets in the list are not individually referenced. If you want to 
  2088.    --  iterate through the list and perform actions involving callbacks that 
  2089.    --  might destroy the widgets, you *must* call 'g_list_foreach (result, 
  2090.    --  (GFunc)g_object_ref, NULL)' first, and then unref all the widgets 
  2091.    --  afterwards. 
  2092.    --  Since: gtk+ 2.4 
  2093.  
  2094.    procedure Map (Widget : not null access Gtk_Widget_Record); 
  2095.    --  This function is only for use in widget implementations. Causes a 
  2096.    --  widget to be mapped if it isn't already. 
  2097.  
  2098.    function Mnemonic_Activate 
  2099.       (Widget        : not null access Gtk_Widget_Record; 
  2100.        Group_Cycling : Boolean) return Boolean; 
  2101.    --  Emits the Gtk.Widget.Gtk_Widget::mnemonic-activate signal. 
  2102.    --  The default handler for this signal activates the Widget if 
  2103.    --  Group_Cycling is False, and just grabs the focus if Group_Cycling is 
  2104.    --  True. 
  2105.    --  "group_cycling": True if there are other widgets with the same mnemonic 
  2106.  
  2107.    procedure Modify_Base 
  2108.       (Widget : not null access Gtk_Widget_Record; 
  2109.        State  : Gtk.Enums.Gtk_State_Type; 
  2110.        Color  : Gdk.Color.Gdk_Color); 
  2111.    pragma Obsolescent (Modify_Base); 
  2112.    --  Sets the base color for a widget in a particular state. All other style 
  2113.    --  values are left untouched. The base color is the background color used 
  2114.    --  along with the text color (see Gtk.Widget.Modify_Text) for widgets such 
  2115.    --  as Gtk.GEntry.Gtk_Entry and Gtk.Text_View.Gtk_Text_View. See also 
  2116.    --  gtk_widget_modify_style. 
  2117.    --  Note: 
  2118.    --  Note that "no window" widgets (which have the GTK_NO_WINDOW flag set) 
  2119.    --  draw on their parent container's window and thus may not draw any 
  2120.    --  background themselves. This is the case for e.g. Gtk.Label.Gtk_Label. 
  2121.    --  To modify the background of such widgets, you have to set the base 
  2122.    --  color on their parent; if you want to set the background of a 
  2123.    --  rectangular area around a label, try placing the label in a 
  2124.    --  Gtk.Event_Box.Gtk_Event_Box widget and setting the base color on that. 
  2125.    --  Deprecated since 3.0, Use Gtk.Widget.Override_Background_Color instead 
  2126.    --  "state": the state for which to set the base color 
  2127.    --  "color": the color to assign (does not need to be allocated), or null 
  2128.    --  to undo the effect of previous calls to of Gtk.Widget.Modify_Base. 
  2129.  
  2130.    procedure Modify_Bg 
  2131.       (Widget : not null access Gtk_Widget_Record; 
  2132.        State  : Gtk.Enums.Gtk_State_Type; 
  2133.        Color  : Gdk.Color.Gdk_Color); 
  2134.    pragma Obsolescent (Modify_Bg); 
  2135.    --  Sets the background color for a widget in a particular state. 
  2136.    --  All other style values are left untouched. See also 
  2137.    --  gtk_widget_modify_style. 
  2138.    --  Note: 
  2139.    --  Note that "no window" widgets (which have the GTK_NO_WINDOW flag set) 
  2140.    --  draw on their parent container's window and thus may not draw any 
  2141.    --  background themselves. This is the case for e.g. Gtk.Label.Gtk_Label. 
  2142.    --  To modify the background of such widgets, you have to set the 
  2143.    --  background color on their parent; if you want to set the background of a 
  2144.    --  rectangular area around a label, try placing the label in a 
  2145.    --  Gtk.Event_Box.Gtk_Event_Box widget and setting the background color on 
  2146.    --  that. 
  2147.    --  Deprecated since 3.0, Use Gtk.Widget.Override_Background_Color instead 
  2148.    --  "state": the state for which to set the background color 
  2149.    --  "color": the color to assign (does not need to be allocated), or null 
  2150.    --  to undo the effect of previous calls to of Gtk.Widget.Modify_Bg. 
  2151.  
  2152.    procedure Modify_Cursor 
  2153.       (Widget    : not null access Gtk_Widget_Record; 
  2154.        Primary   : Gdk.Color.Gdk_Color; 
  2155.        Secondary : Gdk.Color.Gdk_Color); 
  2156.    pragma Obsolescent (Modify_Cursor); 
  2157.    --  Sets the cursor color to use in a widget, overriding the 
  2158.    --  Gtk.Widget.Gtk_Widget:cursor-color and 
  2159.    --  Gtk.Widget.Gtk_Widget:secondary-cursor-color style properties. 
  2160.    --  All other style values are left untouched. See also 
  2161.    --  gtk_widget_modify_style. 
  2162.    --  Since: gtk+ 2.12 
  2163.    --  Deprecated since None, 3.0. Use Gtk.Widget.Override_Cursor instead. 
  2164.    --  "primary": the color to use for primary cursor (does not need to be 
  2165.    --  allocated), or null to undo the effect of previous calls to of 
  2166.    --  Gtk.Widget.Modify_Cursor. 
  2167.    --  "secondary": the color to use for secondary cursor (does not need to be 
  2168.    --  allocated), or null to undo the effect of previous calls to of 
  2169.    --  Gtk.Widget.Modify_Cursor. 
  2170.  
  2171.    procedure Modify_Fg 
  2172.       (Widget : not null access Gtk_Widget_Record; 
  2173.        State  : Gtk.Enums.Gtk_State_Type; 
  2174.        Color  : Gdk.Color.Gdk_Color); 
  2175.    pragma Obsolescent (Modify_Fg); 
  2176.    --  Sets the foreground color for a widget in a particular state. 
  2177.    --  All other style values are left untouched. See also 
  2178.    --  gtk_widget_modify_style. 
  2179.    --  Deprecated since 3.0, Use Gtk.Widget.Override_Color instead 
  2180.    --  "state": the state for which to set the foreground color 
  2181.    --  "color": the color to assign (does not need to be allocated), or null 
  2182.    --  to undo the effect of previous calls to of Gtk.Widget.Modify_Fg. 
  2183.  
  2184.    procedure Modify_Font 
  2185.       (Widget    : not null access Gtk_Widget_Record; 
  2186.        Font_Desc : Pango.Font.Pango_Font_Description); 
  2187.    pragma Obsolescent (Modify_Font); 
  2188.    --  Sets the font to use for a widget. 
  2189.    --  All other style values are left untouched. See also 
  2190.    --  gtk_widget_modify_style. 
  2191.    --  Deprecated since 3.0, Use Gtk.Widget.Override_Font instead 
  2192.    --  "font_desc": the font description to use, or null to undo the effect of 
  2193.    --  previous calls to Gtk.Widget.Modify_Font 
  2194.  
  2195.    procedure Modify_Text 
  2196.       (Widget : not null access Gtk_Widget_Record; 
  2197.        State  : Gtk.Enums.Gtk_State_Type; 
  2198.        Color  : Gdk.Color.Gdk_Color); 
  2199.    pragma Obsolescent (Modify_Text); 
  2200.    --  Sets the text color for a widget in a particular state. 
  2201.    --  All other style values are left untouched. The text color is the 
  2202.    --  foreground color used along with the base color (see 
  2203.    --  Gtk.Widget.Modify_Base) for widgets such as Gtk.GEntry.Gtk_Entry and 
  2204.    --  Gtk.Text_View.Gtk_Text_View. See also gtk_widget_modify_style. 
  2205.    --  Deprecated since 3.0, Use Gtk.Widget.Override_Color instead 
  2206.    --  "state": the state for which to set the text color 
  2207.    --  "color": the color to assign (does not need to be allocated), or null 
  2208.    --  to undo the effect of previous calls to of Gtk.Widget.Modify_Text. 
  2209.  
  2210.    procedure Override_Background_Color 
  2211.       (Widget : not null access Gtk_Widget_Record; 
  2212.        State  : Gtk.Enums.Gtk_State_Flags; 
  2213.        Color  : Gdk.RGBA.Gdk_RGBA); 
  2214.    --  Sets the background color to use for a widget. 
  2215.    --  All other style values are left untouched. See 
  2216.    --  Gtk.Widget.Override_Color. 
  2217.    --  Since: gtk+ 3.0 
  2218.    --  "state": the state for which to set the background color 
  2219.    --  "color": the color to assign, or null to undo the effect of previous 
  2220.    --  calls to Gtk.Widget.Override_Background_Color 
  2221.  
  2222.    procedure Override_Color 
  2223.       (Widget : not null access Gtk_Widget_Record; 
  2224.        State  : Gtk.Enums.Gtk_State_Flags; 
  2225.        Color  : Gdk.RGBA.Gdk_RGBA); 
  2226.    --  Sets the color to use for a widget. 
  2227.    --  All other style values are left untouched. 
  2228.    --  Note: 
  2229.    --  This API is mostly meant as a quick way for applications to change a 
  2230.    --  widget appearance. If you are developing a widgets library and intend 
  2231.    --  this change to be themeable, it is better done by setting meaningful CSS 
  2232.    --  classes and regions in your widget/container implementation through 
  2233.    --  Gtk.Style_Context.Add_Class and Gtk.Style_Context.Add_Region. 
  2234.    --  This way, your widget library can install a 
  2235.    --  Gtk.Css_Provider.Gtk_Css_Provider with the 
  2236.    --  GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order to provide a 
  2237.    --  default styling for those widgets that need so, and this theming may 
  2238.    --  fully overridden by the user's theme. 
  2239.    --  Note: 
  2240.    --  Note that for complex widgets this may bring in undesired results (such 
  2241.    --  as uniform background color everywhere), in these cases it is better to 
  2242.    --  fully style such widgets through a Gtk.Css_Provider.Gtk_Css_Provider 
  2243.    --  with the GTK_STYLE_PROVIDER_PRIORITY_APPLICATION priority. 
  2244.    --  Since: gtk+ 3.0 
  2245.    --  "state": the state for which to set the color 
  2246.    --  "color": the color to assign, or null to undo the effect of previous 
  2247.    --  calls to Gtk.Widget.Override_Color 
  2248.  
  2249.    procedure Override_Cursor 
  2250.       (Widget           : not null access Gtk_Widget_Record; 
  2251.        Cursor           : Gdk.RGBA.Gdk_RGBA; 
  2252.        Secondary_Cursor : Gdk.RGBA.Gdk_RGBA); 
  2253.    --  Sets the cursor color to use in a widget, overriding the 
  2254.    --  Gtk.Widget.Gtk_Widget:cursor-color and 
  2255.    --  Gtk.Widget.Gtk_Widget:secondary-cursor-color style properties. All other 
  2256.    --  style values are left untouched. See also gtk_widget_modify_style. 
  2257.    --  Note that the underlying properties have the Gdk.Color.Gdk_Color type, 
  2258.    --  so the alpha value in Primary and Secondary will be ignored. 
  2259.    --  Since: gtk+ 3.0 
  2260.    --  "cursor": the color to use for primary cursor (does not need to be 
  2261.    --  allocated), or null to undo the effect of previous calls to of 
  2262.    --  Gtk.Widget.Override_Cursor. 
  2263.    --  "secondary_cursor": the color to use for secondary cursor (does not 
  2264.    --  need to be allocated), or null to undo the effect of previous calls to 
  2265.    --  of Gtk.Widget.Override_Cursor. 
  2266.  
  2267.    procedure Override_Font 
  2268.       (Widget    : not null access Gtk_Widget_Record; 
  2269.        Font_Desc : Pango.Font.Pango_Font_Description); 
  2270.    --  Sets the font to use for a widget. All other style values are left 
  2271.    --  untouched. See Gtk.Widget.Override_Color. 
  2272.    --  Since: gtk+ 3.0 
  2273.    --  "font_desc": the font descriptiong to use, or null to undo the effect 
  2274.    --  of previous calls to Gtk.Widget.Override_Font 
  2275.  
  2276.    procedure Override_Symbolic_Color 
  2277.       (Widget : not null access Gtk_Widget_Record; 
  2278.        Name   : UTF8_String; 
  2279.        Color  : Gdk.RGBA.Gdk_RGBA); 
  2280.    --  Sets a symbolic color for a widget. 
  2281.    --  All other style values are left untouched. See 
  2282.    --  Gtk.Widget.Override_Color for overriding the foreground or background 
  2283.    --  color. 
  2284.    --  Since: gtk+ 3.0 
  2285.    --  "name": the name of the symbolic color to modify 
  2286.    --  "color": the color to assign (does not need to be allocated), or null 
  2287.    --  to undo the effect of previous calls to 
  2288.    --  Gtk.Widget.Override_Symbolic_Color 
  2289.  
  2290.    procedure Queue_Compute_Expand 
  2291.       (Widget : not null access Gtk_Widget_Record); 
  2292.    --  Mark Widget as needing to recompute its expand flags. Call this 
  2293.    --  function when setting legacy expand child properties on the child of a 
  2294.    --  container. 
  2295.    --  See Gtk.Widget.Compute_Expand. 
  2296.  
  2297.    procedure Queue_Draw (Widget : not null access Gtk_Widget_Record); 
  2298.    --  Equivalent to calling Gtk.Widget.Queue_Draw_Area for the entire area of 
  2299.    --  a widget. 
  2300.  
  2301.    procedure Queue_Draw_Area 
  2302.       (Widget : not null access Gtk_Widget_Record; 
  2303.        X      : Gint; 
  2304.        Y      : Gint; 
  2305.        Width  : Gint; 
  2306.        Height : Gint); 
  2307.    --  Convenience function that calls Gtk.Widget.Queue_Draw_Region on the 
  2308.    --  region created from the given coordinates. 
  2309.    --  The region here is specified in widget coordinates. Widget coordinates 
  2310.    --  are a bit odd; for historical reasons, they are defined as 
  2311.    --  Widget->window coordinates for widgets that are not GTK_NO_WINDOW 
  2312.    --  widgets, and are relative to Widget->allocation.x, Widget->allocation.y 
  2313.    --  for widgets that are GTK_NO_WINDOW widgets. 
  2314.    --  "x": x coordinate of upper-left corner of rectangle to redraw 
  2315.    --  "y": y coordinate of upper-left corner of rectangle to redraw 
  2316.    --  "width": width of region to draw 
  2317.    --  "height": height of region to draw 
  2318.  
  2319.    procedure Queue_Draw_Region 
  2320.       (Widget : not null access Gtk_Widget_Record; 
  2321.        Region : Cairo.Region.Cairo_Region); 
  2322.    --  Invalidates the rectangular area of Widget defined by Region by calling 
  2323.    --  Gdk.Window.Invalidate_Region on the widget's window and all its child 
  2324.    --  windows. Once the main loop becomes idle (after the current batch of 
  2325.    --  events has been processed, roughly), the window will receive expose 
  2326.    --  events for the union of all regions that have been invalidated. 
  2327.    --  Normally you would only use this function in widget implementations. 
  2328.    --  You might also use it to schedule a redraw of a 
  2329.    --  Gtk.Drawing_Area.Gtk_Drawing_Area or some portion thereof. 
  2330.    --  Since: gtk+ 3.0 
  2331.    --  "region": region to draw 
  2332.  
  2333.    procedure Queue_Resize (Widget : not null access Gtk_Widget_Record); 
  2334.    --  This function is only for use in widget implementations. Flags a widget 
  2335.    --  to have its size renegotiated; should be called when a widget for some 
  2336.    --  reason has a new size request. For example, when you change the text in 
  2337.    --  a Gtk.Label.Gtk_Label, Gtk.Label.Gtk_Label queues a resize to ensure 
  2338.    --  there's enough space for the new text. 
  2339.    --  Note: 
  2340.    --  You cannot call Gtk.Widget.Queue_Resize on a widget from inside its 
  2341.    --  implementation of the GtkWidgetClass::size_allocate virtual method. 
  2342.    --  Calls to Gtk.Widget.Queue_Resize from inside 
  2343.    --  GtkWidgetClass::size_allocate will be silently ignored. 
  2344.  
  2345.    procedure Queue_Resize_No_Redraw 
  2346.       (Widget : not null access Gtk_Widget_Record); 
  2347.    --  This function works like Gtk.Widget.Queue_Resize, except that the 
  2348.    --  widget is not invalidated. 
  2349.    --  Since: gtk+ 2.4 
  2350.  
  2351.    procedure Realize (Widget : not null access Gtk_Widget_Record); 
  2352.    --  Creates the GDK (windowing system) resources associated with a widget. 
  2353.    --  For example, Widget->window will be created when a widget is realized. 
  2354.    --  Normally realization happens implicitly; if you show a widget and all 
  2355.    --  its parent containers, then the widget will be realized and mapped 
  2356.    --  automatically. 
  2357.    --  Realizing a widget requires all the widget's parent widgets to be 
  2358.    --  realized; calling Gtk.Widget.Realize realizes the widget's parents in 
  2359.    --  addition to Widget itself. If a widget is not yet inside a toplevel 
  2360.    --  window when you realize it, bad things will happen. 
  2361.    --  This function is primarily used in widget implementations, and isn't 
  2362.    --  very useful otherwise. Many times when you think you might need it, a 
  2363.    --  better approach is to connect to a signal that will be called after the 
  2364.    --  widget is realized automatically, such as Gtk.Widget.Gtk_Widget::draw. 
  2365.    --  Or simply g_signal_connect () to the Gtk.Widget.Gtk_Widget::realize 
  2366.    --  signal. 
  2367.  
  2368.    function Region_Intersect 
  2369.       (Widget : not null access Gtk_Widget_Record; 
  2370.        Region : Cairo.Region.Cairo_Region) return Cairo.Region.Cairo_Region; 
  2371.    --  Computes the intersection of a Widget's area and Region, returning the 
  2372.    --  intersection. The result may be empty, use cairo_region_is_empty to 
  2373.    --  check. 
  2374.    --  "region": a cairo_region_t, in the same coordinate system as 
  2375.    --  Widget->allocation. That is, relative to Widget->window for NO_WINDOW 
  2376.    --  widgets; relative to the parent window of Widget->window for widgets 
  2377.    --  with their own window. 
  2378.  
  2379.    procedure Register_Window 
  2380.       (Widget : not null access Gtk_Widget_Record; 
  2381.        Window : Gdk.Gdk_Window); 
  2382.    --  Registers a Gdk.Gdk_Window with the widget and sets it up so that the 
  2383.    --  widget recieves events for it. Call Gtk.Widget.Unregister_Window when 
  2384.    --  destroying the window. 
  2385.    --  Before 3.8 you needed to call Gdk.Window.Set_User_Data directly to set 
  2386.    --  this up. This is now deprecated and you should use 
  2387.    --  Gtk.Widget.Register_Window instead. Old code will keep working as is, 
  2388.    --  although some new features like transparency might not work perfectly. 
  2389.    --  Since: gtk+ 3.8 
  2390.    --  "window": a Gdk.Gdk_Window 
  2391.  
  2392.    function Remove_Accelerator 
  2393.       (Widget      : not null access Gtk_Widget_Record; 
  2394.        Accel_Group : not null access Gtk.Accel_Group.Gtk_Accel_Group_Record'Class; 
  2395.        Accel_Key   : Gdk.Types.Gdk_Key_Type; 
  2396.        Accel_Mods  : Gdk.Types.Gdk_Modifier_Type) return Boolean; 
  2397.    --  Removes an accelerator from Widget, previously installed with 
  2398.    --  Gtk.Widget.Add_Accelerator. 
  2399.    --  "accel_group": accel group for this widget 
  2400.    --  "accel_key": GDK keyval of the accelerator 
  2401.    --  "accel_mods": modifier key combination of the accelerator 
  2402.  
  2403.    procedure Remove_Mnemonic_Label 
  2404.       (Widget : not null access Gtk_Widget_Record; 
  2405.        Label  : not null access Gtk_Widget_Record'Class); 
  2406.    --  Removes a widget from the list of mnemonic labels for this widget. (See 
  2407.    --  Gtk.Widget.List_Mnemonic_Labels). The widget must have previously been 
  2408.    --  added to the list with Gtk.Widget.Add_Mnemonic_Label. 
  2409.    --  Since: gtk+ 2.4 
  2410.    --  "label": a Gtk.Widget.Gtk_Widget that was previously set as a mnemnic 
  2411.    --  label for Widget with Gtk.Widget.Add_Mnemonic_Label. 
  2412.  
  2413.    procedure Remove_Tick_Callback 
  2414.       (Widget : not null access Gtk_Widget_Record; 
  2415.        Id     : Guint); 
  2416.    --  Removes a tick callback previously registered with 
  2417.    --  Gtk.Widget.Add_Tick_Callback. 
  2418.    --  Since: gtk+ 3.8 
  2419.    --  "id": an id returned by Gtk.Widget.Add_Tick_Callback 
  2420.  
  2421.    function Render_Icon 
  2422.       (Widget   : not null access Gtk_Widget_Record; 
  2423.        Stock_Id : UTF8_String; 
  2424.        Size     : Gtk.Enums.Gtk_Icon_Size; 
  2425.        Detail   : UTF8_String := "") return Gdk.Pixbuf.Gdk_Pixbuf; 
  2426.    pragma Obsolescent (Render_Icon); 
  2427.    --  A convenience function that uses the theme settings for Widget to look 
  2428.    --  up Stock_Id and render it to a pixbuf. Stock_Id should be a stock icon 
  2429.    --  ID such as GTK_STOCK_OPEN or GTK_STOCK_OK. Size should be a size such as 
  2430.    --  GTK_ICON_SIZE_MENU. Detail should be a string that identifies the widget 
  2431.    --  or code doing the rendering, so that theme engines can special-case 
  2432.    --  rendering for that widget or code. 
  2433.    --  The pixels in the returned Gdk.Pixbuf.Gdk_Pixbuf are shared with the 
  2434.    --  rest of the application and should not be modified. The pixbuf should be 
  2435.    --  freed after use with g_object_unref. 
  2436.    --  Deprecated since 3.0, Use Gtk.Widget.Render_Icon_Pixbuf instead. 
  2437.    --  "stock_id": a stock ID 
  2438.    --  "size": a stock size. A size of (GtkIconSize)-1 means render at the 
  2439.    --  size of the source and don't scale (if there are multiple source sizes, 
  2440.    --  GTK+ picks one of the available sizes). 
  2441.    --  "detail": render detail to pass to theme engine 
  2442.  
  2443.    function Render_Icon_Pixbuf 
  2444.       (Widget   : not null access Gtk_Widget_Record; 
  2445.        Stock_Id : UTF8_String; 
  2446.        Size     : Gtk.Enums.Gtk_Icon_Size) return Gdk.Pixbuf.Gdk_Pixbuf; 
  2447.    --  A convenience function that uses the theme engine and style settings 
  2448.    --  for Widget to look up Stock_Id and render it to a pixbuf. Stock_Id 
  2449.    --  should be a stock icon ID such as GTK_STOCK_OPEN or GTK_STOCK_OK. Size 
  2450.    --  should be a size such as GTK_ICON_SIZE_MENU. 
  2451.    --  The pixels in the returned Gdk.Pixbuf.Gdk_Pixbuf are shared with the 
  2452.    --  rest of the application and should not be modified. The pixbuf should be 
  2453.    --  freed after use with g_object_unref. 
  2454.    --  Since: gtk+ 3.0 
  2455.    --  "stock_id": a stock ID 
  2456.    --  "size": a stock size. A size of (GtkIconSize)-1 means render at the 
  2457.    --  size of the source and don't scale (if there are multiple source sizes, 
  2458.    --  GTK+ picks one of the available sizes). 
  2459.  
  2460.    procedure Reparent 
  2461.       (Widget     : not null access Gtk_Widget_Record; 
  2462.        New_Parent : not null access Gtk_Widget_Record'Class); 
  2463.    --  Moves a widget from one Gtk.Container.Gtk_Container to another, 
  2464.    --  handling reference count issues to avoid destroying the widget. 
  2465.    --  "new_parent": a Gtk.Container.Gtk_Container to move the widget into 
  2466.  
  2467.    procedure Reset_Rc_Styles (Widget : not null access Gtk_Widget_Record); 
  2468.    pragma Obsolescent (Reset_Rc_Styles); 
  2469.    --  Reset the styles of Widget and all descendents, so when they are looked 
  2470.    --  up again, they get the correct values for the currently loaded RC file 
  2471.    --  settings. 
  2472.    --  This function is not useful for applications. 
  2473.    --  Deprecated since 3.0, Use Gtk.Style_Context.Gtk_Style_Context instead, 
  2474.    --  and Gtk.Widget.Reset_Style 
  2475.  
  2476.    procedure Reset_Style (Widget : not null access Gtk_Widget_Record); 
  2477.    --  Updates the style context of Widget and all descendents by updating its 
  2478.    --  widget path. Gtk.Container.Gtk_Container<!-- -->s may want to use this 
  2479.    --  on a child when reordering it in a way that a different style might 
  2480.    --  apply to it. See also Gtk.Container.Get_Path_For_Child. 
  2481.    --  Since: gtk+ 3.0 
  2482.  
  2483.    function Send_Expose 
  2484.       (Widget : not null access Gtk_Widget_Record; 
  2485.        Event  : Gdk.Event.Gdk_Event) return Gint; 
  2486.    --  Very rarely-used function. This function is used to emit an expose 
  2487.    --  event on a widget. This function is not normally used directly. The only 
  2488.    --  time it is used is when propagating an expose event to a child NO_WINDOW 
  2489.    --  widget, and that is normally done using Gtk.Container.Propagate_Draw. 
  2490.    --  If you want to force an area of a window to be redrawn, use 
  2491.    --  Gdk.Window.Invalidate_Rect or Gdk.Window.Invalidate_Region. To cause the 
  2492.    --  redraw to be done immediately, follow that call with a call to 
  2493.    --  Gdk.Window.Process_Updates. 
  2494.    --  "event": a expose Gdk.Event.Gdk_Event 
  2495.  
  2496.    function Send_Focus_Change 
  2497.       (Widget : not null access Gtk_Widget_Record; 
  2498.        Event  : Gdk.Event.Gdk_Event) return Boolean; 
  2499.    --  Sends the focus change Event to Widget 
  2500.    --  This function is not meant to be used by applications. The only time it 
  2501.    --  should be used is when it is necessary for a Gtk.Widget.Gtk_Widget to 
  2502.    --  assign focus to a widget that is semantically owned by the first widget 
  2503.    --  even though it's not a direct child - for instance, a search entry in a 
  2504.    --  floating window similar to the quick search in 
  2505.    --  Gtk.Tree_View.Gtk_Tree_View. 
  2506.    --  An example of its usage is: 
  2507.    --  |[ GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE); 
  2508.    --  fevent->focus_change.type = GDK_FOCUS_CHANGE; fevent->focus_change.in = 
  2509.    --  TRUE; fevent->focus_change.window = gtk_widget_get_window (widget); if 
  2510.    --  (fevent->focus_change.window != NULL) g_object_ref 
  2511.    --  (fevent->focus_change.window); 
  2512.    --  gtk_widget_send_focus_change (widget, fevent); 
  2513.    --  gdk_event_free (event); ]| 
  2514.    --  Since: gtk+ 2.20 
  2515.    --  "event": a Gdk.Event.Gdk_Event of type GDK_FOCUS_CHANGE 
  2516.  
  2517.    procedure Set_Accel_Path 
  2518.       (Widget      : not null access Gtk_Widget_Record; 
  2519.        Accel_Path  : UTF8_String := ""; 
  2520.        Accel_Group : access Gtk.Accel_Group.Gtk_Accel_Group_Record'Class); 
  2521.    --  Given an accelerator group, Accel_Group, and an accelerator path, 
  2522.    --  Accel_Path, sets up an accelerator in Accel_Group so whenever the key 
  2523.    --  binding that is defined for Accel_Path is pressed, Widget will be 
  2524.    --  activated. This removes any accelerators (for any accelerator group) 
  2525.    --  installed by previous calls to Gtk.Widget.Set_Accel_Path. Associating 
  2526.    --  accelerators with paths allows them to be modified by the user and the 
  2527.    --  modifications to be saved for future use. (See Gtk.Accel_Map.Save.) 
  2528.    --  This function is a low level function that would most likely be used by 
  2529.    --  a menu creation system like Gtk.UI_Manager.Gtk_UI_Manager. If you use 
  2530.    --  Gtk.UI_Manager.Gtk_UI_Manager, setting up accelerator paths will be done 
  2531.    --  automatically. 
  2532.    --  Even when you you aren't using Gtk.UI_Manager.Gtk_UI_Manager, if you 
  2533.    --  only want to set up accelerators on menu items 
  2534.    --  Gtk.Menu_Item.Set_Accel_Path provides a somewhat more convenient 
  2535.    --  interface. 
  2536.    --  Note that Accel_Path string will be stored in a Glib.GQuark. Therefore, 
  2537.    --  if you pass a static string, you can save some memory by interning it 
  2538.    --  first with g_intern_static_string. 
  2539.    --  "accel_path": path used to look up the accelerator 
  2540.    --  "accel_group": a Gtk.Accel_Group.Gtk_Accel_Group. 
  2541.  
  2542.    procedure Set_Redraw_On_Allocate 
  2543.       (Widget             : not null access Gtk_Widget_Record; 
  2544.        Redraw_On_Allocate : Boolean); 
  2545.    --  Sets whether the entire widget is queued for drawing when its size 
  2546.    --  allocation changes. By default, this setting is True and the entire 
  2547.    --  widget is redrawn on every size change. If your widget leaves the upper 
  2548.    --  left unchanged when made bigger, turning this setting off will improve 
  2549.    --  performance. 
  2550.    --  Note that for NO_WINDOW widgets setting this flag to False turns off 
  2551.    --  all allocation on resizing: the widget will not even redraw if its 
  2552.    --  position changes; this is to allow containers that don't draw anything 
  2553.    --  to avoid excess invalidations. If you set this flag on a NO_WINDOW 
  2554.    --  widget that *does* draw on Widget->window, you are responsible for 
  2555.    --  invalidating both the old and new allocation of the widget when the 
  2556.    --  widget is moved and responsible for invalidating regions newly when the 
  2557.    --  widget increases size. 
  2558.    --  "redraw_on_allocate": if True, the entire widget will be redrawn when 
  2559.    --  it is allocated to a new size. Otherwise, only the new portion of the 
  2560.    --  widget will be redrawn. 
  2561.  
  2562.    procedure Shape_Combine_Region 
  2563.       (Widget : not null access Gtk_Widget_Record; 
  2564.        Region : Cairo.Region.Cairo_Region); 
  2565.    --  Sets a shape for this widget's GDK window. This allows for transparent 
  2566.    --  windows etc., see Gdk.Window.Shape_Combine_Region for more information. 
  2567.    --  Since: gtk+ 3.0 
  2568.    --  "region": shape to be added, or null to remove an existing shape 
  2569.  
  2570.    procedure Show (Widget : not null access Gtk_Widget_Record); 
  2571.    --  Flags a widget to be displayed. Any widget that isn't shown will not 
  2572.    --  appear on the screen. If you want to show all the widgets in a 
  2573.    --  container, it's easier to call Gtk.Widget.Show_All on the container, 
  2574.    --  instead of individually showing the widgets. 
  2575.    --  Remember that you have to show the containers containing a widget, in 
  2576.    --  addition to the widget itself, before it will appear onscreen. 
  2577.    --  When a toplevel container is shown, it is immediately realized and 
  2578.    --  mapped; other shown widgets are realized and mapped when their toplevel 
  2579.    --  container is realized and mapped. 
  2580.  
  2581.    procedure Show_All (Widget : not null access Gtk_Widget_Record); 
  2582.    --  Recursively shows a widget, and any child widgets (if the widget is a 
  2583.    --  container). 
  2584.  
  2585.    procedure Show_Now (Widget : not null access Gtk_Widget_Record); 
  2586.    --  Shows a widget. If the widget is an unmapped toplevel widget (i.e. a 
  2587.    --  Gtk.Window.Gtk_Window that has not yet been shown), enter the main loop 
  2588.    --  and wait for the window to actually be mapped. Be careful; because the 
  2589.    --  main loop is running, anything can happen during this function. 
  2590.  
  2591.    procedure Size_Allocate 
  2592.       (Widget     : not null access Gtk_Widget_Record; 
  2593.        Allocation : Gtk_Allocation); 
  2594.    --  This function is only used by Gtk.Container.Gtk_Container subclasses, 
  2595.    --  to assign a size and position to their child widgets. 
  2596.    --  In this function, the allocation may be adjusted. It will be forced to 
  2597.    --  a 1x1 minimum size, and the adjust_size_allocation virtual method on the 
  2598.    --  child will be used to adjust the allocation. Standard adjustments 
  2599.    --  include removing the widget's margins, and applying the widget's 
  2600.    --  Gtk.Widget.Gtk_Widget:halign and Gtk.Widget.Gtk_Widget:valign 
  2601.    --  properties. 
  2602.    --  "allocation": position and size to be allocated to Widget 
  2603.  
  2604.    procedure Style_Attach (Widget : not null access Gtk_Widget_Record); 
  2605.    pragma Obsolescent (Style_Attach); 
  2606.    --  This function attaches the widget's Gtk.Style.Gtk_Style to the widget's 
  2607.    --  Gdk.Gdk_Window. It is a replacement for 
  2608.    --    widget->style = gtk_style_attach (widget->style, widget->window); 
  2609.    --  and should only ever be called in a derived widget's "realize" 
  2610.    --  implementation which does not chain up to its parent class' "realize" 
  2611.    --  implementation, because one of the parent classes (finally 
  2612.    --  Gtk.Widget.Gtk_Widget) would attach the style itself. 
  2613.    --  Since: gtk+ 2.20 
  2614.    --  Deprecated since None, 3.0. This step is unnecessary with 
  2615.    --  Gtk.Style_Context.Gtk_Style_Context. 
  2616.  
  2617.    procedure Style_Get_Property 
  2618.       (Widget        : not null access Gtk_Widget_Record; 
  2619.        Property_Name : UTF8_String; 
  2620.        Value         : in out Glib.Values.GValue); 
  2621.    --  Gets the value of a style property of Widget. 
  2622.    --  "property_name": the name of a style property 
  2623.    --  "value": location to return the property value 
  2624.  
  2625.    procedure Thaw_Child_Notify (Widget : not null access Gtk_Widget_Record); 
  2626.    --  Reverts the effect of a previous call to 
  2627.    --  Gtk.Widget.Freeze_Child_Notify. This causes all queued 
  2628.    --  Gtk.Widget.Gtk_Widget::child-notify signals on Widget to be emitted. 
  2629.  
  2630.    procedure Translate_Coordinates 
  2631.       (Widget      : not null access Gtk_Widget_Record; 
  2632.        Dest_Widget : not null access Gtk_Widget_Record'Class; 
  2633.        Src_X       : Gint; 
  2634.        Src_Y       : Gint; 
  2635.        Dest_X      : out Gint; 
  2636.        Dest_Y      : out Gint; 
  2637.        Result      : out Boolean); 
  2638.    --  Translate coordinates relative to Src_Widget's allocation to 
  2639.    --  coordinates relative to Dest_Widget's allocations. In order to perform 
  2640.    --  this operation, both widgets must be realized, and must share a common 
  2641.    --  toplevel. 
  2642.    --  "dest_widget": a Gtk.Widget.Gtk_Widget 
  2643.    --  "src_x": X position relative to Src_Widget 
  2644.    --  "src_y": Y position relative to Src_Widget 
  2645.    --  "dest_x": location to store X position relative to Dest_Widget 
  2646.    --  "dest_y": location to store Y position relative to Dest_Widget 
  2647.  
  2648.    procedure Trigger_Tooltip_Query 
  2649.       (Widget : not null access Gtk_Widget_Record); 
  2650.    --  Triggers a tooltip query on the display where the toplevel of Widget is 
  2651.    --  located. See Gtk.Tooltip.Trigger_Tooltip_Query for more information. 
  2652.    --  Since: gtk+ 2.12 
  2653.  
  2654.    procedure Unmap (Widget : not null access Gtk_Widget_Record); 
  2655.    --  This function is only for use in widget implementations. Causes a 
  2656.    --  widget to be unmapped if it's currently mapped. 
  2657.  
  2658.    procedure Unparent (Widget : not null access Gtk_Widget_Record); 
  2659.    --  This function is only for use in widget implementations. Should be 
  2660.    --  called by implementations of the remove method on 
  2661.    --  Gtk.Container.Gtk_Container, to dissociate a child from the container. 
  2662.  
  2663.    procedure Unrealize (Widget : not null access Gtk_Widget_Record); 
  2664.    --  This function is only useful in widget implementations. Causes a widget 
  2665.    --  to be unrealized (frees all GDK resources associated with the widget, 
  2666.    --  such as Widget->window). 
  2667.  
  2668.    procedure Unregister_Window 
  2669.       (Widget : not null access Gtk_Widget_Record; 
  2670.        Window : Gdk.Gdk_Window); 
  2671.    --  Unregisters a Gdk.Gdk_Window from the widget that was previously set up 
  2672.    --  with Gtk.Widget.Register_Window. You need to call this when the window 
  2673.    --  is no longer used by the widget, such as when you destroy it. 
  2674.    --  Since: gtk+ 3.8 
  2675.    --  "window": a Gdk.Gdk_Window 
  2676.  
  2677.    procedure Unset_State_Flags 
  2678.       (Widget : not null access Gtk_Widget_Record; 
  2679.        Flags  : Gtk.Enums.Gtk_State_Flags); 
  2680.    --  This function is for use in widget implementations. Turns off flag 
  2681.    --  values for the current widget state (insensitive, prelighted, etc.). See 
  2682.    --  Gtk.Widget.Set_State_Flags. 
  2683.    --  Since: gtk+ 3.0 
  2684.    --  "flags": State flags to turn off 
  2685.  
  2686.    function Find_Style_Property 
  2687.       (Self          : GObject_Class; 
  2688.        Property_Name : UTF8_String) return Glib.Param_Spec; 
  2689.    --  Finds a style property of a widget class by name. 
  2690.    --  Since: gtk+ 2.2 
  2691.    --  "property_name": the name of the style property to find 
  2692.  
  2693.    procedure Install_Style_Property 
  2694.       (Self  : GObject_Class; 
  2695.        Pspec : Glib.Param_Spec); 
  2696.    pragma Import (C, Install_Style_Property, "gtk_widget_class_install_style_property"); 
  2697.    --  Installs a style property on a widget class. The parser for the style 
  2698.    --  property is determined by the value type of Pspec. 
  2699.    --  "pspec": the Glib.Param_Spec for the property 
  2700.  
  2701.    ---------------------- 
  2702.    -- GtkAda additions -- 
  2703.    ---------------------- 
  2704.  
  2705.    ------------------------------------ 
  2706.    -- Override default size handling -- 
  2707.    ------------------------------------ 
  2708.  
  2709.    type Gtk_Requisition_Access is access all Gtk_Requisition; 
  2710.    type Gtk_Allocation_Access is access all Gtk_Allocation; 
  2711.    pragma Convention (C, Gtk_Requisition_Access); 
  2712.    pragma Convention (C, Gtk_Allocation_Access); 
  2713.  
  2714.    function Get_Requisition 
  2715.      (Value : Glib.Values.GValue) return Gtk_Requisition_Access; 
  2716.    function Get_Allocation 
  2717.      (Value : Glib.Values.GValue) return Gtk_Allocation_Access; 
  2718.    --  Convert values received as callback parameters 
  2719.  
  2720.    type Size_Allocate_Handler is access procedure 
  2721.      (Widget : System.Address; Allocation : Gtk_Allocation); 
  2722.    pragma Convention (C, Size_Allocate_Handler); 
  2723.    --  Widget is the gtk+ C widget, that needs to be converted to Ada through 
  2724.    --  a call to: 
  2725.    --    declare 
  2726.    --       Stub : Gtk_Widget_Record; --  or the exact type you expect 
  2727.    --    begin 
  2728.    --       My_Widget := Gtk_Widget (Glib.Object.Get_User_Data (Widget, Stub); 
  2729.    --    end; 
  2730.  
  2731.    procedure Set_Default_Size_Allocate_Handler 
  2732.      (Klass   : Glib.Object.Ada_GObject_Class; 
  2733.       Handler : Size_Allocate_Handler); 
  2734.    pragma Import (C, Set_Default_Size_Allocate_Handler, 
  2735.       "ada_WIDGET_CLASS_override_size_allocate"); 
  2736.    --  Override the default size_allocate handler for this class. This handler 
  2737.    --  is automatically called in several cases (when a widget is dynamically 
  2738.    --  resized for instance), not through a signal. Thus, if you need to 
  2739.    --  override the default behavior provided by one of the standard 
  2740.    --  containers, you can not simply use Gtk.Handlers.Emit_Stop_By_Name, and 
  2741.    --  you must override the default handler. Note also that this handler 
  2742.    --  is automatically inherited by children of this class. 
  2743.    -- 
  2744.    --  This function is not needed unless you are writting your own 
  2745.    --  widgets, and should be reserved for advanced customization of the 
  2746.    --  standard widgets. 
  2747.  
  2748.    type Preferred_Size_Handler is access procedure 
  2749.      (Widget       : System.Address; 
  2750.       Minimum_Size : out Glib.Gint; 
  2751.       Natural_Size : out Glib.Gint); 
  2752.    pragma Convention (C, Preferred_Size_Handler); 
  2753.  
  2754.    procedure Set_Default_Get_Preferred_Width_Handler 
  2755.      (Klass   : Glib.Object.Ada_GObject_Class; 
  2756.       Handler : Preferred_Size_Handler); 
  2757.    procedure Set_Default_Get_Preferred_Height_Handler 
  2758.      (Klass   : Glib.Object.Ada_GObject_Class; 
  2759.       Handler : Preferred_Size_Handler); 
  2760.    pragma Import (C, Set_Default_Get_Preferred_Width_Handler, 
  2761.       "ada_WIDGET_CLASS_override_get_preferred_width"); 
  2762.    pragma Import (C, Set_Default_Get_Preferred_Height_Handler, 
  2763.       "ada_WIDGET_CLASS_override_get_preferred_height"); 
  2764.    --  Override the computation of a widget's preferred sizes. 
  2765.    --  You will only need to override this computation if you are writting 
  2766.    --  your own container widgets. 
  2767.  
  2768.    procedure Inherited_Get_Preferred_Width 
  2769.      (Klass      : Ada_GObject_Class; 
  2770.       Widget     : access Gtk_Widget_Record'Class; 
  2771.       Minimum_Size, Natural_Size : out Glib.Gint); 
  2772.    procedure Inherited_Get_Preferred_Height 
  2773.      (Klass      : Ada_GObject_Class; 
  2774.       Widget     : access Gtk_Widget_Record'Class; 
  2775.       Minimum_Size, Natural_Size : out Glib.Gint); 
  2776.    --  Call the default implementation 
  2777.  
  2778.    procedure Inherited_Size_Allocate 
  2779.      (Klass      : Ada_GObject_Class; 
  2780.       Widget     : access Gtk_Widget_Record'Class; 
  2781.       Allocation : Gtk_Allocation); 
  2782.    --  Call the inherited size_allocate. This is useful if you have overloaded it in 
  2783.    --  your own class, but still need to call the standard implementation. 
  2784.  
  2785.    --------------------------- 
  2786.    -- Override Draw handler -- 
  2787.    --------------------------- 
  2788.  
  2789.    generic 
  2790.    with function Draw 
  2791.      (W  : access Gtk_Widget_Record'Class; 
  2792.       Cr : Cairo.Cairo_Context) return Boolean; 
  2793.    function Proxy_Draw 
  2794.      (W  : System.Address; Cr : Cairo.Cairo_Context) return Gboolean; 
  2795.    pragma Convention (C, Proxy_Draw); 
  2796.  
  2797.    type Draw_Handler is access function 
  2798.      (W  : System.Address; 
  2799.       Cr : Cairo.Cairo_Context) return Gboolean; 
  2800.    pragma Convention (C, Draw_Handler); 
  2801.    --  A function responsible for drawing a widget. 
  2802.  
  2803.    procedure Set_Default_Draw_Handler 
  2804.      (Klass : Glib.Object.Ada_GObject_Class; Handler : Draw_Handler); 
  2805.    --  Override the default drawing function. This in general gives more 
  2806.    --  control than connection to Signal_Draw, however a widget is responsible 
  2807.    --  for drawing its children. 
  2808.    --  Use the generic Proxy_Draw to create a suitable callback. 
  2809.  
  2810.    function Inherited_Draw 
  2811.      (Klass  : Ada_GObject_Class; 
  2812.       Widget : access Gtk_Widget_Record'Class; 
  2813.       Cr     : Cairo.Cairo_Context) return Boolean; 
  2814.    --  Call the inherited draw. This is useful if you have overloaded draw in 
  2815.    --  your own class, but still need to draw the child widgets that do not 
  2816.    --  have their own window (the others will already get their own "draw" 
  2817.    --  event. 
  2818.    --  See http://developer.gnome.org/gtk3/3.0/chap-drawing-model.html 
  2819.    --  for an explanation of the gtk+ drawing model. 
  2820.  
  2821.    --------------- 
  2822.    -- Functions -- 
  2823.    --------------- 
  2824.  
  2825.    function Get_Default_Direction return Gtk.Enums.Gtk_Text_Direction; 
  2826.    --  Obtains the current default reading direction. See 
  2827.    --  Gtk.Widget.Set_Default_Direction. 
  2828.  
  2829.    procedure Set_Default_Direction (Dir : Gtk.Enums.Gtk_Text_Direction); 
  2830.    --  Sets the default reading direction for widgets where the direction has 
  2831.    --  not been explicitly set by Gtk.Widget.Set_Direction. 
  2832.    --  "dir": the new default direction. This cannot be 
  2833.    --  Gtk.Enums.Text_Dir_None. 
  2834.  
  2835.    function Get_Default_Style return Gtk.Style.Gtk_Style; 
  2836.    pragma Obsolescent (Get_Default_Style); 
  2837.    --  Returns the default style used by all widgets initially. 
  2838.    --  Deprecated since 3.0, Use Gtk.Style_Context.Gtk_Style_Context instead, 
  2839.    --  and Gtk.Css_Provider.Get_Default to obtain a 
  2840.    --  Gtk.Style_Provider.Gtk_Style_Provider with the default widget style 
  2841.    --  information. 
  2842.  
  2843.    procedure Pop_Composite_Child; 
  2844.    --  Cancels the effect of a previous call to 
  2845.    --  Gtk.Widget.Push_Composite_Child. 
  2846.  
  2847.    procedure Push_Composite_Child; 
  2848.    --  Makes all newly-created widgets as composite children until the 
  2849.    --  corresponding Gtk.Widget.Pop_Composite_Child call. 
  2850.    --  A composite child is a child that's an implementation detail of the 
  2851.    --  container it's inside and should not be visible to people using the 
  2852.    --  container. Composite children aren't treated differently by GTK (but see 
  2853.    --  Gtk.Container.Foreach vs. Gtk.Container.Forall), but e.g. GUI builders 
  2854.    --  might want to treat them in a different way. 
  2855.    --  Here is a simple example: |[ gtk_widget_push_composite_child (); 
  2856.    --  scrolled_window->hscrollbar = gtk_scrollbar_new 
  2857.    --  (GTK_ORIENTATION_HORIZONTAL, hadjustment); gtk_widget_set_composite_name 
  2858.    --  (scrolled_window->hscrollbar, "hscrollbar"); 
  2859.    --  gtk_widget_pop_composite_child (); gtk_widget_set_parent 
  2860.    --  (scrolled_window->hscrollbar, GTK_WIDGET (scrolled_window)); 
  2861.    --  g_object_ref (scrolled_window->hscrollbar); ]| 
  2862.  
  2863.    procedure Transform_To_Window 
  2864.       (Cr     : Cairo.Cairo_Context; 
  2865.        Widget : not null access Gtk_Widget_Record'Class; 
  2866.        Window : Gdk.Gdk_Window); 
  2867.    --  Transforms the given cairo context Cr that from Widget-relative 
  2868.    --  coordinates to Window-relative coordinates. If the Widget's window is 
  2869.    --  not an ancestor of Window, no modification will be applied. 
  2870.    --  This is the inverse to the transformation GTK applies when preparing an 
  2871.    --  expose event to be emitted with the Gtk.Widget.Gtk_Widget::draw signal. 
  2872.    --  It is intended to help porting multiwindow widgets from GTK+ 2 to the 
  2873.    --  rendering architecture of GTK+ 3. 
  2874.    --  Since: gtk+ 3.0 
  2875.    --  "cr": the cairo context to transform 
  2876.    --  "widget": the widget the context is currently centered for 
  2877.    --  "window": the window to transform the context to 
  2878.  
  2879.    function Should_Draw_Window 
  2880.       (Cr     : Cairo.Cairo_Context; 
  2881.        Window : Gdk.Gdk_Window) return Boolean; 
  2882.    --  This function is supposed to be called in Gtk.Widget.Gtk_Widget::draw 
  2883.    --  implementations for widgets that support multiple windows. Cr must be 
  2884.    --  untransformed from invoking of the draw function. This function will 
  2885.    --  return True if the contents of the given Window are supposed to be drawn 
  2886.    --  and False otherwise. Note that when the drawing was not initiated by the 
  2887.    --  windowing system this function will return True for all windows, so you 
  2888.    --  need to draw the bottommost window first. Also, do not use "else if" 
  2889.    --  statements to check which window should be drawn. 
  2890.    --  Since: gtk+ 3.0 
  2891.    --  "cr": a cairo context 
  2892.    --  "window": the window to check. Window may not be an input-only window. 
  2893.  
  2894.    ---------------- 
  2895.    -- Properties -- 
  2896.    ---------------- 
  2897.    --  The following properties are defined for this widget. See 
  2898.    --  Glib.Properties for more information on properties) 
  2899.  
  2900.    App_Paintable_Property : constant Glib.Properties.Property_Boolean; 
  2901.  
  2902.    Can_Default_Property : constant Glib.Properties.Property_Boolean; 
  2903.  
  2904.    Can_Focus_Property : constant Glib.Properties.Property_Boolean; 
  2905.  
  2906.    Composite_Child_Property : constant Glib.Properties.Property_Boolean; 
  2907.  
  2908.    Double_Buffered_Property : constant Glib.Properties.Property_Boolean; 
  2909.    --  Whether the widget is double buffered. 
  2910.  
  2911.    Events_Property : constant Gdk.Event.Property_Gdk_Event_Mask; 
  2912.    --  Type: Gdk.Event.Gdk_Event_Mask 
  2913.  
  2914.    Expand_Property : constant Glib.Properties.Property_Boolean; 
  2915.    --  Whether to expand in both directions. Setting this sets both 
  2916.    --  Gtk.Widget.Gtk_Widget:hexpand and Gtk.Widget.Gtk_Widget:vexpand 
  2917.  
  2918.    Halign_Property : constant Gtk.Widget.Property_Gtk_Align; 
  2919.    --  Type: Gtk_Align 
  2920.    --  How to distribute horizontal space if widget gets extra space, see 
  2921.    --  Gtk.Widget.Gtk_Align 
  2922.  
  2923.    Has_Default_Property : constant Glib.Properties.Property_Boolean; 
  2924.  
  2925.    Has_Focus_Property : constant Glib.Properties.Property_Boolean; 
  2926.  
  2927.    Has_Tooltip_Property : constant Glib.Properties.Property_Boolean; 
  2928.    --  Enables or disables the emission of 
  2929.    --  Gtk.Widget.Gtk_Widget::query-tooltip on Widget. A value of True 
  2930.    --  indicates that Widget can have a tooltip, in this case the widget will 
  2931.    --  be queried using Gtk.Widget.Gtk_Widget::query-tooltip to determine 
  2932.    --  whether it will provide a tooltip or not. 
  2933.    -- 
  2934.    --  Note that setting this property to True for the first time will change 
  2935.    --  the event masks of the GdkWindows of this widget to include leave-notify 
  2936.    --  and motion-notify events. This cannot and will not be undone when the 
  2937.    --  property is set to False again. 
  2938.  
  2939.    Height_Request_Property : constant Glib.Properties.Property_Int; 
  2940.  
  2941.    Hexpand_Property : constant Glib.Properties.Property_Boolean; 
  2942.    --  Whether to expand horizontally. See Gtk.Widget.Set_Hexpand. 
  2943.  
  2944.    Hexpand_Set_Property : constant Glib.Properties.Property_Boolean; 
  2945.    --  Whether to use the Gtk.Widget.Gtk_Widget:hexpand property. See 
  2946.    --  Gtk.Widget.Get_Hexpand_Set. 
  2947.  
  2948.    Is_Focus_Property : constant Glib.Properties.Property_Boolean; 
  2949.  
  2950.    Margin_Property : constant Glib.Properties.Property_Int; 
  2951.    --  Sets all four sides' margin at once. If read, returns max margin on any 
  2952.    --  side. 
  2953.  
  2954.    Margin_Bottom_Property : constant Glib.Properties.Property_Int; 
  2955.    --  Margin on bottom side of widget. 
  2956.    -- 
  2957.    --  This property adds margin outside of the widget's normal size request, 
  2958.    --  the margin will be added in addition to the size from 
  2959.    --  Gtk.Widget.Set_Size_Request for example. 
  2960.  
  2961.    Margin_Left_Property : constant Glib.Properties.Property_Int; 
  2962.    --  Margin on left side of widget. 
  2963.    -- 
  2964.    --  This property adds margin outside of the widget's normal size request, 
  2965.    --  the margin will be added in addition to the size from 
  2966.    --  Gtk.Widget.Set_Size_Request for example. 
  2967.  
  2968.    Margin_Right_Property : constant Glib.Properties.Property_Int; 
  2969.    --  Margin on right side of widget. 
  2970.    -- 
  2971.    --  This property adds margin outside of the widget's normal size request, 
  2972.    --  the margin will be added in addition to the size from 
  2973.    --  Gtk.Widget.Set_Size_Request for example. 
  2974.  
  2975.    Margin_Top_Property : constant Glib.Properties.Property_Int; 
  2976.    --  Margin on top side of widget. 
  2977.    -- 
  2978.    --  This property adds margin outside of the widget's normal size request, 
  2979.    --  the margin will be added in addition to the size from 
  2980.    --  Gtk.Widget.Set_Size_Request for example. 
  2981.  
  2982.    Name_Property : constant Glib.Properties.Property_String; 
  2983.  
  2984.    No_Show_All_Property : constant Glib.Properties.Property_Boolean; 
  2985.  
  2986.    Opacity_Property : constant Glib.Properties.Property_Double; 
  2987.    --  Type: Gdouble 
  2988.    --  The requested opacity of the widget. See Gtk.Widget.Set_Opacity for 
  2989.    --  more details about window opacity. 
  2990.    -- 
  2991.    --  Before 3.8 this was only availible in GtkWindow 
  2992.  
  2993.    Parent_Property : constant Glib.Properties.Property_Object; 
  2994.    --  Type: Gtk.Container.Gtk_Container 
  2995.  
  2996.    Receives_Default_Property : constant Glib.Properties.Property_Boolean; 
  2997.  
  2998.    Sensitive_Property : constant Glib.Properties.Property_Boolean; 
  2999.  
  3000.    Style_Property : constant Glib.Properties.Property_Object; 
  3001.    --  Type: Gtk.Style.Gtk_Style 
  3002.  
  3003.    Tooltip_Markup_Property : constant Glib.Properties.Property_String; 
  3004.    --  Sets the text of tooltip to be the given string, which is marked up 
  3005.    --  with the <link linkend="PangoMarkupFormat">Pango text markup 
  3006.    --  language</link>. Also see Gtk.Tooltip.Set_Markup. 
  3007.    -- 
  3008.    --  This is a convenience property which will take care of getting the 
  3009.    --  tooltip shown if the given string is not null: 
  3010.    --  Gtk.Widget.Gtk_Widget:has-tooltip will automatically be set to True and 
  3011.    --  there will be taken care of Gtk.Widget.Gtk_Widget::query-tooltip in the 
  3012.    --  default signal handler. 
  3013.  
  3014.    Tooltip_Text_Property : constant Glib.Properties.Property_String; 
  3015.    --  Sets the text of tooltip to be the given string. 
  3016.    -- 
  3017.    --  Also see Gtk.Tooltip.Set_Text. 
  3018.    -- 
  3019.    --  This is a convenience property which will take care of getting the 
  3020.    --  tooltip shown if the given string is not null: 
  3021.    --  Gtk.Widget.Gtk_Widget:has-tooltip will automatically be set to True and 
  3022.    --  there will be taken care of Gtk.Widget.Gtk_Widget::query-tooltip in the 
  3023.    --  default signal handler. 
  3024.  
  3025.    Valign_Property : constant Gtk.Widget.Property_Gtk_Align; 
  3026.    --  Type: Gtk_Align 
  3027.    --  How to distribute vertical space if widget gets extra space, see 
  3028.    --  Gtk.Widget.Gtk_Align 
  3029.  
  3030.    Vexpand_Property : constant Glib.Properties.Property_Boolean; 
  3031.    --  Whether to expand vertically. See Gtk.Widget.Set_Vexpand. 
  3032.  
  3033.    Vexpand_Set_Property : constant Glib.Properties.Property_Boolean; 
  3034.    --  Whether to use the Gtk.Widget.Gtk_Widget:vexpand property. See 
  3035.    --  Gtk.Widget.Get_Vexpand_Set. 
  3036.  
  3037.    Visible_Property : constant Glib.Properties.Property_Boolean; 
  3038.  
  3039.    Width_Request_Property : constant Glib.Properties.Property_Int; 
  3040.  
  3041.    Window_Property : constant Glib.Properties.Property_Boxed; 
  3042.    --  Type: Gdk.Window 
  3043.    --  The widget's window if it is realized, null otherwise. 
  3044.  
  3045.    ------------- 
  3046.    -- Signals -- 
  3047.    ------------- 
  3048.  
  3049.    type Cb_Gtk_Widget_Void is not null access procedure (Self : access Gtk_Widget_Record'Class); 
  3050.  
  3051.    type Cb_GObject_Void is not null access procedure 
  3052.      (Self : access Glib.Object.GObject_Record'Class); 
  3053.  
  3054.    Signal_Accel_Closures_Changed : constant Glib.Signal_Name := "accel-closures-changed"; 
  3055.    procedure On_Accel_Closures_Changed 
  3056.       (Self  : not null access Gtk_Widget_Record; 
  3057.        Call  : Cb_Gtk_Widget_Void; 
  3058.        After : Boolean := False); 
  3059.    procedure On_Accel_Closures_Changed 
  3060.       (Self  : not null access Gtk_Widget_Record; 
  3061.        Call  : Cb_GObject_Void; 
  3062.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3063.        After : Boolean := False); 
  3064.  
  3065.    type Cb_Gtk_Widget_Gdk_Event_Button_Boolean is not null access function 
  3066.      (Self  : access Gtk_Widget_Record'Class; 
  3067.       Event : Gdk.Event.Gdk_Event_Button) return Boolean; 
  3068.  
  3069.    type Cb_GObject_Gdk_Event_Button_Boolean is not null access function 
  3070.      (Self  : access Glib.Object.GObject_Record'Class; 
  3071.       Event : Gdk.Event.Gdk_Event_Button) return Boolean; 
  3072.  
  3073.    Signal_Button_Press_Event : constant Glib.Signal_Name := "button-press-event"; 
  3074.    procedure On_Button_Press_Event 
  3075.       (Self  : not null access Gtk_Widget_Record; 
  3076.        Call  : Cb_Gtk_Widget_Gdk_Event_Button_Boolean; 
  3077.        After : Boolean := False); 
  3078.    procedure On_Button_Press_Event 
  3079.       (Self  : not null access Gtk_Widget_Record; 
  3080.        Call  : Cb_GObject_Gdk_Event_Button_Boolean; 
  3081.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3082.        After : Boolean := False); 
  3083.    --  The ::button-press-event signal will be emitted when a button 
  3084.    --  (typically from a mouse) is pressed. 
  3085.    -- 
  3086.    --  To receive this signal, the Gdk.Gdk_Window associated to the widget 
  3087.    --  needs to enable the GDK_BUTTON_PRESS_MASK mask. 
  3088.    -- 
  3089.    --  This signal will be sent to the grab widget if there is one. 
  3090.    --  
  3091.    --  Callback parameters: 
  3092.    --    --  "event": the Gdk.Event.Gdk_Event_Button which triggered this signal. 
  3093.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  3094.  
  3095.    Signal_Button_Release_Event : constant Glib.Signal_Name := "button-release-event"; 
  3096.    procedure On_Button_Release_Event 
  3097.       (Self  : not null access Gtk_Widget_Record; 
  3098.        Call  : Cb_Gtk_Widget_Gdk_Event_Button_Boolean; 
  3099.        After : Boolean := False); 
  3100.    procedure On_Button_Release_Event 
  3101.       (Self  : not null access Gtk_Widget_Record; 
  3102.        Call  : Cb_GObject_Gdk_Event_Button_Boolean; 
  3103.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3104.        After : Boolean := False); 
  3105.    --  The ::button-release-event signal will be emitted when a button 
  3106.    --  (typically from a mouse) is released. 
  3107.    -- 
  3108.    --  To receive this signal, the Gdk.Gdk_Window associated to the widget 
  3109.    --  needs to enable the GDK_BUTTON_RELEASE_MASK mask. 
  3110.    -- 
  3111.    --  This signal will be sent to the grab widget if there is one. 
  3112.    --  
  3113.    --  Callback parameters: 
  3114.    --    --  "event": the Gdk.Event.Gdk_Event_Button which triggered this signal. 
  3115.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  3116.  
  3117.    type Cb_Gtk_Widget_Guint_Boolean is not null access function 
  3118.      (Self      : access Gtk_Widget_Record'Class; 
  3119.       Signal_Id : Guint) return Boolean; 
  3120.  
  3121.    type Cb_GObject_Guint_Boolean is not null access function 
  3122.      (Self      : access Glib.Object.GObject_Record'Class; 
  3123.       Signal_Id : Guint) return Boolean; 
  3124.  
  3125.    Signal_Can_Activate_Accel : constant Glib.Signal_Name := "can-activate-accel"; 
  3126.    procedure On_Can_Activate_Accel 
  3127.       (Self  : not null access Gtk_Widget_Record; 
  3128.        Call  : Cb_Gtk_Widget_Guint_Boolean; 
  3129.        After : Boolean := False); 
  3130.    procedure On_Can_Activate_Accel 
  3131.       (Self  : not null access Gtk_Widget_Record; 
  3132.        Call  : Cb_GObject_Guint_Boolean; 
  3133.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3134.        After : Boolean := False); 
  3135.    --  Determines whether an accelerator that activates the signal identified 
  3136.    --  by Signal_Id can currently be activated. This signal is present to allow 
  3137.    --  applications and derived widgets to override the default 
  3138.    --  Gtk.Widget.Gtk_Widget handling for determining whether an accelerator 
  3139.    --  can be activated. 
  3140.    --  
  3141.    --  Callback parameters: 
  3142.    --    --  "signal_id": the ID of a signal installed on Widget 
  3143.    --    --  Returns True if the signal can be activated. 
  3144.  
  3145.    type Cb_Gtk_Widget_Param_Spec_Void is not null access procedure 
  3146.      (Self           : access Gtk_Widget_Record'Class; 
  3147.       Child_Property : Glib.Param_Spec); 
  3148.  
  3149.    type Cb_GObject_Param_Spec_Void is not null access procedure 
  3150.      (Self           : access Glib.Object.GObject_Record'Class; 
  3151.       Child_Property : Glib.Param_Spec); 
  3152.  
  3153.    Signal_Child_Notify : constant Glib.Signal_Name := "child-notify"; 
  3154.    procedure On_Child_Notify 
  3155.       (Self  : not null access Gtk_Widget_Record; 
  3156.        Call  : Cb_Gtk_Widget_Param_Spec_Void; 
  3157.        After : Boolean := False); 
  3158.    procedure On_Child_Notify 
  3159.       (Self  : not null access Gtk_Widget_Record; 
  3160.        Call  : Cb_GObject_Param_Spec_Void; 
  3161.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3162.        After : Boolean := False); 
  3163.    --  The ::child-notify signal is emitted for each <link 
  3164.    --  linkend="child-properties">child property</link> that has changed on an 
  3165.    --  object. The signal's detail holds the property name. 
  3166.  
  3167.    Signal_Composited_Changed : constant Glib.Signal_Name := "composited-changed"; 
  3168.    procedure On_Composited_Changed 
  3169.       (Self  : not null access Gtk_Widget_Record; 
  3170.        Call  : Cb_Gtk_Widget_Void; 
  3171.        After : Boolean := False); 
  3172.    procedure On_Composited_Changed 
  3173.       (Self  : not null access Gtk_Widget_Record; 
  3174.        Call  : Cb_GObject_Void; 
  3175.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3176.        After : Boolean := False); 
  3177.    --  The ::composited-changed signal is emitted when the composited status 
  3178.    --  of Widget<!-- -->s screen changes. See Gdk.Screen.Is_Composited. 
  3179.  
  3180.    type Cb_Gtk_Widget_Gdk_Event_Configure_Boolean is not null access function 
  3181.      (Self  : access Gtk_Widget_Record'Class; 
  3182.       Event : Gdk.Event.Gdk_Event_Configure) return Boolean; 
  3183.  
  3184.    type Cb_GObject_Gdk_Event_Configure_Boolean is not null access function 
  3185.      (Self  : access Glib.Object.GObject_Record'Class; 
  3186.       Event : Gdk.Event.Gdk_Event_Configure) return Boolean; 
  3187.  
  3188.    Signal_Configure_Event : constant Glib.Signal_Name := "configure-event"; 
  3189.    procedure On_Configure_Event 
  3190.       (Self  : not null access Gtk_Widget_Record; 
  3191.        Call  : Cb_Gtk_Widget_Gdk_Event_Configure_Boolean; 
  3192.        After : Boolean := False); 
  3193.    procedure On_Configure_Event 
  3194.       (Self  : not null access Gtk_Widget_Record; 
  3195.        Call  : Cb_GObject_Gdk_Event_Configure_Boolean; 
  3196.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3197.        After : Boolean := False); 
  3198.    --  The ::configure-event signal will be emitted when the size, position or 
  3199.    --  stacking of the Widget's window has changed. 
  3200.    -- 
  3201.    --  To receive this signal, the Gdk.Gdk_Window associated to the widget 
  3202.    --  needs to enable the GDK_STRUCTURE_MASK mask. GDK will enable this mask 
  3203.    --  automatically for all new windows. 
  3204.    --  
  3205.    --  Callback parameters: 
  3206.    --    --  "event": the Gdk.Event.Gdk_Event_Configure which triggered this signal. 
  3207.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  3208.  
  3209.    type Cb_Gtk_Widget_Gdk_Event_Expose_Boolean is not null access function 
  3210.      (Self  : access Gtk_Widget_Record'Class; 
  3211.       Event : Gdk.Event.Gdk_Event_Expose) return Boolean; 
  3212.  
  3213.    type Cb_GObject_Gdk_Event_Expose_Boolean is not null access function 
  3214.      (Self  : access Glib.Object.GObject_Record'Class; 
  3215.       Event : Gdk.Event.Gdk_Event_Expose) return Boolean; 
  3216.  
  3217.    Signal_Damage_Event : constant Glib.Signal_Name := "damage-event"; 
  3218.    procedure On_Damage_Event 
  3219.       (Self  : not null access Gtk_Widget_Record; 
  3220.        Call  : Cb_Gtk_Widget_Gdk_Event_Expose_Boolean; 
  3221.        After : Boolean := False); 
  3222.    procedure On_Damage_Event 
  3223.       (Self  : not null access Gtk_Widget_Record; 
  3224.        Call  : Cb_GObject_Gdk_Event_Expose_Boolean; 
  3225.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3226.        After : Boolean := False); 
  3227.    --  Emitted when a redirected window belonging to Widget gets drawn into. 
  3228.    --  The region/area members of the event shows what area of the redirected 
  3229.    --  drawable was drawn into. 
  3230.    --  
  3231.    --  Callback parameters: 
  3232.    --    --  "event": the Gdk.Event.Gdk_Event_Expose event 
  3233.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  3234.  
  3235.    type Cb_Gtk_Widget_Gdk_Event_Boolean is not null access function 
  3236.      (Self  : access Gtk_Widget_Record'Class; 
  3237.       Event : Gdk.Event.Gdk_Event) return Boolean; 
  3238.  
  3239.    type Cb_GObject_Gdk_Event_Boolean is not null access function 
  3240.      (Self  : access Glib.Object.GObject_Record'Class; 
  3241.       Event : Gdk.Event.Gdk_Event) return Boolean; 
  3242.  
  3243.    Signal_Delete_Event : constant Glib.Signal_Name := "delete-event"; 
  3244.    procedure On_Delete_Event 
  3245.       (Self  : not null access Gtk_Widget_Record; 
  3246.        Call  : Cb_Gtk_Widget_Gdk_Event_Boolean; 
  3247.        After : Boolean := False); 
  3248.    procedure On_Delete_Event 
  3249.       (Self  : not null access Gtk_Widget_Record; 
  3250.        Call  : Cb_GObject_Gdk_Event_Boolean; 
  3251.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3252.        After : Boolean := False); 
  3253.    --  The ::delete-event signal is emitted if a user requests that a toplevel 
  3254.    --  window is closed. The default handler for this signal destroys the 
  3255.    --  window. Connecting Gtk.Widget.Hide_On_Delete to this signal will cause 
  3256.    --  the window to be hidden instead, so that it can later be shown again 
  3257.    --  without reconstructing it. 
  3258.    --  
  3259.    --  Callback parameters: 
  3260.    --    --  "event": the event which triggered this signal 
  3261.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  3262.  
  3263.    Signal_Destroy : constant Glib.Signal_Name := "destroy"; 
  3264.    procedure On_Destroy 
  3265.       (Self  : not null access Gtk_Widget_Record; 
  3266.        Call  : Cb_Gtk_Widget_Void; 
  3267.        After : Boolean := False); 
  3268.    procedure On_Destroy 
  3269.       (Self  : not null access Gtk_Widget_Record; 
  3270.        Call  : Cb_GObject_Void; 
  3271.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3272.        After : Boolean := False); 
  3273.    --  Signals that all holders of a reference to the widget should release 
  3274.    --  the reference that they hold. May result in finalization of the widget 
  3275.    --  if all references are released. 
  3276.  
  3277.    Signal_Destroy_Event : constant Glib.Signal_Name := "destroy-event"; 
  3278.    procedure On_Destroy_Event 
  3279.       (Self  : not null access Gtk_Widget_Record; 
  3280.        Call  : Cb_Gtk_Widget_Gdk_Event_Boolean; 
  3281.        After : Boolean := False); 
  3282.    procedure On_Destroy_Event 
  3283.       (Self  : not null access Gtk_Widget_Record; 
  3284.        Call  : Cb_GObject_Gdk_Event_Boolean; 
  3285.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3286.        After : Boolean := False); 
  3287.    --  The ::destroy-event signal is emitted when a Gdk.Gdk_Window is 
  3288.    --  destroyed. You rarely get this signal, because most widgets disconnect 
  3289.    --  themselves from their window before they destroy it, so no widget owns 
  3290.    --  the window at destroy time. 
  3291.    -- 
  3292.    --  To receive this signal, the Gdk.Gdk_Window associated to the widget 
  3293.    --  needs to enable the GDK_STRUCTURE_MASK mask. GDK will enable this mask 
  3294.    --  automatically for all new windows. 
  3295.    --  
  3296.    --  Callback parameters: 
  3297.    --    --  "event": the event which triggered this signal 
  3298.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  3299.  
  3300.    type Cb_Gtk_Widget_Gtk_Text_Direction_Void is not null access procedure 
  3301.      (Self               : access Gtk_Widget_Record'Class; 
  3302.       Previous_Direction : Gtk.Enums.Gtk_Text_Direction); 
  3303.  
  3304.    type Cb_GObject_Gtk_Text_Direction_Void is not null access procedure 
  3305.      (Self               : access Glib.Object.GObject_Record'Class; 
  3306.       Previous_Direction : Gtk.Enums.Gtk_Text_Direction); 
  3307.  
  3308.    Signal_Direction_Changed : constant Glib.Signal_Name := "direction-changed"; 
  3309.    procedure On_Direction_Changed 
  3310.       (Self  : not null access Gtk_Widget_Record; 
  3311.        Call  : Cb_Gtk_Widget_Gtk_Text_Direction_Void; 
  3312.        After : Boolean := False); 
  3313.    procedure On_Direction_Changed 
  3314.       (Self  : not null access Gtk_Widget_Record; 
  3315.        Call  : Cb_GObject_Gtk_Text_Direction_Void; 
  3316.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3317.        After : Boolean := False); 
  3318.    --  The ::direction-changed signal is emitted when the text direction of a 
  3319.    --  widget changes. 
  3320.  
  3321.    type Cb_Gtk_Widget_Drag_Context_Void is not null access procedure 
  3322.      (Self    : access Gtk_Widget_Record'Class; 
  3323.       Context : not null access Gdk.Drag_Contexts.Drag_Context_Record'Class); 
  3324.  
  3325.    type Cb_GObject_Drag_Context_Void is not null access procedure 
  3326.      (Self    : access Glib.Object.GObject_Record'Class; 
  3327.       Context : not null access Gdk.Drag_Contexts.Drag_Context_Record'Class); 
  3328.  
  3329.    Signal_Drag_Begin : constant Glib.Signal_Name := "drag-begin"; 
  3330.    procedure On_Drag_Begin 
  3331.       (Self  : not null access Gtk_Widget_Record; 
  3332.        Call  : Cb_Gtk_Widget_Drag_Context_Void; 
  3333.        After : Boolean := False); 
  3334.    procedure On_Drag_Begin 
  3335.       (Self  : not null access Gtk_Widget_Record; 
  3336.        Call  : Cb_GObject_Drag_Context_Void; 
  3337.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3338.        After : Boolean := False); 
  3339.    --  The ::drag-begin signal is emitted on the drag source when a drag is 
  3340.    --  started. A typical reason to connect to this signal is to set up a 
  3341.    --  custom drag icon with e.g. Gtk.Widget.Drag_Source_Set_Icon_Pixbuf. 
  3342.    -- 
  3343.    --  Note that some widgets set up a drag icon in the default handler of 
  3344.    --  this signal, so you may have to use g_signal_connect_after to override 
  3345.    --  what the default handler did. 
  3346.  
  3347.    Signal_Drag_Data_Delete : constant Glib.Signal_Name := "drag-data-delete"; 
  3348.    procedure On_Drag_Data_Delete 
  3349.       (Self  : not null access Gtk_Widget_Record; 
  3350.        Call  : Cb_Gtk_Widget_Drag_Context_Void; 
  3351.        After : Boolean := False); 
  3352.    procedure On_Drag_Data_Delete 
  3353.       (Self  : not null access Gtk_Widget_Record; 
  3354.        Call  : Cb_GObject_Drag_Context_Void; 
  3355.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3356.        After : Boolean := False); 
  3357.    --  The ::drag-data-delete signal is emitted on the drag source when a drag 
  3358.    --  with the action Gdk.Drag_Contexts.Action_Move is successfully completed. 
  3359.    --  The signal handler is responsible for deleting the data that has been 
  3360.    --  dropped. What "delete" means depends on the context of the drag 
  3361.    --  operation. 
  3362.  
  3363.    type Cb_Gtk_Widget_Drag_Context_Gtk_Selection_Data_Guint_Guint_Void is not null access procedure 
  3364.      (Self    : access Gtk_Widget_Record'Class; 
  3365.       Context : not null access Gdk.Drag_Contexts.Drag_Context_Record'Class; 
  3366.       Data    : Gtk.Selection_Data.Gtk_Selection_Data; 
  3367.       Info    : Guint; 
  3368.       Time    : Guint); 
  3369.  
  3370.    type Cb_GObject_Drag_Context_Gtk_Selection_Data_Guint_Guint_Void is not null access procedure 
  3371.      (Self    : access Glib.Object.GObject_Record'Class; 
  3372.       Context : not null access Gdk.Drag_Contexts.Drag_Context_Record'Class; 
  3373.       Data    : Gtk.Selection_Data.Gtk_Selection_Data; 
  3374.       Info    : Guint; 
  3375.       Time    : Guint); 
  3376.  
  3377.    Signal_Drag_Data_Get : constant Glib.Signal_Name := "drag-data-get"; 
  3378.    procedure On_Drag_Data_Get 
  3379.       (Self  : not null access Gtk_Widget_Record; 
  3380.        Call  : Cb_Gtk_Widget_Drag_Context_Gtk_Selection_Data_Guint_Guint_Void; 
  3381.        After : Boolean := False); 
  3382.    procedure On_Drag_Data_Get 
  3383.       (Self  : not null access Gtk_Widget_Record; 
  3384.        Call  : Cb_GObject_Drag_Context_Gtk_Selection_Data_Guint_Guint_Void; 
  3385.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3386.        After : Boolean := False); 
  3387.    --  The ::drag-data-get signal is emitted on the drag source when the drop 
  3388.    --  site requests the data which is dragged. It is the responsibility of the 
  3389.    --  signal handler to fill Data with the data in the format which is 
  3390.    --  indicated by Info. See gtk_selection_data_set and 
  3391.    --  Gtk.Selection_Data.Set_Text. 
  3392.    --  
  3393.    --  Callback parameters: 
  3394.    --    --  "context": the drag context 
  3395.    --    --  "data": the Gtk.Selection_Data.Gtk_Selection_Data to be filled with the 
  3396.    --    --  dragged data 
  3397.    --    --  "info": the info that has been registered with the target in the 
  3398.    --    --  Gtk.Target_List.Gtk_Target_List 
  3399.    --    --  "time": the timestamp at which the data was requested 
  3400.  
  3401.    type Cb_Gtk_Widget_Drag_Context_Gint_Gint_Gtk_Selection_Data_Guint_Guint_Void is not null access procedure 
  3402.      (Self    : access Gtk_Widget_Record'Class; 
  3403.       Context : not null access Gdk.Drag_Contexts.Drag_Context_Record'Class; 
  3404.       X       : Gint; 
  3405.       Y       : Gint; 
  3406.       Data    : Gtk.Selection_Data.Gtk_Selection_Data; 
  3407.       Info    : Guint; 
  3408.       Time    : Guint); 
  3409.  
  3410.    type Cb_GObject_Drag_Context_Gint_Gint_Gtk_Selection_Data_Guint_Guint_Void is not null access procedure 
  3411.      (Self    : access Glib.Object.GObject_Record'Class; 
  3412.       Context : not null access Gdk.Drag_Contexts.Drag_Context_Record'Class; 
  3413.       X       : Gint; 
  3414.       Y       : Gint; 
  3415.       Data    : Gtk.Selection_Data.Gtk_Selection_Data; 
  3416.       Info    : Guint; 
  3417.       Time    : Guint); 
  3418.  
  3419.    Signal_Drag_Data_Received : constant Glib.Signal_Name := "drag-data-received"; 
  3420.    procedure On_Drag_Data_Received 
  3421.       (Self  : not null access Gtk_Widget_Record; 
  3422.        Call  : Cb_Gtk_Widget_Drag_Context_Gint_Gint_Gtk_Selection_Data_Guint_Guint_Void; 
  3423.        After : Boolean := False); 
  3424.    procedure On_Drag_Data_Received 
  3425.       (Self  : not null access Gtk_Widget_Record; 
  3426.        Call  : Cb_GObject_Drag_Context_Gint_Gint_Gtk_Selection_Data_Guint_Guint_Void; 
  3427.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3428.        After : Boolean := False); 
  3429.    --  The ::drag-data-received signal is emitted on the drop site when the 
  3430.    --  dragged data has been received. If the data was received in order to 
  3431.    --  determine whether the drop will be accepted, the handler is expected to 
  3432.    --  call gdk_drag_status and *not* finish the drag. If the data was received 
  3433.    --  in response to a Gtk.Widget.Gtk_Widget::drag-drop signal (and this is 
  3434.    --  the last target to be received), the handler for this signal is expected 
  3435.    --  to process the received data and then call gtk_drag_finish, setting the 
  3436.    --  Success parameter depending on whether the data was processed 
  3437.    --  successfully. 
  3438.    -- 
  3439.    --  The handler may inspect the selected action with 
  3440.    --  Gdk.Drag_Contexts.Get_Selected_Action before calling gtk_drag_finish, 
  3441.    --  e.g. to implement Gdk.Drag_Contexts.Action_Ask as shown in the following 
  3442.    --  example: |[ void drag_data_received (GtkWidget *widget, GdkDragContext 
  3443.    --  *context, gint x, gint y, GtkSelectionData *data, guint info, guint 
  3444.    --  time) { if ((data->length >= 0) && (data->format == 8)) { GdkDragAction 
  3445.    --  action; 
  3446.    -- 
  3447.    --  /* handle data here */ 
  3448.    -- 
  3449.    --  action = gdk_drag_context_get_selected_action (context); if (action == 
  3450.    --  GDK_ACTION_ASK) { GtkWidget *dialog; gint response; 
  3451.    -- 
  3452.    --  dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL | 
  3453.    --  GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_YES_NO, 
  3454.    --  "Move the data ?\n"); response = gtk_dialog_run (GTK_DIALOG (dialog)); 
  3455.    --  gtk_widget_destroy (dialog); 
  3456.    -- 
  3457.    --  if (response == GTK_RESPONSE_YES) action = GDK_ACTION_MOVE; else action 
  3458.    --  = GDK_ACTION_COPY; } 
  3459.    -- 
  3460.    --  gtk_drag_finish (context, TRUE, action == GDK_ACTION_MOVE, time); } 
  3461.    --  else gtk_drag_finish (context, FALSE, FALSE, time); } ]| 
  3462.    --  
  3463.    --  Callback parameters: 
  3464.    --    --  "context": the drag context 
  3465.    --    --  "x": where the drop happened 
  3466.    --    --  "y": where the drop happened 
  3467.    --    --  "data": the received data 
  3468.    --    --  "info": the info that has been registered with the target in the 
  3469.    --    --  Gtk.Target_List.Gtk_Target_List 
  3470.    --    --  "time": the timestamp at which the data was received 
  3471.  
  3472.    type Cb_Gtk_Widget_Drag_Context_Gint_Gint_Guint_Boolean is not null access function 
  3473.      (Self    : access Gtk_Widget_Record'Class; 
  3474.       Context : not null access Gdk.Drag_Contexts.Drag_Context_Record'Class; 
  3475.       X       : Gint; 
  3476.       Y       : Gint; 
  3477.       Time    : Guint) return Boolean; 
  3478.  
  3479.    type Cb_GObject_Drag_Context_Gint_Gint_Guint_Boolean is not null access function 
  3480.      (Self    : access Glib.Object.GObject_Record'Class; 
  3481.       Context : not null access Gdk.Drag_Contexts.Drag_Context_Record'Class; 
  3482.       X       : Gint; 
  3483.       Y       : Gint; 
  3484.       Time    : Guint) return Boolean; 
  3485.  
  3486.    Signal_Drag_Drop : constant Glib.Signal_Name := "drag-drop"; 
  3487.    procedure On_Drag_Drop 
  3488.       (Self  : not null access Gtk_Widget_Record; 
  3489.        Call  : Cb_Gtk_Widget_Drag_Context_Gint_Gint_Guint_Boolean; 
  3490.        After : Boolean := False); 
  3491.    procedure On_Drag_Drop 
  3492.       (Self  : not null access Gtk_Widget_Record; 
  3493.        Call  : Cb_GObject_Drag_Context_Gint_Gint_Guint_Boolean; 
  3494.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3495.        After : Boolean := False); 
  3496.    --  The ::drag-drop signal is emitted on the drop site when the user drops 
  3497.    --  the data onto the widget. The signal handler must determine whether the 
  3498.    --  cursor position is in a drop zone or not. If it is not in a drop zone, 
  3499.    --  it returns False and no further processing is necessary. Otherwise, the 
  3500.    --  handler returns True. In this case, the handler must ensure that 
  3501.    --  gtk_drag_finish is called to let the source know that the drop is done. 
  3502.    --  The call to gtk_drag_finish can be done either directly or in a 
  3503.    --  Gtk.Widget.Gtk_Widget::drag-data-received handler which gets triggered 
  3504.    --  by calling Gtk.Widget.Drag_Get_Data to receive the data for one or more 
  3505.    --  of the supported targets. 
  3506.    --  
  3507.    --  Callback parameters: 
  3508.    --    --  "context": the drag context 
  3509.    --    --  "x": the x coordinate of the current cursor position 
  3510.    --    --  "y": the y coordinate of the current cursor position 
  3511.    --    --  "time": the timestamp of the motion event 
  3512.    --    --  Returns whether the cursor position is in a drop zone 
  3513.  
  3514.    Signal_Drag_End : constant Glib.Signal_Name := "drag-end"; 
  3515.    procedure On_Drag_End 
  3516.       (Self  : not null access Gtk_Widget_Record; 
  3517.        Call  : Cb_Gtk_Widget_Drag_Context_Void; 
  3518.        After : Boolean := False); 
  3519.    procedure On_Drag_End 
  3520.       (Self  : not null access Gtk_Widget_Record; 
  3521.        Call  : Cb_GObject_Drag_Context_Void; 
  3522.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3523.        After : Boolean := False); 
  3524.    --  The ::drag-end signal is emitted on the drag source when a drag is 
  3525.    --  finished. A typical reason to connect to this signal is to undo things 
  3526.    --  done in Gtk.Widget.Gtk_Widget::drag-begin. 
  3527.  
  3528.    type Cb_Gtk_Widget_Drag_Context_Gtk_Drag_Result_Boolean is not null access function 
  3529.      (Self    : access Gtk_Widget_Record'Class; 
  3530.       Context : not null access Gdk.Drag_Contexts.Drag_Context_Record'Class; 
  3531.       Result  : Gtk.Enums.Gtk_Drag_Result) return Boolean; 
  3532.  
  3533.    type Cb_GObject_Drag_Context_Gtk_Drag_Result_Boolean is not null access function 
  3534.      (Self    : access Glib.Object.GObject_Record'Class; 
  3535.       Context : not null access Gdk.Drag_Contexts.Drag_Context_Record'Class; 
  3536.       Result  : Gtk.Enums.Gtk_Drag_Result) return Boolean; 
  3537.  
  3538.    Signal_Drag_Failed : constant Glib.Signal_Name := "drag-failed"; 
  3539.    procedure On_Drag_Failed 
  3540.       (Self  : not null access Gtk_Widget_Record; 
  3541.        Call  : Cb_Gtk_Widget_Drag_Context_Gtk_Drag_Result_Boolean; 
  3542.        After : Boolean := False); 
  3543.    procedure On_Drag_Failed 
  3544.       (Self  : not null access Gtk_Widget_Record; 
  3545.        Call  : Cb_GObject_Drag_Context_Gtk_Drag_Result_Boolean; 
  3546.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3547.        After : Boolean := False); 
  3548.    --  The ::drag-failed signal is emitted on the drag source when a drag has 
  3549.    --  failed. The signal handler may hook custom code to handle a failed DND 
  3550.    --  operation based on the type of error, it returns True is the failure has 
  3551.    --  been already handled (not showing the default "drag operation failed" 
  3552.    --  animation), otherwise it returns False. 
  3553.    --  
  3554.    --  Callback parameters: 
  3555.    --    --  "context": the drag context 
  3556.    --    --  "result": the result of the drag operation 
  3557.    --    --  Returns True if the failed drag operation has been already handled. 
  3558.  
  3559.    type Cb_Gtk_Widget_Drag_Context_Guint_Void is not null access procedure 
  3560.      (Self    : access Gtk_Widget_Record'Class; 
  3561.       Context : not null access Gdk.Drag_Contexts.Drag_Context_Record'Class; 
  3562.       Time    : Guint); 
  3563.  
  3564.    type Cb_GObject_Drag_Context_Guint_Void is not null access procedure 
  3565.      (Self    : access Glib.Object.GObject_Record'Class; 
  3566.       Context : not null access Gdk.Drag_Contexts.Drag_Context_Record'Class; 
  3567.       Time    : Guint); 
  3568.  
  3569.    Signal_Drag_Leave : constant Glib.Signal_Name := "drag-leave"; 
  3570.    procedure On_Drag_Leave 
  3571.       (Self  : not null access Gtk_Widget_Record; 
  3572.        Call  : Cb_Gtk_Widget_Drag_Context_Guint_Void; 
  3573.        After : Boolean := False); 
  3574.    procedure On_Drag_Leave 
  3575.       (Self  : not null access Gtk_Widget_Record; 
  3576.        Call  : Cb_GObject_Drag_Context_Guint_Void; 
  3577.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3578.        After : Boolean := False); 
  3579.    --  The ::drag-leave signal is emitted on the drop site when the cursor 
  3580.    --  leaves the widget. A typical reason to connect to this signal is to undo 
  3581.    --  things done in Gtk.Widget.Gtk_Widget::drag-motion, e.g. undo 
  3582.    --  highlighting with Gtk.Widget.Drag_Unhighlight 
  3583.    --  
  3584.    --  Callback parameters: 
  3585.    --    --  "context": the drag context 
  3586.    --    --  "time": the timestamp of the motion event 
  3587.  
  3588.    Signal_Drag_Motion : constant Glib.Signal_Name := "drag-motion"; 
  3589.    procedure On_Drag_Motion 
  3590.       (Self  : not null access Gtk_Widget_Record; 
  3591.        Call  : Cb_Gtk_Widget_Drag_Context_Gint_Gint_Guint_Boolean; 
  3592.        After : Boolean := False); 
  3593.    procedure On_Drag_Motion 
  3594.       (Self  : not null access Gtk_Widget_Record; 
  3595.        Call  : Cb_GObject_Drag_Context_Gint_Gint_Guint_Boolean; 
  3596.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3597.        After : Boolean := False); 
  3598.    --  The ::drag-motion signal is emitted on the drop site when the user 
  3599.    --  moves the cursor over the widget during a drag. The signal handler must 
  3600.    --  determine whether the cursor position is in a drop zone or not. If it is 
  3601.    --  not in a drop zone, it returns False and no further processing is 
  3602.    --  necessary. Otherwise, the handler returns True. In this case, the 
  3603.    --  handler is responsible for providing the necessary information for 
  3604.    --  displaying feedback to the user, by calling gdk_drag_status. 
  3605.    -- 
  3606.    --  If the decision whether the drop will be accepted or rejected can't be 
  3607.    --  made based solely on the cursor position and the type of the data, the 
  3608.    --  handler may inspect the dragged data by calling Gtk.Widget.Drag_Get_Data 
  3609.    --  and defer the gdk_drag_status call to the 
  3610.    --  Gtk.Widget.Gtk_Widget::drag-data-received handler. Note that you cannot 
  3611.    --  not pass GTK_DEST_DEFAULT_DROP, GTK_DEST_DEFAULT_MOTION or 
  3612.    --  GTK_DEST_DEFAULT_ALL to gtk_drag_dest_set when using the drag-motion 
  3613.    --  signal that way. 
  3614.    -- 
  3615.    --  Also note that there is no drag-enter signal. The drag receiver has to 
  3616.    --  keep track of whether he has received any drag-motion signals since the 
  3617.    --  last Gtk.Widget.Gtk_Widget::drag-leave and if not, treat the drag-motion 
  3618.    --  signal as an "enter" signal. Upon an "enter", the handler will typically 
  3619.    --  highlight the drop site with Gtk.Widget.Drag_Highlight. |[ static void 
  3620.    --  drag_motion (GtkWidget *widget, GdkDragContext *context, gint x, gint y, 
  3621.    --  guint time) { GdkAtom target; 
  3622.    -- 
  3623.    --  PrivateData *private_data = GET_PRIVATE_DATA (widget); 
  3624.    -- 
  3625.    --  if (!private_data->drag_highlight) { private_data->drag_highlight = 1; 
  3626.    --  gtk_drag_highlight (widget); } 
  3627.    -- 
  3628.    --  target = gtk_drag_dest_find_target (widget, context, NULL); if (target 
  3629.    --  == GDK_NONE) gdk_drag_status (context, 0, time); else { 
  3630.    --  private_data->pending_status = gdk_drag_context_get_suggested_action 
  3631.    --  (context); gtk_drag_get_data (widget, context, target, time); } 
  3632.    -- 
  3633.    --  return TRUE; } 
  3634.    -- 
  3635.    --  static void drag_data_received (GtkWidget *widget, GdkDragContext 
  3636.    --  *context, gint x, gint y, GtkSelectionData *selection_data, guint info, 
  3637.    --  guint time) { PrivateData *private_data = GET_PRIVATE_DATA (widget); 
  3638.    -- 
  3639.    --  if (private_data->suggested_action) { private_data->suggested_action = 
  3640.    --  0; 
  3641.    -- 
  3642.    --  /* We are getting this data due to a request in drag_motion, * rather 
  3643.    --  than due to a request in drag_drop, so we are just * supposed to call 
  3644.    --  gdk_drag_status, not actually paste in * the data. */ str = 
  3645.    --  gtk_selection_data_get_text (selection_data); if (!data_is_acceptable 
  3646.    --  (str)) gdk_drag_status (context, 0, time); else gdk_drag_status 
  3647.    --  (context, private_data->suggested_action, time); } else { /* accept the 
  3648.    --  drop */ } } ]| 
  3649.    --  
  3650.    --  Callback parameters: 
  3651.    --    --  "context": the drag context 
  3652.    --    --  "x": the x coordinate of the current cursor position 
  3653.    --    --  "y": the y coordinate of the current cursor position 
  3654.    --    --  "time": the timestamp of the motion event 
  3655.    --    --  Returns whether the cursor position is in a drop zone 
  3656.  
  3657.    type Cb_Gtk_Widget_Cairo_Context_Boolean is not null access function 
  3658.      (Self : access Gtk_Widget_Record'Class; 
  3659.       Cr   : Cairo.Cairo_Context) return Boolean; 
  3660.  
  3661.    type Cb_GObject_Cairo_Context_Boolean is not null access function 
  3662.      (Self : access Glib.Object.GObject_Record'Class; 
  3663.       Cr   : Cairo.Cairo_Context) return Boolean; 
  3664.  
  3665.    Signal_Draw : constant Glib.Signal_Name := "draw"; 
  3666.    procedure On_Draw 
  3667.       (Self  : not null access Gtk_Widget_Record; 
  3668.        Call  : Cb_Gtk_Widget_Cairo_Context_Boolean; 
  3669.        After : Boolean := False); 
  3670.    procedure On_Draw 
  3671.       (Self  : not null access Gtk_Widget_Record; 
  3672.        Call  : Cb_GObject_Cairo_Context_Boolean; 
  3673.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3674.        After : Boolean := False); 
  3675.    --  This signal is emitted when a widget is supposed to render itself. The 
  3676.    --  Widget's top left corner must be painted at the origin of the passed in 
  3677.    --  context and be sized to the values returned by 
  3678.    --  Gtk.Widget.Get_Allocated_Width and Gtk.Widget.Get_Allocated_Height. 
  3679.    -- 
  3680.    --  Signal handlers connected to this signal can modify the cairo context 
  3681.    --  passed as Cr in any way they like and don't need to restore it. The 
  3682.    --  signal emission takes care of calling cairo_save before and 
  3683.    --  cairo_restore after invoking the handler. 
  3684.    -- 
  3685.    --  The signal handler will get a Cr with a clip region already set to the 
  3686.    --  widget's dirty region, i.e. to the area that needs repainting. 
  3687.    --  Complicated widgets that want to avoid redrawing themselves completely 
  3688.    --  can get the full extents of the clip region with 
  3689.    --  gdk_cairo_get_clip_rectangle, or they can get a finer-grained 
  3690.    --  representation of the dirty region with cairo_copy_clip_rectangle_list. 
  3691.    --  
  3692.    --  Callback parameters: 
  3693.    --    --  "cr": the cairo context to draw to 
  3694.    --    --  Returns True to stop other handlers from being invoked for the event. % False to propagate the event further. 
  3695.  
  3696.    type Cb_Gtk_Widget_Gdk_Event_Crossing_Boolean is not null access function 
  3697.      (Self  : access Gtk_Widget_Record'Class; 
  3698.       Event : Gdk.Event.Gdk_Event_Crossing) return Boolean; 
  3699.  
  3700.    type Cb_GObject_Gdk_Event_Crossing_Boolean is not null access function 
  3701.      (Self  : access Glib.Object.GObject_Record'Class; 
  3702.       Event : Gdk.Event.Gdk_Event_Crossing) return Boolean; 
  3703.  
  3704.    Signal_Enter_Notify_Event : constant Glib.Signal_Name := "enter-notify-event"; 
  3705.    procedure On_Enter_Notify_Event 
  3706.       (Self  : not null access Gtk_Widget_Record; 
  3707.        Call  : Cb_Gtk_Widget_Gdk_Event_Crossing_Boolean; 
  3708.        After : Boolean := False); 
  3709.    procedure On_Enter_Notify_Event 
  3710.       (Self  : not null access Gtk_Widget_Record; 
  3711.        Call  : Cb_GObject_Gdk_Event_Crossing_Boolean; 
  3712.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3713.        After : Boolean := False); 
  3714.    --  The ::enter-notify-event will be emitted when the pointer enters the 
  3715.    --  Widget's window. 
  3716.    -- 
  3717.    --  To receive this signal, the Gdk.Gdk_Window associated to the widget 
  3718.    --  needs to enable the GDK_ENTER_NOTIFY_MASK mask. 
  3719.    -- 
  3720.    --  This signal will be sent to the grab widget if there is one. 
  3721.    --  
  3722.    --  Callback parameters: 
  3723.    --    --  "event": the Gdk.Event.Gdk_Event_Crossing which triggered this signal. 
  3724.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  3725.  
  3726.    Signal_Event : constant Glib.Signal_Name := "event"; 
  3727.    procedure On_Event 
  3728.       (Self  : not null access Gtk_Widget_Record; 
  3729.        Call  : Cb_Gtk_Widget_Gdk_Event_Boolean; 
  3730.        After : Boolean := False); 
  3731.    procedure On_Event 
  3732.       (Self  : not null access Gtk_Widget_Record; 
  3733.        Call  : Cb_GObject_Gdk_Event_Boolean; 
  3734.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3735.        After : Boolean := False); 
  3736.    --  The GTK+ main loop will emit three signals for each GDK event delivered 
  3737.    --  to a widget: one generic ::event signal, another, more specific, signal 
  3738.    --  that matches the type of event delivered (e.g. 
  3739.    --  Gtk.Widget.Gtk_Widget::key-press-event) and finally a generic 
  3740.    --  Gtk.Widget.Gtk_Widget::event-after signal. 
  3741.    --  
  3742.    --  Callback parameters: 
  3743.    --    --  "event": the Gdk.Event.Gdk_Event which triggered this signal 
  3744.    --    --  Returns True to stop other handlers from being invoked for the event and to cancel the emission of the second specific ::event signal. False to propagate the event further and to allow the emission of the second signal. The ::event-after signal is emitted regardless of the return value. 
  3745.  
  3746.    type Cb_Gtk_Widget_Gdk_Event_Void is not null access procedure 
  3747.      (Self  : access Gtk_Widget_Record'Class; 
  3748.       Event : Gdk.Event.Gdk_Event); 
  3749.  
  3750.    type Cb_GObject_Gdk_Event_Void is not null access procedure 
  3751.      (Self  : access Glib.Object.GObject_Record'Class; 
  3752.       Event : Gdk.Event.Gdk_Event); 
  3753.  
  3754.    Signal_Event_After : constant Glib.Signal_Name := "event-after"; 
  3755.    procedure On_Event_After 
  3756.       (Self  : not null access Gtk_Widget_Record; 
  3757.        Call  : Cb_Gtk_Widget_Gdk_Event_Void; 
  3758.        After : Boolean := False); 
  3759.    procedure On_Event_After 
  3760.       (Self  : not null access Gtk_Widget_Record; 
  3761.        Call  : Cb_GObject_Gdk_Event_Void; 
  3762.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3763.        After : Boolean := False); 
  3764.    --  After the emission of the Gtk.Widget.Gtk_Widget::event signal and 
  3765.    --  (optionally) the second more specific signal, ::event-after will be 
  3766.    --  emitted regardless of the previous two signals handlers return values. 
  3767.  
  3768.    type Cb_Gtk_Widget_Gtk_Direction_Type_Boolean is not null access function 
  3769.      (Self      : access Gtk_Widget_Record'Class; 
  3770.       Direction : Gtk.Enums.Gtk_Direction_Type) return Boolean; 
  3771.  
  3772.    type Cb_GObject_Gtk_Direction_Type_Boolean is not null access function 
  3773.      (Self      : access Glib.Object.GObject_Record'Class; 
  3774.       Direction : Gtk.Enums.Gtk_Direction_Type) return Boolean; 
  3775.  
  3776.    Signal_Focus : constant Glib.Signal_Name := "focus"; 
  3777.    procedure On_Focus 
  3778.       (Self  : not null access Gtk_Widget_Record; 
  3779.        Call  : Cb_Gtk_Widget_Gtk_Direction_Type_Boolean; 
  3780.        After : Boolean := False); 
  3781.    procedure On_Focus 
  3782.       (Self  : not null access Gtk_Widget_Record; 
  3783.        Call  : Cb_GObject_Gtk_Direction_Type_Boolean; 
  3784.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3785.        After : Boolean := False); 
  3786.    --  
  3787.    --  Callback parameters: 
  3788.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  3789.  
  3790.    type Cb_Gtk_Widget_Gdk_Event_Focus_Boolean is not null access function 
  3791.      (Self  : access Gtk_Widget_Record'Class; 
  3792.       Event : Gdk.Event.Gdk_Event_Focus) return Boolean; 
  3793.  
  3794.    type Cb_GObject_Gdk_Event_Focus_Boolean is not null access function 
  3795.      (Self  : access Glib.Object.GObject_Record'Class; 
  3796.       Event : Gdk.Event.Gdk_Event_Focus) return Boolean; 
  3797.  
  3798.    Signal_Focus_In_Event : constant Glib.Signal_Name := "focus-in-event"; 
  3799.    procedure On_Focus_In_Event 
  3800.       (Self  : not null access Gtk_Widget_Record; 
  3801.        Call  : Cb_Gtk_Widget_Gdk_Event_Focus_Boolean; 
  3802.        After : Boolean := False); 
  3803.    procedure On_Focus_In_Event 
  3804.       (Self  : not null access Gtk_Widget_Record; 
  3805.        Call  : Cb_GObject_Gdk_Event_Focus_Boolean; 
  3806.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3807.        After : Boolean := False); 
  3808.    --  The ::focus-in-event signal will be emitted when the keyboard focus 
  3809.    --  enters the Widget's window. 
  3810.    -- 
  3811.    --  To receive this signal, the Gdk.Gdk_Window associated to the widget 
  3812.    --  needs to enable the GDK_FOCUS_CHANGE_MASK mask. 
  3813.    --  
  3814.    --  Callback parameters: 
  3815.    --    --  "event": the Gdk.Event.Gdk_Event_Focus which triggered this signal. 
  3816.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  3817.  
  3818.    Signal_Focus_Out_Event : constant Glib.Signal_Name := "focus-out-event"; 
  3819.    procedure On_Focus_Out_Event 
  3820.       (Self  : not null access Gtk_Widget_Record; 
  3821.        Call  : Cb_Gtk_Widget_Gdk_Event_Focus_Boolean; 
  3822.        After : Boolean := False); 
  3823.    procedure On_Focus_Out_Event 
  3824.       (Self  : not null access Gtk_Widget_Record; 
  3825.        Call  : Cb_GObject_Gdk_Event_Focus_Boolean; 
  3826.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3827.        After : Boolean := False); 
  3828.    --  The ::focus-out-event signal will be emitted when the keyboard focus 
  3829.    --  leaves the Widget's window. 
  3830.    -- 
  3831.    --  To receive this signal, the Gdk.Gdk_Window associated to the widget 
  3832.    --  needs to enable the GDK_FOCUS_CHANGE_MASK mask. 
  3833.    --  
  3834.    --  Callback parameters: 
  3835.    --    --  "event": the Gdk.Event.Gdk_Event_Focus which triggered this signal. 
  3836.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  3837.  
  3838.    type Cb_Gtk_Widget_Gdk_Event_Grab_Broken_Boolean is not null access function 
  3839.      (Self  : access Gtk_Widget_Record'Class; 
  3840.       Event : Gdk.Event.Gdk_Event_Grab_Broken) return Boolean; 
  3841.  
  3842.    type Cb_GObject_Gdk_Event_Grab_Broken_Boolean is not null access function 
  3843.      (Self  : access Glib.Object.GObject_Record'Class; 
  3844.       Event : Gdk.Event.Gdk_Event_Grab_Broken) return Boolean; 
  3845.  
  3846.    Signal_Grab_Broken_Event : constant Glib.Signal_Name := "grab-broken-event"; 
  3847.    procedure On_Grab_Broken_Event 
  3848.       (Self  : not null access Gtk_Widget_Record; 
  3849.        Call  : Cb_Gtk_Widget_Gdk_Event_Grab_Broken_Boolean; 
  3850.        After : Boolean := False); 
  3851.    procedure On_Grab_Broken_Event 
  3852.       (Self  : not null access Gtk_Widget_Record; 
  3853.        Call  : Cb_GObject_Gdk_Event_Grab_Broken_Boolean; 
  3854.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3855.        After : Boolean := False); 
  3856.    --  Emitted when a pointer or keyboard grab on a window belonging to Widget 
  3857.    --  gets broken. 
  3858.    -- 
  3859.    --  On X11, this happens when the grab window becomes unviewable (i.e. it 
  3860.    --  or one of its ancestors is unmapped), or if the same application grabs 
  3861.    --  the pointer or keyboard again. 
  3862.    --  
  3863.    --  Callback parameters: 
  3864.    --    --  "event": the Gdk.Event.Gdk_Event_Grab_Broken event 
  3865.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  3866.  
  3867.    Signal_Grab_Focus : constant Glib.Signal_Name := "grab-focus"; 
  3868.    procedure On_Grab_Focus 
  3869.       (Self  : not null access Gtk_Widget_Record; 
  3870.        Call  : Cb_Gtk_Widget_Void; 
  3871.        After : Boolean := False); 
  3872.    procedure On_Grab_Focus 
  3873.       (Self  : not null access Gtk_Widget_Record; 
  3874.        Call  : Cb_GObject_Void; 
  3875.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3876.        After : Boolean := False); 
  3877.  
  3878.    type Cb_Gtk_Widget_Boolean_Void is not null access procedure 
  3879.      (Self        : access Gtk_Widget_Record'Class; 
  3880.       Was_Grabbed : Boolean); 
  3881.  
  3882.    type Cb_GObject_Boolean_Void is not null access procedure 
  3883.      (Self        : access Glib.Object.GObject_Record'Class; 
  3884.       Was_Grabbed : Boolean); 
  3885.  
  3886.    Signal_Grab_Notify : constant Glib.Signal_Name := "grab-notify"; 
  3887.    procedure On_Grab_Notify 
  3888.       (Self  : not null access Gtk_Widget_Record; 
  3889.        Call  : Cb_Gtk_Widget_Boolean_Void; 
  3890.        After : Boolean := False); 
  3891.    procedure On_Grab_Notify 
  3892.       (Self  : not null access Gtk_Widget_Record; 
  3893.        Call  : Cb_GObject_Boolean_Void; 
  3894.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3895.        After : Boolean := False); 
  3896.    --  The ::grab-notify signal is emitted when a widget becomes shadowed by a 
  3897.    --  GTK+ grab (not a pointer or keyboard grab) on another widget, or when it 
  3898.    --  becomes unshadowed due to a grab being removed. 
  3899.    -- 
  3900.    --  A widget is shadowed by a Gtk.Widget.Grab_Add when the topmost grab 
  3901.    --  widget in the grab stack of its window group is not its ancestor. 
  3902.  
  3903.    Signal_Hide : constant Glib.Signal_Name := "hide"; 
  3904.    procedure On_Hide 
  3905.       (Self  : not null access Gtk_Widget_Record; 
  3906.        Call  : Cb_Gtk_Widget_Void; 
  3907.        After : Boolean := False); 
  3908.    procedure On_Hide 
  3909.       (Self  : not null access Gtk_Widget_Record; 
  3910.        Call  : Cb_GObject_Void; 
  3911.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3912.        After : Boolean := False); 
  3913.  
  3914.    type Cb_Gtk_Widget_Gtk_Widget_Void is not null access procedure 
  3915.      (Self              : access Gtk_Widget_Record'Class; 
  3916.       Previous_Toplevel : access Gtk_Widget_Record'Class); 
  3917.  
  3918.    type Cb_GObject_Gtk_Widget_Void is not null access procedure 
  3919.      (Self              : access Glib.Object.GObject_Record'Class; 
  3920.       Previous_Toplevel : access Gtk_Widget_Record'Class); 
  3921.  
  3922.    Signal_Hierarchy_Changed : constant Glib.Signal_Name := "hierarchy-changed"; 
  3923.    procedure On_Hierarchy_Changed 
  3924.       (Self  : not null access Gtk_Widget_Record; 
  3925.        Call  : Cb_Gtk_Widget_Gtk_Widget_Void; 
  3926.        After : Boolean := False); 
  3927.    procedure On_Hierarchy_Changed 
  3928.       (Self  : not null access Gtk_Widget_Record; 
  3929.        Call  : Cb_GObject_Gtk_Widget_Void; 
  3930.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3931.        After : Boolean := False); 
  3932.    --  The ::hierarchy-changed signal is emitted when the anchored state of a 
  3933.    --  widget changes. A widget is 'anchored' when its toplevel ancestor is a 
  3934.    --  Gtk.Window.Gtk_Window. This signal is emitted when a widget changes from 
  3935.    --  un-anchored to anchored or vice-versa. 
  3936.  
  3937.    type Cb_Gtk_Widget_Gdk_Event_Key_Boolean is not null access function 
  3938.      (Self  : access Gtk_Widget_Record'Class; 
  3939.       Event : Gdk.Event.Gdk_Event_Key) return Boolean; 
  3940.  
  3941.    type Cb_GObject_Gdk_Event_Key_Boolean is not null access function 
  3942.      (Self  : access Glib.Object.GObject_Record'Class; 
  3943.       Event : Gdk.Event.Gdk_Event_Key) return Boolean; 
  3944.  
  3945.    Signal_Key_Press_Event : constant Glib.Signal_Name := "key-press-event"; 
  3946.    procedure On_Key_Press_Event 
  3947.       (Self  : not null access Gtk_Widget_Record; 
  3948.        Call  : Cb_Gtk_Widget_Gdk_Event_Key_Boolean; 
  3949.        After : Boolean := False); 
  3950.    procedure On_Key_Press_Event 
  3951.       (Self  : not null access Gtk_Widget_Record; 
  3952.        Call  : Cb_GObject_Gdk_Event_Key_Boolean; 
  3953.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3954.        After : Boolean := False); 
  3955.    --  The ::key-press-event signal is emitted when a key is pressed. The 
  3956.    --  signal emission will reoccur at the key-repeat rate when the key is kept 
  3957.    --  pressed. 
  3958.    -- 
  3959.    --  To receive this signal, the Gdk.Gdk_Window associated to the widget 
  3960.    --  needs to enable the GDK_KEY_PRESS_MASK mask. 
  3961.    -- 
  3962.    --  This signal will be sent to the grab widget if there is one. 
  3963.    --  
  3964.    --  Callback parameters: 
  3965.    --    --  "event": the Gdk.Event.Gdk_Event_Key which triggered this signal. 
  3966.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  3967.  
  3968.    Signal_Key_Release_Event : constant Glib.Signal_Name := "key-release-event"; 
  3969.    procedure On_Key_Release_Event 
  3970.       (Self  : not null access Gtk_Widget_Record; 
  3971.        Call  : Cb_Gtk_Widget_Gdk_Event_Key_Boolean; 
  3972.        After : Boolean := False); 
  3973.    procedure On_Key_Release_Event 
  3974.       (Self  : not null access Gtk_Widget_Record; 
  3975.        Call  : Cb_GObject_Gdk_Event_Key_Boolean; 
  3976.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3977.        After : Boolean := False); 
  3978.    --  The ::key-release-event signal is emitted when a key is released. 
  3979.    -- 
  3980.    --  To receive this signal, the Gdk.Gdk_Window associated to the widget 
  3981.    --  needs to enable the GDK_KEY_RELEASE_MASK mask. 
  3982.    -- 
  3983.    --  This signal will be sent to the grab widget if there is one. 
  3984.    --  
  3985.    --  Callback parameters: 
  3986.    --    --  "event": the Gdk.Event.Gdk_Event_Key which triggered this signal. 
  3987.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  3988.  
  3989.    Signal_Keynav_Failed : constant Glib.Signal_Name := "keynav-failed"; 
  3990.    procedure On_Keynav_Failed 
  3991.       (Self  : not null access Gtk_Widget_Record; 
  3992.        Call  : Cb_Gtk_Widget_Gtk_Direction_Type_Boolean; 
  3993.        After : Boolean := False); 
  3994.    procedure On_Keynav_Failed 
  3995.       (Self  : not null access Gtk_Widget_Record; 
  3996.        Call  : Cb_GObject_Gtk_Direction_Type_Boolean; 
  3997.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  3998.        After : Boolean := False); 
  3999.    --  Gets emitted if keyboard navigation fails. See Gtk.Widget.Keynav_Failed 
  4000.    --  for details. 
  4001.    --  
  4002.    --  Callback parameters: 
  4003.    --    --  "direction": the direction of movement 
  4004.    --    --  Returns True if stopping keyboard navigation is fine, False if the emitting widget should try to handle the keyboard navigation attempt in its parent container(s). 
  4005.  
  4006.    Signal_Leave_Notify_Event : constant Glib.Signal_Name := "leave-notify-event"; 
  4007.    procedure On_Leave_Notify_Event 
  4008.       (Self  : not null access Gtk_Widget_Record; 
  4009.        Call  : Cb_Gtk_Widget_Gdk_Event_Crossing_Boolean; 
  4010.        After : Boolean := False); 
  4011.    procedure On_Leave_Notify_Event 
  4012.       (Self  : not null access Gtk_Widget_Record; 
  4013.        Call  : Cb_GObject_Gdk_Event_Crossing_Boolean; 
  4014.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4015.        After : Boolean := False); 
  4016.    --  The ::leave-notify-event will be emitted when the pointer leaves the 
  4017.    --  Widget's window. 
  4018.    -- 
  4019.    --  To receive this signal, the Gdk.Gdk_Window associated to the widget 
  4020.    --  needs to enable the GDK_LEAVE_NOTIFY_MASK mask. 
  4021.    -- 
  4022.    --  This signal will be sent to the grab widget if there is one. 
  4023.    --  
  4024.    --  Callback parameters: 
  4025.    --    --  "event": the Gdk.Event.Gdk_Event_Crossing which triggered this signal. 
  4026.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  4027.  
  4028.    Signal_Map : constant Glib.Signal_Name := "map"; 
  4029.    procedure On_Map 
  4030.       (Self  : not null access Gtk_Widget_Record; 
  4031.        Call  : Cb_Gtk_Widget_Void; 
  4032.        After : Boolean := False); 
  4033.    procedure On_Map 
  4034.       (Self  : not null access Gtk_Widget_Record; 
  4035.        Call  : Cb_GObject_Void; 
  4036.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4037.        After : Boolean := False); 
  4038.  
  4039.    type Cb_Gtk_Widget_Gdk_Event_Any_Boolean is not null access function 
  4040.      (Self  : access Gtk_Widget_Record'Class; 
  4041.       Event : Gdk.Event.Gdk_Event_Any) return Boolean; 
  4042.  
  4043.    type Cb_GObject_Gdk_Event_Any_Boolean is not null access function 
  4044.      (Self  : access Glib.Object.GObject_Record'Class; 
  4045.       Event : Gdk.Event.Gdk_Event_Any) return Boolean; 
  4046.  
  4047.    Signal_Map_Event : constant Glib.Signal_Name := "map-event"; 
  4048.    procedure On_Map_Event 
  4049.       (Self  : not null access Gtk_Widget_Record; 
  4050.        Call  : Cb_Gtk_Widget_Gdk_Event_Any_Boolean; 
  4051.        After : Boolean := False); 
  4052.    procedure On_Map_Event 
  4053.       (Self  : not null access Gtk_Widget_Record; 
  4054.        Call  : Cb_GObject_Gdk_Event_Any_Boolean; 
  4055.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4056.        After : Boolean := False); 
  4057.    --  The ::map-event signal will be emitted when the Widget's window is 
  4058.    --  mapped. A window is mapped when it becomes visible on the screen. 
  4059.    -- 
  4060.    --  To receive this signal, the Gdk.Gdk_Window associated to the widget 
  4061.    --  needs to enable the GDK_STRUCTURE_MASK mask. GDK will enable this mask 
  4062.    --  automatically for all new windows. 
  4063.    --  
  4064.    --  Callback parameters: 
  4065.    --    --  "event": the Gdk.Event.Gdk_Event_Any which triggered this signal. 
  4066.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  4067.  
  4068.    type Cb_Gtk_Widget_Boolean_Boolean is not null access function 
  4069.      (Self : access Gtk_Widget_Record'Class; 
  4070.       Arg1 : Boolean) return Boolean; 
  4071.  
  4072.    type Cb_GObject_Boolean_Boolean is not null access function 
  4073.      (Self : access Glib.Object.GObject_Record'Class; 
  4074.       Arg1 : Boolean) return Boolean; 
  4075.  
  4076.    Signal_Mnemonic_Activate : constant Glib.Signal_Name := "mnemonic-activate"; 
  4077.    procedure On_Mnemonic_Activate 
  4078.       (Self  : not null access Gtk_Widget_Record; 
  4079.        Call  : Cb_Gtk_Widget_Boolean_Boolean; 
  4080.        After : Boolean := False); 
  4081.    procedure On_Mnemonic_Activate 
  4082.       (Self  : not null access Gtk_Widget_Record; 
  4083.        Call  : Cb_GObject_Boolean_Boolean; 
  4084.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4085.        After : Boolean := False); 
  4086.    --  
  4087.    --  Callback parameters: 
  4088.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  4089.  
  4090.    type Cb_Gtk_Widget_Gdk_Event_Motion_Boolean is not null access function 
  4091.      (Self  : access Gtk_Widget_Record'Class; 
  4092.       Event : Gdk.Event.Gdk_Event_Motion) return Boolean; 
  4093.  
  4094.    type Cb_GObject_Gdk_Event_Motion_Boolean is not null access function 
  4095.      (Self  : access Glib.Object.GObject_Record'Class; 
  4096.       Event : Gdk.Event.Gdk_Event_Motion) return Boolean; 
  4097.  
  4098.    Signal_Motion_Notify_Event : constant Glib.Signal_Name := "motion-notify-event"; 
  4099.    procedure On_Motion_Notify_Event 
  4100.       (Self  : not null access Gtk_Widget_Record; 
  4101.        Call  : Cb_Gtk_Widget_Gdk_Event_Motion_Boolean; 
  4102.        After : Boolean := False); 
  4103.    procedure On_Motion_Notify_Event 
  4104.       (Self  : not null access Gtk_Widget_Record; 
  4105.        Call  : Cb_GObject_Gdk_Event_Motion_Boolean; 
  4106.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4107.        After : Boolean := False); 
  4108.    --  The ::motion-notify-event signal is emitted when the pointer moves over 
  4109.    --  the widget's Gdk.Gdk_Window. 
  4110.    -- 
  4111.    --  To receive this signal, the Gdk.Gdk_Window associated to the widget 
  4112.    --  needs to enable the GDK_POINTER_MOTION_MASK mask. 
  4113.    -- 
  4114.    --  This signal will be sent to the grab widget if there is one. 
  4115.    --  
  4116.    --  Callback parameters: 
  4117.    --    --  "event": the Gdk.Event.Gdk_Event_Motion which triggered this signal. 
  4118.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  4119.  
  4120.    type Cb_Gtk_Widget_Gtk_Direction_Type_Void is not null access procedure 
  4121.      (Self      : access Gtk_Widget_Record'Class; 
  4122.       Direction : Gtk.Enums.Gtk_Direction_Type); 
  4123.  
  4124.    type Cb_GObject_Gtk_Direction_Type_Void is not null access procedure 
  4125.      (Self      : access Glib.Object.GObject_Record'Class; 
  4126.       Direction : Gtk.Enums.Gtk_Direction_Type); 
  4127.  
  4128.    Signal_Move_Focus : constant Glib.Signal_Name := "move-focus"; 
  4129.    procedure On_Move_Focus 
  4130.       (Self  : not null access Gtk_Widget_Record; 
  4131.        Call  : Cb_Gtk_Widget_Gtk_Direction_Type_Void; 
  4132.        After : Boolean := False); 
  4133.    procedure On_Move_Focus 
  4134.       (Self  : not null access Gtk_Widget_Record; 
  4135.        Call  : Cb_GObject_Gtk_Direction_Type_Void; 
  4136.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4137.        After : Boolean := False); 
  4138.  
  4139.    Signal_Parent_Set : constant Glib.Signal_Name := "parent-set"; 
  4140.    procedure On_Parent_Set 
  4141.       (Self  : not null access Gtk_Widget_Record; 
  4142.        Call  : Cb_Gtk_Widget_Gtk_Widget_Void; 
  4143.        After : Boolean := False); 
  4144.    procedure On_Parent_Set 
  4145.       (Self  : not null access Gtk_Widget_Record; 
  4146.        Call  : Cb_GObject_Gtk_Widget_Void; 
  4147.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4148.        After : Boolean := False); 
  4149.    --  The ::parent-set signal is emitted when a new parent has been set on a 
  4150.    --  widget. 
  4151.  
  4152.    type Cb_Gtk_Widget_Boolean is not null access function 
  4153.      (Self : access Gtk_Widget_Record'Class) return Boolean; 
  4154.  
  4155.    type Cb_GObject_Boolean is not null access function 
  4156.      (Self : access Glib.Object.GObject_Record'Class) 
  4157.    return Boolean; 
  4158.  
  4159.    Signal_Popup_Menu : constant Glib.Signal_Name := "popup-menu"; 
  4160.    procedure On_Popup_Menu 
  4161.       (Self  : not null access Gtk_Widget_Record; 
  4162.        Call  : Cb_Gtk_Widget_Boolean; 
  4163.        After : Boolean := False); 
  4164.    procedure On_Popup_Menu 
  4165.       (Self  : not null access Gtk_Widget_Record; 
  4166.        Call  : Cb_GObject_Boolean; 
  4167.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4168.        After : Boolean := False); 
  4169.    --  This signal gets emitted whenever a widget should pop up a context 
  4170.    --  menu. This usually happens through the standard key binding mechanism; 
  4171.    --  by pressing a certain key while a widget is focused, the user can cause 
  4172.    --  the widget to pop up a menu. For example, the Gtk.GEntry.Gtk_Entry 
  4173.    --  widget creates a menu with clipboard commands. See <xref 
  4174.    --  linkend="checklist-popup-menu"/> for an example of how to use this 
  4175.    --  signal. 
  4176.    --  
  4177.    --  Callback parameters: 
  4178.    --    --  Returns True if a menu was activated 
  4179.  
  4180.    type Cb_Gtk_Widget_Gdk_Event_Property_Boolean is not null access function 
  4181.      (Self  : access Gtk_Widget_Record'Class; 
  4182.       Event : Gdk.Event.Gdk_Event_Property) return Boolean; 
  4183.  
  4184.    type Cb_GObject_Gdk_Event_Property_Boolean is not null access function 
  4185.      (Self  : access Glib.Object.GObject_Record'Class; 
  4186.       Event : Gdk.Event.Gdk_Event_Property) return Boolean; 
  4187.  
  4188.    Signal_Property_Notify_Event : constant Glib.Signal_Name := "property-notify-event"; 
  4189.    procedure On_Property_Notify_Event 
  4190.       (Self  : not null access Gtk_Widget_Record; 
  4191.        Call  : Cb_Gtk_Widget_Gdk_Event_Property_Boolean; 
  4192.        After : Boolean := False); 
  4193.    procedure On_Property_Notify_Event 
  4194.       (Self  : not null access Gtk_Widget_Record; 
  4195.        Call  : Cb_GObject_Gdk_Event_Property_Boolean; 
  4196.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4197.        After : Boolean := False); 
  4198.    --  The ::property-notify-event signal will be emitted when a property on 
  4199.    --  the Widget's window has been changed or deleted. 
  4200.    -- 
  4201.    --  To receive this signal, the Gdk.Gdk_Window associated to the widget 
  4202.    --  needs to enable the GDK_PROPERTY_CHANGE_MASK mask. 
  4203.    --  
  4204.    --  Callback parameters: 
  4205.    --    --  "event": the Gdk.Event.Gdk_Event_Property which triggered this signal. 
  4206.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  4207.  
  4208.    type Cb_Gtk_Widget_Gdk_Event_Proximity_Boolean is not null access function 
  4209.      (Self  : access Gtk_Widget_Record'Class; 
  4210.       Event : Gdk.Event.Gdk_Event_Proximity) return Boolean; 
  4211.  
  4212.    type Cb_GObject_Gdk_Event_Proximity_Boolean is not null access function 
  4213.      (Self  : access Glib.Object.GObject_Record'Class; 
  4214.       Event : Gdk.Event.Gdk_Event_Proximity) return Boolean; 
  4215.  
  4216.    Signal_Proximity_In_Event : constant Glib.Signal_Name := "proximity-in-event"; 
  4217.    procedure On_Proximity_In_Event 
  4218.       (Self  : not null access Gtk_Widget_Record; 
  4219.        Call  : Cb_Gtk_Widget_Gdk_Event_Proximity_Boolean; 
  4220.        After : Boolean := False); 
  4221.    procedure On_Proximity_In_Event 
  4222.       (Self  : not null access Gtk_Widget_Record; 
  4223.        Call  : Cb_GObject_Gdk_Event_Proximity_Boolean; 
  4224.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4225.        After : Boolean := False); 
  4226.    --  To receive this signal the Gdk.Gdk_Window associated to the widget 
  4227.    --  needs to enable the GDK_PROXIMITY_IN_MASK mask. 
  4228.    -- 
  4229.    --  This signal will be sent to the grab widget if there is one. 
  4230.    --  
  4231.    --  Callback parameters: 
  4232.    --    --  "event": the Gdk.Event.Gdk_Event_Proximity which triggered this signal. 
  4233.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  4234.  
  4235.    Signal_Proximity_Out_Event : constant Glib.Signal_Name := "proximity-out-event"; 
  4236.    procedure On_Proximity_Out_Event 
  4237.       (Self  : not null access Gtk_Widget_Record; 
  4238.        Call  : Cb_Gtk_Widget_Gdk_Event_Proximity_Boolean; 
  4239.        After : Boolean := False); 
  4240.    procedure On_Proximity_Out_Event 
  4241.       (Self  : not null access Gtk_Widget_Record; 
  4242.        Call  : Cb_GObject_Gdk_Event_Proximity_Boolean; 
  4243.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4244.        After : Boolean := False); 
  4245.    --  To receive this signal the Gdk.Gdk_Window associated to the widget 
  4246.    --  needs to enable the GDK_PROXIMITY_OUT_MASK mask. 
  4247.    -- 
  4248.    --  This signal will be sent to the grab widget if there is one. 
  4249.    --  
  4250.    --  Callback parameters: 
  4251.    --    --  "event": the Gdk.Event.Gdk_Event_Proximity which triggered this signal. 
  4252.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  4253.  
  4254.    type Cb_Gtk_Widget_Gint_Gint_Boolean_GObject_Boolean is not null access function 
  4255.      (Self          : access Gtk_Widget_Record'Class; 
  4256.       X             : Gint; 
  4257.       Y             : Gint; 
  4258.       Keyboard_Mode : Boolean; 
  4259.       Tooltip       : not null access Glib.Object.GObject_Record'Class) 
  4260.    return Boolean; 
  4261.  
  4262.    type Cb_GObject_Gint_Gint_Boolean_GObject_Boolean is not null access function 
  4263.      (Self          : access Glib.Object.GObject_Record'Class; 
  4264.       X             : Gint; 
  4265.       Y             : Gint; 
  4266.       Keyboard_Mode : Boolean; 
  4267.       Tooltip       : not null access Glib.Object.GObject_Record'Class) 
  4268.    return Boolean; 
  4269.  
  4270.    Signal_Query_Tooltip : constant Glib.Signal_Name := "query-tooltip"; 
  4271.    procedure On_Query_Tooltip 
  4272.       (Self  : not null access Gtk_Widget_Record; 
  4273.        Call  : Cb_Gtk_Widget_Gint_Gint_Boolean_GObject_Boolean; 
  4274.        After : Boolean := False); 
  4275.    procedure On_Query_Tooltip 
  4276.       (Self  : not null access Gtk_Widget_Record; 
  4277.        Call  : Cb_GObject_Gint_Gint_Boolean_GObject_Boolean; 
  4278.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4279.        After : Boolean := False); 
  4280.    --  Emitted when Gtk.Widget.Gtk_Widget:has-tooltip is True and the 
  4281.    --  Gtk.Settings.Gtk_Settings:gtk-tooltip-timeout has expired with the 
  4282.    --  cursor hovering "above" Widget; or emitted when Widget got focus in 
  4283.    --  keyboard mode. 
  4284.    -- 
  4285.    --  Using the given coordinates, the signal handler should determine 
  4286.    --  whether a tooltip should be shown for Widget. If this is the case True 
  4287.    --  should be returned, False otherwise. Note that if Keyboard_Mode is True, 
  4288.    --  the values of X and Y are undefined and should not be used. 
  4289.    -- 
  4290.    --  The signal handler is free to manipulate Tooltip with the therefore 
  4291.    --  destined function calls. 
  4292.    --  
  4293.    --  Callback parameters: 
  4294.    --    --  "x": the x coordinate of the cursor position where the request has been 
  4295.    --    --  emitted, relative to Widget's left side 
  4296.    --    --  "y": the y coordinate of the cursor position where the request has been 
  4297.    --    --  emitted, relative to Widget's top 
  4298.    --    --  "keyboard_mode": True if the tooltip was trigged using the keyboard 
  4299.    --    --  "tooltip": a Gtk.Tooltip.Gtk_Tooltip 
  4300.    --    --  Returns True if Tooltip should be shown right now, False otherwise. 
  4301.  
  4302.    Signal_Realize : constant Glib.Signal_Name := "realize"; 
  4303.    procedure On_Realize 
  4304.       (Self  : not null access Gtk_Widget_Record; 
  4305.        Call  : Cb_Gtk_Widget_Void; 
  4306.        After : Boolean := False); 
  4307.    procedure On_Realize 
  4308.       (Self  : not null access Gtk_Widget_Record; 
  4309.        Call  : Cb_GObject_Void; 
  4310.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4311.        After : Boolean := False); 
  4312.  
  4313.    type Cb_Gtk_Widget_Gdk_Screen_Void is not null access procedure 
  4314.      (Self            : access Gtk_Widget_Record'Class; 
  4315.       Previous_Screen : access Gdk.Screen.Gdk_Screen_Record'Class); 
  4316.  
  4317.    type Cb_GObject_Gdk_Screen_Void is not null access procedure 
  4318.      (Self            : access Glib.Object.GObject_Record'Class; 
  4319.       Previous_Screen : access Gdk.Screen.Gdk_Screen_Record'Class); 
  4320.  
  4321.    Signal_Screen_Changed : constant Glib.Signal_Name := "screen-changed"; 
  4322.    procedure On_Screen_Changed 
  4323.       (Self  : not null access Gtk_Widget_Record; 
  4324.        Call  : Cb_Gtk_Widget_Gdk_Screen_Void; 
  4325.        After : Boolean := False); 
  4326.    procedure On_Screen_Changed 
  4327.       (Self  : not null access Gtk_Widget_Record; 
  4328.        Call  : Cb_GObject_Gdk_Screen_Void; 
  4329.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4330.        After : Boolean := False); 
  4331.    --  The ::screen-changed signal gets emitted when the screen of a widget 
  4332.    --  has changed. 
  4333.  
  4334.    type Cb_Gtk_Widget_Gdk_Event_Scroll_Boolean is not null access function 
  4335.      (Self  : access Gtk_Widget_Record'Class; 
  4336.       Event : Gdk.Event.Gdk_Event_Scroll) return Boolean; 
  4337.  
  4338.    type Cb_GObject_Gdk_Event_Scroll_Boolean is not null access function 
  4339.      (Self  : access Glib.Object.GObject_Record'Class; 
  4340.       Event : Gdk.Event.Gdk_Event_Scroll) return Boolean; 
  4341.  
  4342.    Signal_Scroll_Event : constant Glib.Signal_Name := "scroll-event"; 
  4343.    procedure On_Scroll_Event 
  4344.       (Self  : not null access Gtk_Widget_Record; 
  4345.        Call  : Cb_Gtk_Widget_Gdk_Event_Scroll_Boolean; 
  4346.        After : Boolean := False); 
  4347.    procedure On_Scroll_Event 
  4348.       (Self  : not null access Gtk_Widget_Record; 
  4349.        Call  : Cb_GObject_Gdk_Event_Scroll_Boolean; 
  4350.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4351.        After : Boolean := False); 
  4352.    --  The ::scroll-event signal is emitted when a button in the 4 to 7 range 
  4353.    --  is pressed. Wheel mice are usually configured to generate button press 
  4354.    --  events for buttons 4 and 5 when the wheel is turned. 
  4355.    -- 
  4356.    --  To receive this signal, the Gdk.Gdk_Window associated to the widget 
  4357.    --  needs to enable the GDK_SCROLL_MASK mask. 
  4358.    -- 
  4359.    --  This signal will be sent to the grab widget if there is one. 
  4360.    --  
  4361.    --  Callback parameters: 
  4362.    --    --  "event": the Gdk.Event.Gdk_Event_Scroll which triggered this signal. 
  4363.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  4364.  
  4365.    type Cb_Gtk_Widget_Gdk_Event_Selection_Boolean is not null access function 
  4366.      (Self  : access Gtk_Widget_Record'Class; 
  4367.       Event : Gdk.Event.Gdk_Event_Selection) return Boolean; 
  4368.  
  4369.    type Cb_GObject_Gdk_Event_Selection_Boolean is not null access function 
  4370.      (Self  : access Glib.Object.GObject_Record'Class; 
  4371.       Event : Gdk.Event.Gdk_Event_Selection) return Boolean; 
  4372.  
  4373.    Signal_Selection_Clear_Event : constant Glib.Signal_Name := "selection-clear-event"; 
  4374.    procedure On_Selection_Clear_Event 
  4375.       (Self  : not null access Gtk_Widget_Record; 
  4376.        Call  : Cb_Gtk_Widget_Gdk_Event_Selection_Boolean; 
  4377.        After : Boolean := False); 
  4378.    procedure On_Selection_Clear_Event 
  4379.       (Self  : not null access Gtk_Widget_Record; 
  4380.        Call  : Cb_GObject_Gdk_Event_Selection_Boolean; 
  4381.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4382.        After : Boolean := False); 
  4383.    --  The ::selection-clear-event signal will be emitted when the the 
  4384.    --  Widget's window has lost ownership of a selection. 
  4385.    --  
  4386.    --  Callback parameters: 
  4387.    --    --  "event": the Gdk.Event.Gdk_Event_Selection which triggered this signal. 
  4388.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  4389.  
  4390.    type Cb_Gtk_Widget_Gtk_Selection_Data_Guint_Guint_Void is not null access procedure 
  4391.      (Self : access Gtk_Widget_Record'Class; 
  4392.       Data : Gtk.Selection_Data.Gtk_Selection_Data; 
  4393.       Info : Guint; 
  4394.       Time : Guint); 
  4395.  
  4396.    type Cb_GObject_Gtk_Selection_Data_Guint_Guint_Void is not null access procedure 
  4397.      (Self : access Glib.Object.GObject_Record'Class; 
  4398.       Data : Gtk.Selection_Data.Gtk_Selection_Data; 
  4399.       Info : Guint; 
  4400.       Time : Guint); 
  4401.  
  4402.    Signal_Selection_Get : constant Glib.Signal_Name := "selection-get"; 
  4403.    procedure On_Selection_Get 
  4404.       (Self  : not null access Gtk_Widget_Record; 
  4405.        Call  : Cb_Gtk_Widget_Gtk_Selection_Data_Guint_Guint_Void; 
  4406.        After : Boolean := False); 
  4407.    procedure On_Selection_Get 
  4408.       (Self  : not null access Gtk_Widget_Record; 
  4409.        Call  : Cb_GObject_Gtk_Selection_Data_Guint_Guint_Void; 
  4410.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4411.        After : Boolean := False); 
  4412.    --  
  4413.    --  Callback parameters: 
  4414.  
  4415.    Signal_Selection_Notify_Event : constant Glib.Signal_Name := "selection-notify-event"; 
  4416.    procedure On_Selection_Notify_Event 
  4417.       (Self  : not null access Gtk_Widget_Record; 
  4418.        Call  : Cb_Gtk_Widget_Gdk_Event_Selection_Boolean; 
  4419.        After : Boolean := False); 
  4420.    procedure On_Selection_Notify_Event 
  4421.       (Self  : not null access Gtk_Widget_Record; 
  4422.        Call  : Cb_GObject_Gdk_Event_Selection_Boolean; 
  4423.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4424.        After : Boolean := False); 
  4425.    --  
  4426.    --  Callback parameters: 
  4427.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  4428.  
  4429.    type Cb_Gtk_Widget_Gtk_Selection_Data_Guint_Void is not null access procedure 
  4430.      (Self : access Gtk_Widget_Record'Class; 
  4431.       Data : Gtk.Selection_Data.Gtk_Selection_Data; 
  4432.       Time : Guint); 
  4433.  
  4434.    type Cb_GObject_Gtk_Selection_Data_Guint_Void is not null access procedure 
  4435.      (Self : access Glib.Object.GObject_Record'Class; 
  4436.       Data : Gtk.Selection_Data.Gtk_Selection_Data; 
  4437.       Time : Guint); 
  4438.  
  4439.    Signal_Selection_Received : constant Glib.Signal_Name := "selection-received"; 
  4440.    procedure On_Selection_Received 
  4441.       (Self  : not null access Gtk_Widget_Record; 
  4442.        Call  : Cb_Gtk_Widget_Gtk_Selection_Data_Guint_Void; 
  4443.        After : Boolean := False); 
  4444.    procedure On_Selection_Received 
  4445.       (Self  : not null access Gtk_Widget_Record; 
  4446.        Call  : Cb_GObject_Gtk_Selection_Data_Guint_Void; 
  4447.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4448.        After : Boolean := False); 
  4449.    --  
  4450.    --  Callback parameters: 
  4451.  
  4452.    Signal_Selection_Request_Event : constant Glib.Signal_Name := "selection-request-event"; 
  4453.    procedure On_Selection_Request_Event 
  4454.       (Self  : not null access Gtk_Widget_Record; 
  4455.        Call  : Cb_Gtk_Widget_Gdk_Event_Selection_Boolean; 
  4456.        After : Boolean := False); 
  4457.    procedure On_Selection_Request_Event 
  4458.       (Self  : not null access Gtk_Widget_Record; 
  4459.        Call  : Cb_GObject_Gdk_Event_Selection_Boolean; 
  4460.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4461.        After : Boolean := False); 
  4462.    --  The ::selection-request-event signal will be emitted when another 
  4463.    --  client requests ownership of the selection owned by the Widget's window. 
  4464.    --  
  4465.    --  Callback parameters: 
  4466.    --    --  "event": the Gdk.Event.Gdk_Event_Selection which triggered this signal. 
  4467.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  4468.  
  4469.    Signal_Show : constant Glib.Signal_Name := "show"; 
  4470.    procedure On_Show 
  4471.       (Self  : not null access Gtk_Widget_Record; 
  4472.        Call  : Cb_Gtk_Widget_Void; 
  4473.        After : Boolean := False); 
  4474.    procedure On_Show 
  4475.       (Self  : not null access Gtk_Widget_Record; 
  4476.        Call  : Cb_GObject_Void; 
  4477.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4478.        After : Boolean := False); 
  4479.  
  4480.    type Cb_Gtk_Widget_Gtk_Widget_Help_Type_Boolean is not null access function 
  4481.      (Self      : access Gtk_Widget_Record'Class; 
  4482.       Help_Type : Gtk_Widget_Help_Type) return Boolean; 
  4483.  
  4484.    type Cb_GObject_Gtk_Widget_Help_Type_Boolean is not null access function 
  4485.      (Self      : access Glib.Object.GObject_Record'Class; 
  4486.       Help_Type : Gtk_Widget_Help_Type) return Boolean; 
  4487.  
  4488.    Signal_Show_Help : constant Glib.Signal_Name := "show-help"; 
  4489.    procedure On_Show_Help 
  4490.       (Self  : not null access Gtk_Widget_Record; 
  4491.        Call  : Cb_Gtk_Widget_Gtk_Widget_Help_Type_Boolean; 
  4492.        After : Boolean := False); 
  4493.    procedure On_Show_Help 
  4494.       (Self  : not null access Gtk_Widget_Record; 
  4495.        Call  : Cb_GObject_Gtk_Widget_Help_Type_Boolean; 
  4496.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4497.        After : Boolean := False); 
  4498.    --  
  4499.    --  Callback parameters: 
  4500.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  4501.  
  4502.    type Cb_Gtk_Widget_Cairo_Rectangle_Int_Void is not null access procedure 
  4503.      (Self       : access Gtk_Widget_Record'Class; 
  4504.       Allocation : Cairo.Region.Cairo_Rectangle_Int); 
  4505.  
  4506.    type Cb_GObject_Cairo_Rectangle_Int_Void is not null access procedure 
  4507.      (Self       : access Glib.Object.GObject_Record'Class; 
  4508.       Allocation : Cairo.Region.Cairo_Rectangle_Int); 
  4509.  
  4510.    Signal_Size_Allocate : constant Glib.Signal_Name := "size-allocate"; 
  4511.    procedure On_Size_Allocate 
  4512.       (Self  : not null access Gtk_Widget_Record; 
  4513.        Call  : Cb_Gtk_Widget_Cairo_Rectangle_Int_Void; 
  4514.        After : Boolean := False); 
  4515.    procedure On_Size_Allocate 
  4516.       (Self  : not null access Gtk_Widget_Record; 
  4517.        Call  : Cb_GObject_Cairo_Rectangle_Int_Void; 
  4518.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4519.        After : Boolean := False); 
  4520.  
  4521.    type Cb_Gtk_Widget_Gtk_State_Type_Void is not null access procedure 
  4522.      (Self  : access Gtk_Widget_Record'Class; 
  4523.       State : Gtk.Enums.Gtk_State_Type); 
  4524.  
  4525.    type Cb_GObject_Gtk_State_Type_Void is not null access procedure 
  4526.      (Self  : access Glib.Object.GObject_Record'Class; 
  4527.       State : Gtk.Enums.Gtk_State_Type); 
  4528.  
  4529.    Signal_State_Changed : constant Glib.Signal_Name := "state-changed"; 
  4530.    procedure On_State_Changed 
  4531.       (Self  : not null access Gtk_Widget_Record; 
  4532.        Call  : Cb_Gtk_Widget_Gtk_State_Type_Void; 
  4533.        After : Boolean := False); 
  4534.    procedure On_State_Changed 
  4535.       (Self  : not null access Gtk_Widget_Record; 
  4536.        Call  : Cb_GObject_Gtk_State_Type_Void; 
  4537.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4538.        After : Boolean := False); 
  4539.    --  The ::state-changed signal is emitted when the widget state changes. 
  4540.    --  See Gtk.Widget.Get_State. 
  4541.  
  4542.    type Cb_Gtk_Widget_Gtk_State_Flags_Void is not null access procedure 
  4543.      (Self  : access Gtk_Widget_Record'Class; 
  4544.       Flags : Gtk.Enums.Gtk_State_Flags); 
  4545.  
  4546.    type Cb_GObject_Gtk_State_Flags_Void is not null access procedure 
  4547.      (Self  : access Glib.Object.GObject_Record'Class; 
  4548.       Flags : Gtk.Enums.Gtk_State_Flags); 
  4549.  
  4550.    Signal_State_Flags_Changed : constant Glib.Signal_Name := "state-flags-changed"; 
  4551.    procedure On_State_Flags_Changed 
  4552.       (Self  : not null access Gtk_Widget_Record; 
  4553.        Call  : Cb_Gtk_Widget_Gtk_State_Flags_Void; 
  4554.        After : Boolean := False); 
  4555.    procedure On_State_Flags_Changed 
  4556.       (Self  : not null access Gtk_Widget_Record; 
  4557.        Call  : Cb_GObject_Gtk_State_Flags_Void; 
  4558.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4559.        After : Boolean := False); 
  4560.    --  The ::state-flags-changed signal is emitted when the widget state 
  4561.    --  changes, see Gtk.Widget.Get_State_Flags. 
  4562.  
  4563.    type Cb_Gtk_Widget_Gtk_Style_Void is not null access procedure 
  4564.      (Self           : access Gtk_Widget_Record'Class; 
  4565.       Previous_Style : access Gtk.Style.Gtk_Style_Record'Class); 
  4566.  
  4567.    type Cb_GObject_Gtk_Style_Void is not null access procedure 
  4568.      (Self           : access Glib.Object.GObject_Record'Class; 
  4569.       Previous_Style : access Gtk.Style.Gtk_Style_Record'Class); 
  4570.  
  4571.    Signal_Style_Set : constant Glib.Signal_Name := "style-set"; 
  4572.    procedure On_Style_Set 
  4573.       (Self  : not null access Gtk_Widget_Record; 
  4574.        Call  : Cb_Gtk_Widget_Gtk_Style_Void; 
  4575.        After : Boolean := False); 
  4576.    procedure On_Style_Set 
  4577.       (Self  : not null access Gtk_Widget_Record; 
  4578.        Call  : Cb_GObject_Gtk_Style_Void; 
  4579.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4580.        After : Boolean := False); 
  4581.    --  The ::style-set signal is emitted when a new style has been set on a 
  4582.    --  widget. Note that style-modifying functions like Gtk.Widget.Modify_Base 
  4583.    --  also cause this signal to be emitted. 
  4584.    -- 
  4585.    --  Note that this signal is emitted for changes to the deprecated 
  4586.    --  Gtk.Style.Gtk_Style. To track changes to the 
  4587.    --  Gtk.Style_Context.Gtk_Style_Context associated with a widget, use the 
  4588.    --  Gtk.Widget.Gtk_Widget::style-updated signal. 
  4589.  
  4590.    Signal_Style_Updated : constant Glib.Signal_Name := "style-updated"; 
  4591.    procedure On_Style_Updated 
  4592.       (Self  : not null access Gtk_Widget_Record; 
  4593.        Call  : Cb_Gtk_Widget_Void; 
  4594.        After : Boolean := False); 
  4595.    procedure On_Style_Updated 
  4596.       (Self  : not null access Gtk_Widget_Record; 
  4597.        Call  : Cb_GObject_Void; 
  4598.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4599.        After : Boolean := False); 
  4600.    --  The ::style-updated signal is emitted when the 
  4601.    --  Gtk.Style_Context.Gtk_Style_Context of a widget is changed. Note that 
  4602.    --  style-modifying functions like Gtk.Widget.Override_Color also cause this 
  4603.    --  signal to be emitted. 
  4604.  
  4605.    Signal_Touch_Event : constant Glib.Signal_Name := "touch-event"; 
  4606.    procedure On_Touch_Event 
  4607.       (Self  : not null access Gtk_Widget_Record; 
  4608.        Call  : Cb_Gtk_Widget_Gdk_Event_Boolean; 
  4609.        After : Boolean := False); 
  4610.    procedure On_Touch_Event 
  4611.       (Self  : not null access Gtk_Widget_Record; 
  4612.        Call  : Cb_GObject_Gdk_Event_Boolean; 
  4613.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4614.        After : Boolean := False); 
  4615.  
  4616.    Signal_Unmap : constant Glib.Signal_Name := "unmap"; 
  4617.    procedure On_Unmap 
  4618.       (Self  : not null access Gtk_Widget_Record; 
  4619.        Call  : Cb_Gtk_Widget_Void; 
  4620.        After : Boolean := False); 
  4621.    procedure On_Unmap 
  4622.       (Self  : not null access Gtk_Widget_Record; 
  4623.        Call  : Cb_GObject_Void; 
  4624.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4625.        After : Boolean := False); 
  4626.  
  4627.    Signal_Unmap_Event : constant Glib.Signal_Name := "unmap-event"; 
  4628.    procedure On_Unmap_Event 
  4629.       (Self  : not null access Gtk_Widget_Record; 
  4630.        Call  : Cb_Gtk_Widget_Gdk_Event_Any_Boolean; 
  4631.        After : Boolean := False); 
  4632.    procedure On_Unmap_Event 
  4633.       (Self  : not null access Gtk_Widget_Record; 
  4634.        Call  : Cb_GObject_Gdk_Event_Any_Boolean; 
  4635.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4636.        After : Boolean := False); 
  4637.    --  The ::unmap-event signal will be emitted when the Widget's window is 
  4638.    --  unmapped. A window is unmapped when it becomes invisible on the screen. 
  4639.    -- 
  4640.    --  To receive this signal, the Gdk.Gdk_Window associated to the widget 
  4641.    --  needs to enable the GDK_STRUCTURE_MASK mask. GDK will enable this mask 
  4642.    --  automatically for all new windows. 
  4643.    --  
  4644.    --  Callback parameters: 
  4645.    --    --  "event": the Gdk.Event.Gdk_Event_Any which triggered this signal 
  4646.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  4647.  
  4648.    Signal_Unrealize : constant Glib.Signal_Name := "unrealize"; 
  4649.    procedure On_Unrealize 
  4650.       (Self  : not null access Gtk_Widget_Record; 
  4651.        Call  : Cb_Gtk_Widget_Void; 
  4652.        After : Boolean := False); 
  4653.    procedure On_Unrealize 
  4654.       (Self  : not null access Gtk_Widget_Record; 
  4655.        Call  : Cb_GObject_Void; 
  4656.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4657.        After : Boolean := False); 
  4658.  
  4659.    type Cb_Gtk_Widget_Gdk_Event_Visibility_Boolean is not null access function 
  4660.      (Self  : access Gtk_Widget_Record'Class; 
  4661.       Event : Gdk.Event.Gdk_Event_Visibility) return Boolean; 
  4662.  
  4663.    type Cb_GObject_Gdk_Event_Visibility_Boolean is not null access function 
  4664.      (Self  : access Glib.Object.GObject_Record'Class; 
  4665.       Event : Gdk.Event.Gdk_Event_Visibility) return Boolean; 
  4666.  
  4667.    Signal_Visibility_Notify_Event : constant Glib.Signal_Name := "visibility-notify-event"; 
  4668.    procedure On_Visibility_Notify_Event 
  4669.       (Self  : not null access Gtk_Widget_Record; 
  4670.        Call  : Cb_Gtk_Widget_Gdk_Event_Visibility_Boolean; 
  4671.        After : Boolean := False); 
  4672.    procedure On_Visibility_Notify_Event 
  4673.       (Self  : not null access Gtk_Widget_Record; 
  4674.        Call  : Cb_GObject_Gdk_Event_Visibility_Boolean; 
  4675.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4676.        After : Boolean := False); 
  4677.    --  The ::visibility-notify-event will be emitted when the Widget's window 
  4678.    --  is obscured or unobscured. 
  4679.    -- 
  4680.    --  To receive this signal the Gdk.Gdk_Window associated to the widget 
  4681.    --  needs to enable the GDK_VISIBILITY_NOTIFY_MASK mask. 
  4682.    --  
  4683.    --  Callback parameters: 
  4684.    --    --  "event": the Gdk.Event.Gdk_Event_Visibility which triggered this 
  4685.    --    --  signal. 
  4686.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  4687.  
  4688.    type Cb_Gtk_Widget_Gdk_Event_Window_State_Boolean is not null access function 
  4689.      (Self  : access Gtk_Widget_Record'Class; 
  4690.       Event : Gdk.Event.Gdk_Event_Window_State) return Boolean; 
  4691.  
  4692.    type Cb_GObject_Gdk_Event_Window_State_Boolean is not null access function 
  4693.      (Self  : access Glib.Object.GObject_Record'Class; 
  4694.       Event : Gdk.Event.Gdk_Event_Window_State) return Boolean; 
  4695.  
  4696.    Signal_Window_State_Event : constant Glib.Signal_Name := "window-state-event"; 
  4697.    procedure On_Window_State_Event 
  4698.       (Self  : not null access Gtk_Widget_Record; 
  4699.        Call  : Cb_Gtk_Widget_Gdk_Event_Window_State_Boolean; 
  4700.        After : Boolean := False); 
  4701.    procedure On_Window_State_Event 
  4702.       (Self  : not null access Gtk_Widget_Record; 
  4703.        Call  : Cb_GObject_Gdk_Event_Window_State_Boolean; 
  4704.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  4705.        After : Boolean := False); 
  4706.    --  The ::window-state-event will be emitted when the state of the toplevel 
  4707.    --  window associated to the Widget changes. 
  4708.    -- 
  4709.    --  To receive this signal the Gdk.Gdk_Window associated to the widget 
  4710.    --  needs to enable the GDK_STRUCTURE_MASK mask. GDK will enable this mask 
  4711.    --  automatically for all new windows. 
  4712.    --  
  4713.    --  Callback parameters: 
  4714.    --    --  "event": the Gdk.Event.Gdk_Event_Window_State which triggered this 
  4715.    --    --  signal. 
  4716.    --    --  Returns True to stop other handlers from being invoked for the event. False to propagate the event further. 
  4717.  
  4718. private 
  4719.    Window_Property : constant Glib.Properties.Property_Boxed := 
  4720.      Glib.Properties.Build ("window"); 
  4721.    Width_Request_Property : constant Glib.Properties.Property_Int := 
  4722.      Glib.Properties.Build ("width-request"); 
  4723.    Visible_Property : constant Glib.Properties.Property_Boolean := 
  4724.      Glib.Properties.Build ("visible"); 
  4725.    Vexpand_Set_Property : constant Glib.Properties.Property_Boolean := 
  4726.      Glib.Properties.Build ("vexpand-set"); 
  4727.    Vexpand_Property : constant Glib.Properties.Property_Boolean := 
  4728.      Glib.Properties.Build ("vexpand"); 
  4729.    Valign_Property : constant Gtk.Widget.Property_Gtk_Align := 
  4730.      Gtk.Widget.Build ("valign"); 
  4731.    Tooltip_Text_Property : constant Glib.Properties.Property_String := 
  4732.      Glib.Properties.Build ("tooltip-text"); 
  4733.    Tooltip_Markup_Property : constant Glib.Properties.Property_String := 
  4734.      Glib.Properties.Build ("tooltip-markup"); 
  4735.    Style_Property : constant Glib.Properties.Property_Object := 
  4736.      Glib.Properties.Build ("style"); 
  4737.    Sensitive_Property : constant Glib.Properties.Property_Boolean := 
  4738.      Glib.Properties.Build ("sensitive"); 
  4739.    Receives_Default_Property : constant Glib.Properties.Property_Boolean := 
  4740.      Glib.Properties.Build ("receives-default"); 
  4741.    Parent_Property : constant Glib.Properties.Property_Object := 
  4742.      Glib.Properties.Build ("parent"); 
  4743.    Opacity_Property : constant Glib.Properties.Property_Double := 
  4744.      Glib.Properties.Build ("opacity"); 
  4745.    No_Show_All_Property : constant Glib.Properties.Property_Boolean := 
  4746.      Glib.Properties.Build ("no-show-all"); 
  4747.    Name_Property : constant Glib.Properties.Property_String := 
  4748.      Glib.Properties.Build ("name"); 
  4749.    Margin_Top_Property : constant Glib.Properties.Property_Int := 
  4750.      Glib.Properties.Build ("margin-top"); 
  4751.    Margin_Right_Property : constant Glib.Properties.Property_Int := 
  4752.      Glib.Properties.Build ("margin-right"); 
  4753.    Margin_Left_Property : constant Glib.Properties.Property_Int := 
  4754.      Glib.Properties.Build ("margin-left"); 
  4755.    Margin_Bottom_Property : constant Glib.Properties.Property_Int := 
  4756.      Glib.Properties.Build ("margin-bottom"); 
  4757.    Margin_Property : constant Glib.Properties.Property_Int := 
  4758.      Glib.Properties.Build ("margin"); 
  4759.    Is_Focus_Property : constant Glib.Properties.Property_Boolean := 
  4760.      Glib.Properties.Build ("is-focus"); 
  4761.    Hexpand_Set_Property : constant Glib.Properties.Property_Boolean := 
  4762.      Glib.Properties.Build ("hexpand-set"); 
  4763.    Hexpand_Property : constant Glib.Properties.Property_Boolean := 
  4764.      Glib.Properties.Build ("hexpand"); 
  4765.    Height_Request_Property : constant Glib.Properties.Property_Int := 
  4766.      Glib.Properties.Build ("height-request"); 
  4767.    Has_Tooltip_Property : constant Glib.Properties.Property_Boolean := 
  4768.      Glib.Properties.Build ("has-tooltip"); 
  4769.    Has_Focus_Property : constant Glib.Properties.Property_Boolean := 
  4770.      Glib.Properties.Build ("has-focus"); 
  4771.    Has_Default_Property : constant Glib.Properties.Property_Boolean := 
  4772.      Glib.Properties.Build ("has-default"); 
  4773.    Halign_Property : constant Gtk.Widget.Property_Gtk_Align := 
  4774.      Gtk.Widget.Build ("halign"); 
  4775.    Expand_Property : constant Glib.Properties.Property_Boolean := 
  4776.      Glib.Properties.Build ("expand"); 
  4777.    Events_Property : constant Gdk.Event.Property_Gdk_Event_Mask := 
  4778.      Gdk.Event.Build ("events"); 
  4779.    Double_Buffered_Property : constant Glib.Properties.Property_Boolean := 
  4780.      Glib.Properties.Build ("double-buffered"); 
  4781.    Composite_Child_Property : constant Glib.Properties.Property_Boolean := 
  4782.      Glib.Properties.Build ("composite-child"); 
  4783.    Can_Focus_Property : constant Glib.Properties.Property_Boolean := 
  4784.      Glib.Properties.Build ("can-focus"); 
  4785.    Can_Default_Property : constant Glib.Properties.Property_Boolean := 
  4786.      Glib.Properties.Build ("can-default"); 
  4787.    App_Paintable_Property : constant Glib.Properties.Property_Boolean := 
  4788.      Glib.Properties.Build ("app-paintable"); 
  4789. end Gtk.Widget;