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. --  The Gtk.Cell_Area.Gtk_Cell_Area is an abstract class for 
  26. --  Gtk.Cell_Layout.Gtk_Cell_Layout widgets (also referred to as "layouting 
  27. --  widgets") to interface with an arbitrary number of Gtk_Cell_Renderers and 
  28. --  interact with the user for a given Gtk.Tree_Model.Gtk_Tree_Model row. 
  29. -- 
  30. --  The cell area handles events, focus navigation, drawing and size requests 
  31. --  and allocations for a given row of data. 
  32. -- 
  33. --  Usually users dont have to interact with the Gtk.Cell_Area.Gtk_Cell_Area 
  34. --  directly unless they are implementing a cell-layouting widget themselves. 
  35. -- 
  36. --  == Requesting area sizes == 
  37. -- 
  38. --  As outlined in <link linkend="geometry-management">GtkWidget's geometry 
  39. --  management section</link>, GTK+ uses a height-for-width geometry management 
  40. --  system to compute the sizes of widgets and user interfaces. 
  41. --  Gtk.Cell_Area.Gtk_Cell_Area uses the same semantics to calculate the size 
  42. --  of an area for an arbitrary number of Gtk.Tree_Model.Gtk_Tree_Model rows. 
  43. -- 
  44. --  When requesting the size of a cell area one needs to calculate the size 
  45. --  for a handful of rows, and this will be done differently by different 
  46. --  layouting widgets. For instance a Gtk.Tree_View_Column.Gtk_Tree_View_Column 
  47. --  always lines up the areas from top to bottom while a 
  48. --  Gtk.Icon_View.Gtk_Icon_View on the other hand might enforce that all areas 
  49. --  received the same width and wrap the areas around, requesting height for 
  50. --  more cell areas when allocated less width. 
  51. -- 
  52. --  It's also important for areas to maintain some cell alignments with areas 
  53. --  rendered for adjacent rows (cells can appear "columnized" inside an area 
  54. --  even when the size of cells are different in each row). For this reason the 
  55. --  Gtk.Cell_Area.Gtk_Cell_Area uses a 
  56. --  Gtk.Cell_Area_Context.Gtk_Cell_Area_Context object to store the alignments 
  57. --  and sizes along the way (as well as the overall largest minimum and natural 
  58. --  size for all the rows which have been calculated with the said context). 
  59. -- 
  60. --  The Gtk.Cell_Area_Context.Gtk_Cell_Area_Context is an opaque object 
  61. --  specific to the Gtk.Cell_Area.Gtk_Cell_Area which created it (see 
  62. --  Gtk.Cell_Area.Create_Context). The owning cell-layouting widget can create 
  63. --  as many contexts as it wishes to calculate sizes of rows which should 
  64. --  receive the same size in at least one orientation (horizontally or 
  65. --  vertically), However, it's important that the same 
  66. --  Gtk.Cell_Area_Context.Gtk_Cell_Area_Context which was used to request the 
  67. --  sizes for a given Gtk.Tree_Model.Gtk_Tree_Model row be used when rendering 
  68. --  or processing events for that row. 
  69. -- 
  70. --  In order to request the width of all the rows at the root level of a 
  71. --  Gtk.Tree_Model.Gtk_Tree_Model one would do the following: 
  72. -- 
  73. --  
  74. -- 
  75. --  == Requesting the width of a handful of GtkTreeModel rows == 
  76. -- 
  77. --  
  78. -- 
  79. --    GtkTreeIter iter; 
  80. --    gint        minimum_width; 
  81. --    gint        natural_width; 
  82. --    valid = gtk_tree_model_get_iter_first (model, &iter); 
  83. --    while (valid) 
  84. --    { 
  85. --       gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE); 
  86. --       gtk_cell_area_get_preferred_width (area, context, widget, NULL, NULL); 
  87. --       valid = gtk_tree_model_iter_next (model, &iter); 
  88. --    } 
  89. --    gtk_cell_area_context_get_preferred_width (context, &minimum_width, &natural_width); 
  90. -- 
  91. --  Note that in this example it's not important to observe the returned 
  92. --  minimum and natural width of the area for each row unless the 
  93. --  cell-layouting object is actually interested in the widths of individual 
  94. --  rows. The overall width is however stored in the accompanying 
  95. --  Gtk.Cell_Area_Context.Gtk_Cell_Area_Context object and can be consulted at 
  96. --  any time. 
  97. -- 
  98. --  This can be useful since Gtk.Cell_Layout.Gtk_Cell_Layout widgets usually 
  99. --  have to support requesting and rendering rows in treemodels with an 
  100. --  exceedingly large amount of rows. The Gtk.Cell_Layout.Gtk_Cell_Layout 
  101. --  widget in that case would calculate the required width of the rows in an 
  102. --  idle or timeout source (see g_timeout_add) and when the widget is requested 
  103. --  its actual width in Gtk.Widget.GObject_Class.get_preferred_width it can 
  104. --  simply consult the width accumulated so far in the 
  105. --  Gtk.Cell_Area_Context.Gtk_Cell_Area_Context object. 
  106. -- 
  107. --  A simple example where rows are rendered from top to bottom and take up 
  108. --  the full width of the layouting widget would look like: 
  109. -- 
  110. --  
  111. -- 
  112. --  == A typical get_preferred_width implementation == 
  113. -- 
  114. --  
  115. -- 
  116. --    static void 
  117. --    foo_get_preferred_width (GtkWidget       *widget, 
  118. --       gint            *minimum_size, 
  119. --       gint            *natural_size) 
  120. --    { 
  121. --       Foo        *foo  = FOO (widget); 
  122. --       FooPrivate *priv = foo->priv; 
  123. --       foo_ensure_at_least_one_handfull_of_rows_have_been_requested (foo); 
  124. --       gtk_cell_area_context_get_preferred_width (priv->context, minimum_size, natural_size); 
  125. --    } 
  126. -- 
  127. --  In the above example the Foo widget has to make sure that some row sizes 
  128. --  have been calculated (the amount of rows that Foo judged was appropriate to 
  129. --  request space for in a single timeout iteration) before simply returning 
  130. --  the amount of space required by the area via the 
  131. --  Gtk.Cell_Area_Context.Gtk_Cell_Area_Context. 
  132. -- 
  133. --  Requesting the height for width (or width for height) of an area is a 
  134. --  similar task except in this case the 
  135. --  Gtk.Cell_Area_Context.Gtk_Cell_Area_Context does not store the data 
  136. --  (actually, it does not know how much space the layouting widget plans to 
  137. --  allocate it for every row. It's up to the layouting widget to render each 
  138. --  row of data with the appropriate height and width which was requested by 
  139. --  the Gtk.Cell_Area.Gtk_Cell_Area). 
  140. -- 
  141. --  In order to request the height for width of all the rows at the root level 
  142. --  of a Gtk.Tree_Model.Gtk_Tree_Model one would do the following: 
  143. -- 
  144. --  
  145. -- 
  146. --  == Requesting the height for width of a handful of GtkTreeModel rows == 
  147. -- 
  148. --  
  149. -- 
  150. --    GtkTreeIter iter; 
  151. --    gint        minimum_height; 
  152. --    gint        natural_height; 
  153. --    gint        full_minimum_height = 0; 
  154. --    gint        full_natural_height = 0; 
  155. --    valid = gtk_tree_model_get_iter_first (model, &iter); 
  156. --    while (valid) 
  157. --    { 
  158. --       gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE); 
  159. --       gtk_cell_area_get_preferred_height_for_width (area, context, widget, 
  160. --          width, &minimum_height, &natural_height); 
  161. --       if (width_is_for_allocation) 
  162. --       cache_row_height (&iter, minimum_height, natural_height); 
  163. --       full_minimum_height += minimum_height; 
  164. --       full_natural_height += natural_height; 
  165. --       valid = gtk_tree_model_iter_next (model, &iter); 
  166. --    } 
  167. -- 
  168. --  Note that in the above example we would need to cache the heights returned 
  169. --  for each row so that we would know what sizes to render the areas for each 
  170. --  row. However we would only want to really cache the heights if the request 
  171. --  is intended for the layouting widgets real allocation. 
  172. -- 
  173. --  In some cases the layouting widget is requested the height for an 
  174. --  arbitrary for_width, this is a special case for layouting widgets who need 
  175. --  to request size for tens of thousands of rows. For this case it's only 
  176. --  important that the layouting widget calculate one reasonably sized chunk of 
  177. --  rows and return that height synchronously. The reasoning here is that any 
  178. --  layouting widget is at least capable of synchronously calculating enough 
  179. --  height to fill the screen height (or scrolled window height) in response to 
  180. --  a single call to Gtk.Widget.GObject_Class.get_preferred_height_for_width. 
  181. --  Returning a perfect height for width that is larger than the screen area is 
  182. --  inconsequential since after the layouting receives an allocation from a 
  183. --  scrolled window it simply continues to drive the scrollbar values while 
  184. --  more and more height is required for the row heights that are calculated in 
  185. --  the background. 
  186. -- 
  187. --  == Rendering Areas == 
  188. -- 
  189. --  Once area sizes have been aquired at least for the rows in the visible 
  190. --  area of the layouting widget they can be rendered at 
  191. --  Gtk.Widget.GObject_Class.draw time. 
  192. -- 
  193. --  A crude example of how to render all the rows at the root level runs as 
  194. --  follows: 
  195. -- 
  196. --  
  197. -- 
  198. --  == Requesting the width of a handful of GtkTreeModel rows == 
  199. -- 
  200. --  
  201. -- 
  202. --    GtkAllocation allocation; 
  203. --    GdkRectangle  cell_area = { 0, }; 
  204. --    GtkTreeIter   iter; 
  205. --    gint          minimum_width; 
  206. --    gint          natural_width; 
  207. --    gtk_widget_get_allocation (widget, &allocation); 
  208. --    cell_area.width = allocation.width; 
  209. --    valid = gtk_tree_model_get_iter_first (model, &iter); 
  210. --    while (valid) 
  211. --    { 
  212. --       cell_area.height = get_cached_height_for_row (&iter); 
  213. --       gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE); 
  214. --       gtk_cell_area_render (area, context, widget, cr, 
  215. --          &cell_area, &cell_area, state_flags, FALSE); 
  216. --       cell_area.y += cell_area.height; 
  217. --       valid = gtk_tree_model_iter_next (model, &iter); 
  218. --    } 
  219. -- 
  220. --  Note that the cached height in this example really depends on how the 
  221. --  layouting widget works. The layouting widget might decide to give every row 
  222. --  its minimum or natural height or, if the model content is expected to fit 
  223. --  inside the layouting widget without scrolling, it would make sense to 
  224. --  calculate the allocation for each row at 
  225. --  Gtk.Widget.Gtk_Widget::size-allocate time using 
  226. --  gtk_distribute_natural_allocation. 
  227. -- 
  228. --  == Handling Events and Driving Keyboard Focus == 
  229. -- 
  230. --  Passing events to the area is as simple as handling events on any normal 
  231. --  widget and then passing them to the Gtk.Cell_Area.Event API as they come 
  232. --  in. Usually Gtk.Cell_Area.Gtk_Cell_Area is only interested in button 
  233. --  events, however some customized derived areas can be implemented who are 
  234. --  interested in handling other events. Handling an event can trigger the 
  235. --  Gtk.Cell_Area.Gtk_Cell_Area::focus-changed signal to fire; as well as 
  236. --  Gtk.Cell_Area.Gtk_Cell_Area::add-editable in the case that an editable cell 
  237. --  was clicked and needs to start editing. You can call 
  238. --  Gtk.Cell_Area.Stop_Editing at any time to cancel any cell editing that is 
  239. --  currently in progress. 
  240. -- 
  241. --  The Gtk.Cell_Area.Gtk_Cell_Area drives keyboard focus from cell to cell in 
  242. --  a way similar to Gtk.Widget.Gtk_Widget. For layouting widgets that support 
  243. --  giving focus to cells it's important to remember to pass 
  244. --  Gtk.Cell_Renderer.Cell_Renderer_Focused to the area functions for the row 
  245. --  that has focus and to tell the area to paint the focus at render time. 
  246. -- 
  247. --  Layouting widgets that accept focus on cells should implement the 
  248. --  Gtk.Widget.GObject_Class.focus virtual method. The layouting widget is 
  249. --  always responsible for knowing where Gtk.Tree_Model.Gtk_Tree_Model rows are 
  250. --  rendered inside the widget, so at Gtk.Widget.GObject_Class.focus time the 
  251. --  layouting widget should use the Gtk.Cell_Area.Gtk_Cell_Area methods to 
  252. --  navigate focus inside the area and then observe the GtkDirectionType to 
  253. --  pass the focus to adjacent rows and areas. 
  254. -- 
  255. --  A basic example of how the Gtk.Widget.GObject_Class.focus virtual method 
  256. --  should be implemented: 
  257. -- 
  258. --  
  259. -- 
  260. --  == Implementing keyboard focus navigation == 
  261. -- 
  262. --  
  263. -- 
  264. --    static gboolean 
  265. --    foo_focus (GtkWidget       *widget, 
  266. --       GtkDirectionType direction) 
  267. --    { 
  268. --       Foo        *foo  = FOO (widget); 
  269. --       FooPrivate *priv = foo->priv; 
  270. --       gint        focus_row; 
  271. --       gboolean    have_focus = FALSE; 
  272. --       focus_row = priv->focus_row; 
  273. --       if (!gtk_widget_has_focus (widget)) 
  274. --       gtk_widget_grab_focus (widget); 
  275. --       valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, priv->focus_row); 
  276. --       while (valid) 
  277. --       { 
  278. --          gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE); 
  279. --          if (gtk_cell_area_focus (priv->area, direction)) 
  280. --          { 
  281. --             priv->focus_row = focus_row; 
  282. --             have_focus = TRUE; 
  283. --             break; 
  284. --          } 
  285. --       else 
  286. --          { 
  287. --             if (direction == GTK_DIR_RIGHT || 
  288. --                direction == GTK_DIR_LEFT) 
  289. --             break; 
  290. --          else if (direction == GTK_DIR_UP || 
  291. --             direction == GTK_DIR_TAB_BACKWARD) 
  292. --          { 
  293. --             if (focus_row == 0) 
  294. --             break; 
  295. --          else 
  296. --             { 
  297. --                focus_row--; 
  298. --                valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, focus_row); 
  299. --             } 
  300. --          } 
  301. --       else 
  302. --          { 
  303. --             if (focus_row == last_row) 
  304. --             break; 
  305. --          else 
  306. --             { 
  307. --                focus_row++; 
  308. --                valid = gtk_tree_model_iter_next (priv->model, &iter); 
  309. --             } 
  310. --          } 
  311. --       } 
  312. --    } 
  313. --    return have_focus; 
  314. -- } 
  315. -- 
  316. --  Note that the layouting widget is responsible for matching the 
  317. --  GtkDirectionType values to the way it lays out its cells. 
  318. -- 
  319. --  == Cell Properties == 
  320. -- 
  321. --  The Gtk.Cell_Area.Gtk_Cell_Area introduces *cell properties* for 
  322. --  Gtk_Cell_Renderers in very much the same way that 
  323. --  Gtk.Container.Gtk_Container introduces <link 
  324. --  linkend="child-properties">child properties</link> for Gtk_Widgets. This 
  325. --  provides some general interfaces for defining the relationship cell areas 
  326. --  have with their cells. For instance in a 
  327. --  Gtk.Cell_Area_Box.Gtk_Cell_Area_Box a cell might "expand" and receive extra 
  328. --  space when the area is allocated more than its full natural request, or a 
  329. --  cell might be configured to "align" with adjacent rows which were requested 
  330. --  and rendered with the same Gtk.Cell_Area_Context.Gtk_Cell_Area_Context. 
  331. -- 
  332. --  Use gtk_cell_area_class_install_cell_property to install cell properties 
  333. --  for a cell area class and gtk_cell_area_class_find_cell_property or 
  334. --  gtk_cell_area_class_list_cell_properties to get information about existing 
  335. --  cell properties. 
  336. -- 
  337. --  To set the value of a cell property, use Gtk.Cell_Area.Cell_Set_Property, 
  338. --  gtk_cell_area_cell_set or gtk_cell_area_cell_set_valist. To obtain the 
  339. --  value of a cell property, use Gtk.Cell_Area.Cell_Get_Property, 
  340. --  gtk_cell_area_cell_get or gtk_cell_area_cell_get_valist. 
  341. -- 
  342. -- 
  343. --  </description> 
  344. --  <group>Layout Containers</group> 
  345. pragma Ada_2005; 
  346.  
  347. pragma Warnings (Off, "*is already use-visible*"); 
  348. with Cairo;                 use Cairo; 
  349. with Cairo.Region;          use Cairo.Region; 
  350. with Gdk.Event;             use Gdk.Event; 
  351. with Gdk.Rectangle;         use Gdk.Rectangle; 
  352. with Glib;                  use Glib; 
  353. with Glib.Object;           use Glib.Object; 
  354. with Glib.Properties;       use Glib.Properties; 
  355. with Glib.Types;            use Glib.Types; 
  356. with Glib.Values;           use Glib.Values; 
  357. with Gtk.Buildable;         use Gtk.Buildable; 
  358. with Gtk.Cell_Area_Context; use Gtk.Cell_Area_Context; 
  359. with Gtk.Cell_Editable;     use Gtk.Cell_Editable; 
  360. with Gtk.Cell_Layout;       use Gtk.Cell_Layout; 
  361. with Gtk.Cell_Renderer;     use Gtk.Cell_Renderer; 
  362. with Gtk.Enums;             use Gtk.Enums; 
  363. with Gtk.Tree_Model;        use Gtk.Tree_Model; 
  364. with Gtk.Widget;            use Gtk.Widget; 
  365.  
  366. package Gtk.Cell_Area is 
  367.  
  368.    type Gtk_Cell_Area_Record is new GObject_Record with null record; 
  369.    type Gtk_Cell_Area is access all Gtk_Cell_Area_Record'Class; 
  370.  
  371.    --------------- 
  372.    -- Callbacks -- 
  373.    --------------- 
  374.  
  375.    type Gtk_Cell_Callback is access function 
  376.      (Renderer : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class) 
  377.    return Boolean; 
  378.    --  The type of the callback functions used for iterating over the cell 
  379.    --  renderers of a Gtk.Cell_Area.Gtk_Cell_Area, see Gtk.Cell_Area.Foreach. 
  380.    --  "renderer": the cell renderer to operate on 
  381.  
  382.    type Gtk_Cell_Alloc_Callback is access function 
  383.      (Renderer        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  384.       Cell_Area       : Gdk.Rectangle.Gdk_Rectangle; 
  385.       Cell_Background : Gdk.Rectangle.Gdk_Rectangle) return Boolean; 
  386.    --  The type of the callback functions used for iterating over the cell 
  387.    --  renderers and their allocated areas inside a 
  388.    --  Gtk.Cell_Area.Gtk_Cell_Area, see Gtk.Cell_Area.Foreach_Alloc. 
  389.    --  "renderer": the cell renderer to operate on 
  390.    --  "cell_area": the area allocated to Renderer inside the rectangle 
  391.    --  provided to Gtk.Cell_Area.Foreach_Alloc. 
  392.    --  "cell_background": the background area for Renderer inside the 
  393.    --  background area provided to Gtk.Cell_Area.Foreach_Alloc. 
  394.  
  395.    type Gtk_Cell_Layout_Data_Func is access procedure 
  396.      (Cell_Layout : Gtk.Cell_Layout.Gtk_Cell_Layout; 
  397.       Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  398.       Tree_Model  : Gtk.Tree_Model.Gtk_Tree_Model; 
  399.       Iter        : Gtk.Tree_Model.Gtk_Tree_Iter); 
  400.    --  A function which should set the value of Cell_Layout's cell renderer(s) 
  401.    --  as appropriate. 
  402.    --  "cell_layout": a Gtk.Cell_Layout.Gtk_Cell_Layout 
  403.    --  "cell": the cell renderer whose value is to be set 
  404.    --  "tree_model": the model 
  405.    --  "iter": a Gtk.Tree_Model.Gtk_Tree_Iter indicating the row to set the 
  406.    --  value for 
  407.  
  408.    ------------------ 
  409.    -- Constructors -- 
  410.    ------------------ 
  411.  
  412.    function Get_Type return Glib.GType; 
  413.    pragma Import (C, Get_Type, "gtk_cell_area_get_type"); 
  414.  
  415.    ------------- 
  416.    -- Methods -- 
  417.    ------------- 
  418.  
  419.    function Activate 
  420.       (Self      : not null access Gtk_Cell_Area_Record; 
  421.        Context   : not null access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class; 
  422.        Widget    : not null access Gtk.Widget.Gtk_Widget_Record'Class; 
  423.        Cell_Area : Gdk.Rectangle.Gdk_Rectangle; 
  424.        Flags     : Gtk.Cell_Renderer.Gtk_Cell_Renderer_State; 
  425.        Edit_Only : Boolean) return Boolean; 
  426.    --  Activates Area, usually by activating the currently focused cell, 
  427.    --  however some subclasses which embed widgets in the area can also 
  428.    --  activate a widget if it currently has the focus. 
  429.    --  Since: gtk+ 3.0 
  430.    --  "context": the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context in context 
  431.    --  with the current row data 
  432.    --  "widget": the Gtk.Widget.Gtk_Widget that Area is rendering on 
  433.    --  "cell_area": the size and location of Area relative to Widget's 
  434.    --  allocation 
  435.    --  "flags": the Gtk.Cell_Renderer.Gtk_Cell_Renderer_State flags for Area 
  436.    --  for this row of data. 
  437.    --  "edit_only": if True then only cell renderers that are 
  438.    --  Gtk.Cell_Renderer.Cell_Renderer_Mode_Editable will be activated. 
  439.  
  440.    function Activate_Cell 
  441.       (Self      : not null access Gtk_Cell_Area_Record; 
  442.        Widget    : not null access Gtk.Widget.Gtk_Widget_Record'Class; 
  443.        Renderer  : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  444.        Event     : Gdk.Event.Gdk_Event; 
  445.        Cell_Area : Gdk.Rectangle.Gdk_Rectangle; 
  446.        Flags     : Gtk.Cell_Renderer.Gtk_Cell_Renderer_State) return Boolean; 
  447.    --  This is used by Gtk.Cell_Area.Gtk_Cell_Area subclasses when handling 
  448.    --  events to activate cells, the base Gtk.Cell_Area.Gtk_Cell_Area class 
  449.    --  activates cells for keyboard events for free in its own 
  450.    --  GtkCellArea->activate implementation. 
  451.    --  Since: gtk+ 3.0 
  452.    --  "widget": the Gtk.Widget.Gtk_Widget that Area is rendering onto 
  453.    --  "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer in Area to activate 
  454.    --  "event": the Gdk.Event.Gdk_Event for which cell activation should occur 
  455.    --  "cell_area": the Gdk.Rectangle.Gdk_Rectangle in Widget relative 
  456.    --  coordinates of Renderer for the current row. 
  457.    --  "flags": the Gtk.Cell_Renderer.Gtk_Cell_Renderer_State for Renderer 
  458.  
  459.    procedure Add 
  460.       (Self     : not null access Gtk_Cell_Area_Record; 
  461.        Renderer : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class); 
  462.    --  Adds Renderer to Area with the default child cell properties. 
  463.    --  Since: gtk+ 3.0 
  464.    --  "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer to add to Area 
  465.  
  466.    procedure Add_Focus_Sibling 
  467.       (Self     : not null access Gtk_Cell_Area_Record; 
  468.        Renderer : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  469.        Sibling  : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class); 
  470.    --  Adds Sibling to Renderer's focusable area, focus will be drawn around 
  471.    --  Renderer and all of its siblings if Renderer can focus for a given row. 
  472.    --  Events handled by focus siblings can also activate the given focusable 
  473.    --  Renderer. 
  474.    --  Since: gtk+ 3.0 
  475.    --  "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer expected to have 
  476.    --  focus 
  477.    --  "sibling": the Gtk.Cell_Renderer.Gtk_Cell_Renderer to add to Renderer's 
  478.    --  focus area 
  479.  
  480.    procedure Apply_Attributes 
  481.       (Self        : not null access Gtk_Cell_Area_Record; 
  482.        Tree_Model  : Gtk.Tree_Model.Gtk_Tree_Model; 
  483.        Iter        : Gtk.Tree_Model.Gtk_Tree_Iter; 
  484.        Is_Expander : Boolean; 
  485.        Is_Expanded : Boolean); 
  486.    --  Applies any connected attributes to the renderers in Area by pulling 
  487.    --  the values from Tree_Model. 
  488.    --  Since: gtk+ 3.0 
  489.    --  "tree_model": the Gtk.Tree_Model.Gtk_Tree_Model to pull values from 
  490.    --  "iter": the Gtk.Tree_Model.Gtk_Tree_Iter in Tree_Model to apply values 
  491.    --  for 
  492.    --  "is_expander": whether Iter has children 
  493.    --  "is_expanded": whether Iter is expanded in the view and children are 
  494.    --  visible 
  495.  
  496.    procedure Attribute_Connect 
  497.       (Self      : not null access Gtk_Cell_Area_Record; 
  498.        Renderer  : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  499.        Attribute : UTF8_String; 
  500.        Column    : Gint); 
  501.    --  Connects an Attribute to apply values from Column for the 
  502.    --  Gtk.Tree_Model.Gtk_Tree_Model in use. 
  503.    --  Since: gtk+ 3.0 
  504.    --  "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer to connect an 
  505.    --  attribute for 
  506.    --  "attribute": the attribute name 
  507.    --  "column": the Gtk.Tree_Model.Gtk_Tree_Model column to fetch attribute 
  508.    --  values from 
  509.  
  510.    procedure Attribute_Disconnect 
  511.       (Self      : not null access Gtk_Cell_Area_Record; 
  512.        Renderer  : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  513.        Attribute : UTF8_String); 
  514.    --  Disconnects Attribute for the Renderer in Area so that attribute will 
  515.    --  no longer be updated with values from the model. 
  516.    --  Since: gtk+ 3.0 
  517.    --  "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer to disconnect an 
  518.    --  attribute for 
  519.    --  "attribute": the attribute name 
  520.  
  521.    procedure Cell_Get_Property 
  522.       (Self          : not null access Gtk_Cell_Area_Record; 
  523.        Renderer      : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  524.        Property_Name : UTF8_String; 
  525.        Value         : in out Glib.Values.GValue); 
  526.    --  Gets the value of a cell property for Renderer in Area. 
  527.    --  Since: gtk+ 3.0 
  528.    --  "renderer": a Gtk.Cell_Renderer.Gtk_Cell_Renderer inside Area 
  529.    --  "property_name": the name of the property to get 
  530.    --  "value": a location to return the value 
  531.  
  532.    procedure Cell_Set_Property 
  533.       (Self          : not null access Gtk_Cell_Area_Record; 
  534.        Renderer      : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  535.        Property_Name : UTF8_String; 
  536.        Value         : in out Glib.Values.GValue); 
  537.    --  Sets a cell property for Renderer in Area. 
  538.    --  Since: gtk+ 3.0 
  539.    --  "renderer": a Gtk.Cell_Renderer.Gtk_Cell_Renderer inside Area 
  540.    --  "property_name": the name of the cell property to set 
  541.    --  "value": the value to set the cell property to 
  542.  
  543.    function Copy_Context 
  544.       (Self    : not null access Gtk_Cell_Area_Record; 
  545.        Context : not null access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class) 
  546.        return Gtk.Cell_Area_Context.Gtk_Cell_Area_Context; 
  547.    --  This is sometimes needed for cases where rows need to share alignments 
  548.    --  in one orientation but may be separately grouped in the opposing 
  549.    --  orientation. 
  550.    --  For instance, Gtk.Icon_View.Gtk_Icon_View creates all icons (rows) to 
  551.    --  have the same width and the cells theirin to have the same horizontal 
  552.    --  alignments. However each row of icons may have a separate collective 
  553.    --  height. Gtk.Icon_View.Gtk_Icon_View uses this to request the heights of 
  554.    --  each row based on a context which was already used to request all the 
  555.    --  row widths that are to be displayed. 
  556.    --  Since: gtk+ 3.0 
  557.    --  "context": the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context to copy 
  558.  
  559.    function Create_Context 
  560.       (Self : not null access Gtk_Cell_Area_Record) 
  561.        return Gtk.Cell_Area_Context.Gtk_Cell_Area_Context; 
  562.    --  Creates a Gtk.Cell_Area_Context.Gtk_Cell_Area_Context to be used with 
  563.    --  Area for all purposes. Gtk.Cell_Area_Context.Gtk_Cell_Area_Context 
  564.    --  stores geometry information for rows for which it was operated on, it is 
  565.    --  important to use the same context for the same row of data at all times 
  566.    --  (i.e. one should render and handle events with the same 
  567.    --  Gtk.Cell_Area_Context.Gtk_Cell_Area_Context which was used to request 
  568.    --  the size of those rows of data). 
  569.    --  Since: gtk+ 3.0 
  570.  
  571.    function Event 
  572.       (Self      : not null access Gtk_Cell_Area_Record; 
  573.        Context   : not null access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class; 
  574.        Widget    : not null access Gtk.Widget.Gtk_Widget_Record'Class; 
  575.        Event     : Gdk.Event.Gdk_Event; 
  576.        Cell_Area : Gdk.Rectangle.Gdk_Rectangle; 
  577.        Flags     : Gtk.Cell_Renderer.Gtk_Cell_Renderer_State) return Gint; 
  578.    --  Delegates event handling to a Gtk.Cell_Area.Gtk_Cell_Area. 
  579.    --  Since: gtk+ 3.0 
  580.    --  "context": the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context for this row 
  581.    --  of data. 
  582.    --  "widget": the Gtk.Widget.Gtk_Widget that Area is rendering to 
  583.    --  "event": the Gdk.Event.Gdk_Event to handle 
  584.    --  "cell_area": the Widget relative coordinates for Area 
  585.    --  "flags": the Gtk.Cell_Renderer.Gtk_Cell_Renderer_State for Area in this 
  586.    --  row. 
  587.  
  588.    function Focus 
  589.       (Self      : not null access Gtk_Cell_Area_Record; 
  590.        Direction : Gtk.Enums.Gtk_Direction_Type) return Boolean; 
  591.    --  This should be called by the Area's owning layout widget when focus is 
  592.    --  to be passed to Area, or moved within Area for a given Direction and row 
  593.    --  data. 
  594.    --  Implementing Gtk.Cell_Area.Gtk_Cell_Area classes should implement this 
  595.    --  method to receive and navigate focus in its own way particular to how it 
  596.    --  lays out cells. 
  597.    --  Since: gtk+ 3.0 
  598.    --  "direction": the Gtk.Enums.Gtk_Direction_Type 
  599.  
  600.    procedure Foreach 
  601.       (Self     : not null access Gtk_Cell_Area_Record; 
  602.        Callback : Gtk_Cell_Callback); 
  603.    --  Calls Callback for every Gtk.Cell_Renderer.Gtk_Cell_Renderer in Area. 
  604.    --  Since: gtk+ 3.0 
  605.    --  "callback": the Gtk_Cell_Callback to call 
  606.  
  607.    generic 
  608.       type User_Data_Type (<>) is private; 
  609.       with procedure Destroy (Data : in out User_Data_Type) is null; 
  610.    package Foreach_User_Data is 
  611.  
  612.       type Gtk_Cell_Callback is access function 
  613.         (Renderer : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  614.          Data     : User_Data_Type) return Boolean; 
  615.       --  The type of the callback functions used for iterating over the cell 
  616.       --  renderers of a Gtk.Cell_Area.Gtk_Cell_Area, see Gtk.Cell_Area.Foreach. 
  617.       --  "renderer": the cell renderer to operate on 
  618.       --  "data": user-supplied data 
  619.  
  620.       procedure Foreach 
  621.          (Self          : not null access Gtk.Cell_Area.Gtk_Cell_Area_Record'Class; 
  622.           Callback      : Gtk_Cell_Callback; 
  623.           Callback_Data : User_Data_Type); 
  624.       --  Calls Callback for every Gtk.Cell_Renderer.Gtk_Cell_Renderer in 
  625.       --  Area. 
  626.       --  Since: gtk+ 3.0 
  627.       --  "callback": the Gtk_Cell_Callback to call 
  628.       --  "callback_data": user provided data pointer 
  629.  
  630.    end Foreach_User_Data; 
  631.  
  632.    procedure Foreach_Alloc 
  633.       (Self            : not null access Gtk_Cell_Area_Record; 
  634.        Context         : not null access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class; 
  635.        Widget          : not null access Gtk.Widget.Gtk_Widget_Record'Class; 
  636.        Cell_Area       : Gdk.Rectangle.Gdk_Rectangle; 
  637.        Background_Area : Gdk.Rectangle.Gdk_Rectangle; 
  638.        Callback        : Gtk_Cell_Alloc_Callback); 
  639.    --  Calls Callback for every Gtk.Cell_Renderer.Gtk_Cell_Renderer in Area 
  640.    --  with the allocated rectangle inside Cell_Area. 
  641.    --  Since: gtk+ 3.0 
  642.    --  "context": the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context for this row 
  643.    --  of data. 
  644.    --  "widget": the Gtk.Widget.Gtk_Widget that Area is rendering to 
  645.    --  "cell_area": the Widget relative coordinates and size for Area 
  646.    --  "background_area": the Widget relative coordinates of the background 
  647.    --  area 
  648.    --  "callback": the Gtk_Cell_Alloc_Callback to call 
  649.  
  650.    generic 
  651.       type User_Data_Type (<>) is private; 
  652.       with procedure Destroy (Data : in out User_Data_Type) is null; 
  653.    package Foreach_Alloc_User_Data is 
  654.  
  655.       type Gtk_Cell_Alloc_Callback is access function 
  656.         (Renderer        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  657.          Cell_Area       : Gdk.Rectangle.Gdk_Rectangle; 
  658.          Cell_Background : Gdk.Rectangle.Gdk_Rectangle; 
  659.          Data            : User_Data_Type) return Boolean; 
  660.       --  The type of the callback functions used for iterating over the cell 
  661.       --  renderers and their allocated areas inside a 
  662.       --  Gtk.Cell_Area.Gtk_Cell_Area, see Gtk.Cell_Area.Foreach_Alloc. 
  663.       --  "renderer": the cell renderer to operate on 
  664.       --  "cell_area": the area allocated to Renderer inside the rectangle 
  665.       --  provided to Gtk.Cell_Area.Foreach_Alloc. 
  666.       --  "cell_background": the background area for Renderer inside the 
  667.       --  background area provided to Gtk.Cell_Area.Foreach_Alloc. 
  668.       --  "data": user-supplied data 
  669.  
  670.       procedure Foreach_Alloc 
  671.          (Self            : not null access Gtk.Cell_Area.Gtk_Cell_Area_Record'Class; 
  672.           Context         : not null access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class; 
  673.           Widget          : not null access Gtk.Widget.Gtk_Widget_Record'Class; 
  674.           Cell_Area       : Gdk.Rectangle.Gdk_Rectangle; 
  675.           Background_Area : Gdk.Rectangle.Gdk_Rectangle; 
  676.           Callback        : Gtk_Cell_Alloc_Callback; 
  677.           Callback_Data   : User_Data_Type); 
  678.       --  Calls Callback for every Gtk.Cell_Renderer.Gtk_Cell_Renderer in Area 
  679.       --  with the allocated rectangle inside Cell_Area. 
  680.       --  Since: gtk+ 3.0 
  681.       --  "context": the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context for this 
  682.       --  row of data. 
  683.       --  "widget": the Gtk.Widget.Gtk_Widget that Area is rendering to 
  684.       --  "cell_area": the Widget relative coordinates and size for Area 
  685.       --  "background_area": the Widget relative coordinates of the background 
  686.       --  area 
  687.       --  "callback": the Gtk_Cell_Alloc_Callback to call 
  688.       --  "callback_data": user provided data pointer 
  689.  
  690.    end Foreach_Alloc_User_Data; 
  691.  
  692.    procedure Get_Cell_Allocation 
  693.       (Self       : not null access Gtk_Cell_Area_Record; 
  694.        Context    : not null access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class; 
  695.        Widget     : not null access Gtk.Widget.Gtk_Widget_Record'Class; 
  696.        Renderer   : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  697.        Cell_Area  : access Gdk.Rectangle.Gdk_Rectangle; 
  698.        Allocation : access Gdk.Rectangle.Gdk_Rectangle); 
  699.    --  Derives the allocation of Renderer inside Area if Area were to be 
  700.    --  renderered in Cell_Area. 
  701.    --  Since: gtk+ 3.0 
  702.    --  "context": the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context used to hold 
  703.    --  sizes for Area. 
  704.    --  "widget": the Gtk.Widget.Gtk_Widget that Area is rendering on 
  705.    --  "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer to get the 
  706.    --  allocation for 
  707.    --  "cell_area": the whole allocated area for Area in Widget for this row 
  708.    --  "allocation": where to store the allocation for Renderer 
  709.  
  710.    function Get_Current_Path_String 
  711.       (Self : not null access Gtk_Cell_Area_Record) return UTF8_String; 
  712.    --  Gets the current Gtk.Tree_Model.Gtk_Tree_Path string for the currently 
  713.    --  applied Gtk.Tree_Model.Gtk_Tree_Iter, this is implicitly updated when 
  714.    --  Gtk.Cell_Area.Apply_Attributes is called and can be used to interact 
  715.    --  with renderers from Gtk.Cell_Area.Gtk_Cell_Area subclasses. 
  716.    --  Since: gtk+ 3.0 
  717.  
  718.    function Get_Edit_Widget 
  719.       (Self : not null access Gtk_Cell_Area_Record) 
  720.        return Gtk.Cell_Editable.Gtk_Cell_Editable; 
  721.    --  Gets the Gtk.Cell_Editable.Gtk_Cell_Editable widget currently used to 
  722.    --  edit the currently edited cell. 
  723.    --  Since: gtk+ 3.0 
  724.  
  725.    function Get_Edited_Cell 
  726.       (Self : not null access Gtk_Cell_Area_Record) 
  727.        return Gtk.Cell_Renderer.Gtk_Cell_Renderer; 
  728.    --  Gets the Gtk.Cell_Renderer.Gtk_Cell_Renderer in Area that is currently 
  729.    --  being edited. 
  730.    --  Since: gtk+ 3.0 
  731.  
  732.    function Get_Focus_Cell 
  733.       (Self : not null access Gtk_Cell_Area_Record) 
  734.        return Gtk.Cell_Renderer.Gtk_Cell_Renderer; 
  735.    --  Retrieves the currently focused cell for Area 
  736.    --  Since: gtk+ 3.0 
  737.  
  738.    procedure Set_Focus_Cell 
  739.       (Self     : not null access Gtk_Cell_Area_Record; 
  740.        Renderer : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class); 
  741.    --  Explicitly sets the currently focused cell to Renderer. 
  742.    --  This is generally called by implementations of 
  743.    --  Gtk.Cell_Area_Class.Gtk_Cell_Area_Class.focus or 
  744.    --  Gtk.Cell_Area_Class.Gtk_Cell_Area_Class.event, however it can also be 
  745.    --  used to implement functions such as Gtk.Tree_View.Set_Cursor_On_Cell. 
  746.    --  Since: gtk+ 3.0 
  747.    --  "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer to give focus to 
  748.  
  749.    function Get_Focus_From_Sibling 
  750.       (Self     : not null access Gtk_Cell_Area_Record; 
  751.        Renderer : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class) 
  752.        return Gtk.Cell_Renderer.Gtk_Cell_Renderer; 
  753.    --  Gets the Gtk.Cell_Renderer.Gtk_Cell_Renderer which is expected to be 
  754.    --  focusable for which Renderer is, or may be a sibling. 
  755.    --  This is handy for Gtk.Cell_Area.Gtk_Cell_Area subclasses when handling 
  756.    --  events, after determining the renderer at the event location it can then 
  757.    --  chose to activate the focus cell for which the event cell may have been 
  758.    --  a sibling. 
  759.    --  Since: gtk+ 3.0 
  760.    --  "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer 
  761.  
  762.    function Get_Focus_Siblings 
  763.       (Self     : not null access Gtk_Cell_Area_Record; 
  764.        Renderer : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class) 
  765.        return Glib.Object.Object_Simple_List.Glist; 
  766.    --  Gets the focus sibling cell renderers for Renderer. 
  767.    --  Since: gtk+ 3.0 
  768.    --  "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer expected to have 
  769.    --  focus 
  770.  
  771.    procedure Get_Preferred_Height 
  772.       (Self           : not null access Gtk_Cell_Area_Record; 
  773.        Context        : not null access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class; 
  774.        Widget         : not null access Gtk.Widget.Gtk_Widget_Record'Class; 
  775.        Minimum_Height : out Gint; 
  776.        Natural_Height : out Gint); 
  777.    --  Retrieves a cell area's initial minimum and natural height. 
  778.    --  Area will store some geometrical information in Context along the way; 
  779.    --  when requesting sizes over an arbitrary number of rows, it's not 
  780.    --  important to check the Minimum_Height and Natural_Height of this call 
  781.    --  but rather to consult Gtk.Cell_Area_Context.Get_Preferred_Height after a 
  782.    --  series of requests. 
  783.    --  Since: gtk+ 3.0 
  784.    --  "context": the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context to perform 
  785.    --  this request with 
  786.    --  "widget": the Gtk.Widget.Gtk_Widget where Area will be rendering 
  787.    --  "minimum_height": location to store the minimum height, or null 
  788.    --  "natural_height": location to store the natural height, or null 
  789.  
  790.    procedure Get_Preferred_Height_For_Width 
  791.       (Self           : not null access Gtk_Cell_Area_Record; 
  792.        Context        : not null access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class; 
  793.        Widget         : not null access Gtk.Widget.Gtk_Widget_Record'Class; 
  794.        Width          : Gint; 
  795.        Minimum_Height : out Gint; 
  796.        Natural_Height : out Gint); 
  797.    --  Retrieves a cell area's minimum and natural height if it would be given 
  798.    --  the specified Width. 
  799.    --  Area stores some geometrical information in Context along the way while 
  800.    --  calling Gtk.Cell_Area.Get_Preferred_Width. It's important to perform a 
  801.    --  series of Gtk.Cell_Area.Get_Preferred_Width requests with Context first 
  802.    --  and then call Gtk.Cell_Area.Get_Preferred_Height_For_Width on each cell 
  803.    --  area individually to get the height for width of each fully requested 
  804.    --  row. 
  805.    --  If at some point, the width of a single row changes, it should be 
  806.    --  requested with Gtk.Cell_Area.Get_Preferred_Width again and then the full 
  807.    --  width of the requested rows checked again with 
  808.    --  Gtk.Cell_Area_Context.Get_Preferred_Width. 
  809.    --  Since: gtk+ 3.0 
  810.    --  "context": the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context which has 
  811.    --  already been requested for widths. 
  812.    --  "widget": the Gtk.Widget.Gtk_Widget where Area will be rendering 
  813.    --  "width": the width for which to check the height of this area 
  814.    --  "minimum_height": location to store the minimum height, or null 
  815.    --  "natural_height": location to store the natural height, or null 
  816.  
  817.    procedure Get_Preferred_Width 
  818.       (Self          : not null access Gtk_Cell_Area_Record; 
  819.        Context       : not null access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class; 
  820.        Widget        : not null access Gtk.Widget.Gtk_Widget_Record'Class; 
  821.        Minimum_Width : out Gint; 
  822.        Natural_Width : out Gint); 
  823.    --  Retrieves a cell area's initial minimum and natural width. 
  824.    --  Area will store some geometrical information in Context along the way; 
  825.    --  when requesting sizes over an arbitrary number of rows, it's not 
  826.    --  important to check the Minimum_Width and Natural_Width of this call but 
  827.    --  rather to consult Gtk.Cell_Area_Context.Get_Preferred_Width after a 
  828.    --  series of requests. 
  829.    --  Since: gtk+ 3.0 
  830.    --  "context": the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context to perform 
  831.    --  this request with 
  832.    --  "widget": the Gtk.Widget.Gtk_Widget where Area will be rendering 
  833.    --  "minimum_width": location to store the minimum width, or null 
  834.    --  "natural_width": location to store the natural width, or null 
  835.  
  836.    procedure Get_Preferred_Width_For_Height 
  837.       (Self          : not null access Gtk_Cell_Area_Record; 
  838.        Context       : not null access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class; 
  839.        Widget        : not null access Gtk.Widget.Gtk_Widget_Record'Class; 
  840.        Height        : Gint; 
  841.        Minimum_Width : out Gint; 
  842.        Natural_Width : out Gint); 
  843.    --  Retrieves a cell area's minimum and natural width if it would be given 
  844.    --  the specified Height. 
  845.    --  Area stores some geometrical information in Context along the way while 
  846.    --  calling Gtk.Cell_Area.Get_Preferred_Height. It's important to perform a 
  847.    --  series of Gtk.Cell_Area.Get_Preferred_Height requests with Context first 
  848.    --  and then call Gtk.Cell_Area.Get_Preferred_Width_For_Height on each cell 
  849.    --  area individually to get the height for width of each fully requested 
  850.    --  row. 
  851.    --  If at some point, the height of a single row changes, it should be 
  852.    --  requested with Gtk.Cell_Area.Get_Preferred_Height again and then the 
  853.    --  full height of the requested rows checked again with 
  854.    --  Gtk.Cell_Area_Context.Get_Preferred_Height. 
  855.    --  Since: gtk+ 3.0 
  856.    --  "context": the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context which has 
  857.    --  already been requested for widths. 
  858.    --  "widget": the Gtk.Widget.Gtk_Widget where Area will be rendering 
  859.    --  "height": the height for which to check the width of this area 
  860.    --  "minimum_width": location to store the minimum width, or null 
  861.    --  "natural_width": location to store the natural width, or null 
  862.  
  863.    function Get_Request_Mode 
  864.       (Self : not null access Gtk_Cell_Area_Record) 
  865.        return Gtk.Enums.Gtk_Size_Request_Mode; 
  866.    --  Gets whether the area prefers a height-for-width layout or a 
  867.    --  width-for-height layout. 
  868.    --  Since: gtk+ 3.0 
  869.  
  870.    function Has_Renderer 
  871.       (Self     : not null access Gtk_Cell_Area_Record; 
  872.        Renderer : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class) 
  873.        return Boolean; 
  874.    --  Checks if Area contains Renderer. 
  875.    --  Since: gtk+ 3.0 
  876.    --  "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer to check 
  877.  
  878.    procedure Inner_Cell_Area 
  879.       (Self       : not null access Gtk_Cell_Area_Record; 
  880.        Widget     : not null access Gtk.Widget.Gtk_Widget_Record'Class; 
  881.        Cell_Area  : Gdk.Rectangle.Gdk_Rectangle; 
  882.        Inner_Area : out Gdk.Rectangle.Gdk_Rectangle); 
  883.    --  This is a convenience function for Gtk.Cell_Area.Gtk_Cell_Area 
  884.    --  implementations to get the inner area where a given 
  885.    --  Gtk.Cell_Renderer.Gtk_Cell_Renderer will be rendered. It removes any 
  886.    --  padding previously added by Gtk.Cell_Area.Request_Renderer. 
  887.    --  Since: gtk+ 3.0 
  888.    --  "widget": the Gtk.Widget.Gtk_Widget that Area is rendering onto 
  889.    --  "cell_area": the Widget relative coordinates where one of Area's cells 
  890.    --  is to be placed 
  891.    --  "inner_area": the return location for the inner cell area 
  892.  
  893.    function Is_Activatable 
  894.       (Self : not null access Gtk_Cell_Area_Record) return Boolean; 
  895.    --  Returns whether the area can do anything when activated, after applying 
  896.    --  new attributes to Area. 
  897.    --  Since: gtk+ 3.0 
  898.  
  899.    function Is_Focus_Sibling 
  900.       (Self     : not null access Gtk_Cell_Area_Record; 
  901.        Renderer : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  902.        Sibling  : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class) 
  903.        return Boolean; 
  904.    --  Returns whether Sibling is one of Renderer's focus siblings (see 
  905.    --  Gtk.Cell_Area.Add_Focus_Sibling). 
  906.    --  Since: gtk+ 3.0 
  907.    --  "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer expected to have 
  908.    --  focus 
  909.    --  "sibling": the Gtk.Cell_Renderer.Gtk_Cell_Renderer to check against 
  910.    --  Renderer's sibling list 
  911.  
  912.    procedure Remove 
  913.       (Self     : not null access Gtk_Cell_Area_Record; 
  914.        Renderer : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class); 
  915.    --  Removes Renderer from Area. 
  916.    --  Since: gtk+ 3.0 
  917.    --  "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer to remove from Area 
  918.  
  919.    procedure Remove_Focus_Sibling 
  920.       (Self     : not null access Gtk_Cell_Area_Record; 
  921.        Renderer : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  922.        Sibling  : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class); 
  923.    --  Removes Sibling from Renderer's focus sibling list (see 
  924.    --  Gtk.Cell_Area.Add_Focus_Sibling). 
  925.    --  Since: gtk+ 3.0 
  926.    --  "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer expected to have 
  927.    --  focus 
  928.    --  "sibling": the Gtk.Cell_Renderer.Gtk_Cell_Renderer to remove from 
  929.    --  Renderer's focus area 
  930.  
  931.    procedure Render 
  932.       (Self            : not null access Gtk_Cell_Area_Record; 
  933.        Context         : not null access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class; 
  934.        Widget          : not null access Gtk.Widget.Gtk_Widget_Record'Class; 
  935.        Cr              : Cairo.Cairo_Context; 
  936.        Background_Area : Gdk.Rectangle.Gdk_Rectangle; 
  937.        Cell_Area       : Gdk.Rectangle.Gdk_Rectangle; 
  938.        Flags           : Gtk.Cell_Renderer.Gtk_Cell_Renderer_State; 
  939.        Paint_Focus     : Boolean); 
  940.    --  Renders Area's cells according to Area's layout onto Widget at the 
  941.    --  given coordinates. 
  942.    --  Since: gtk+ 3.0 
  943.    --  "context": the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context for this row 
  944.    --  of data. 
  945.    --  "widget": the Gtk.Widget.Gtk_Widget that Area is rendering to 
  946.    --  "cr": the cairo_t to render with 
  947.    --  "background_area": the Widget relative coordinates for Area's 
  948.    --  background 
  949.    --  "cell_area": the Widget relative coordinates for Area 
  950.    --  "flags": the Gtk.Cell_Renderer.Gtk_Cell_Renderer_State for Area in this 
  951.    --  row. 
  952.    --  "paint_focus": whether Area should paint focus on focused cells for 
  953.    --  focused rows or not. 
  954.  
  955.    procedure Request_Renderer 
  956.       (Self         : not null access Gtk_Cell_Area_Record; 
  957.        Renderer     : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  958.        Orientation  : Gtk.Enums.Gtk_Orientation; 
  959.        Widget       : not null access Gtk.Widget.Gtk_Widget_Record'Class; 
  960.        For_Size     : Gint; 
  961.        Minimum_Size : out Gint; 
  962.        Natural_Size : out Gint); 
  963.    --  This is a convenience function for Gtk.Cell_Area.Gtk_Cell_Area 
  964.    --  implementations to request size for cell renderers. It's important to 
  965.    --  use this function to request size and then use 
  966.    --  Gtk.Cell_Area.Inner_Cell_Area at render and event time since this 
  967.    --  function will add padding around the cell for focus painting. 
  968.    --  Since: gtk+ 3.0 
  969.    --  "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer to request size for 
  970.    --  "orientation": the Gtk.Enums.Gtk_Orientation in which to request size 
  971.    --  "widget": the Gtk.Widget.Gtk_Widget that Area is rendering onto 
  972.    --  "for_size": the allocation contextual size to request for, or -1 if the 
  973.    --  base request for the orientation is to be returned. 
  974.    --  "minimum_size": location to store the minimum size, or null 
  975.    --  "natural_size": location to store the natural size, or null 
  976.  
  977.    procedure Stop_Editing 
  978.       (Self     : not null access Gtk_Cell_Area_Record; 
  979.        Canceled : Boolean); 
  980.    --  Explicitly stops the editing of the currently edited cell. 
  981.    --  If Canceled is True, the currently edited cell renderer will emit the 
  982.    --  ::editing-canceled signal, otherwise the the ::editing-done signal will 
  983.    --  be emitted on the current edit widget. 
  984.    --  See Gtk.Cell_Area.Get_Edited_Cell and Gtk.Cell_Area.Get_Edit_Widget. 
  985.    --  Since: gtk+ 3.0 
  986.    --  "canceled": whether editing was canceled. 
  987.  
  988.    procedure Set_Cell_Data_Func 
  989.       (Cell_Layout : not null access Gtk_Cell_Area_Record; 
  990.        Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  991.        Func        : Gtk_Cell_Layout_Data_Func); 
  992.    --  Sets the Gtk_Cell_Layout_Data_Func to use for Cell_Layout. 
  993.    --  This function is used instead of the standard attributes mapping for 
  994.    --  setting the column value, and should set the value of Cell_Layout's cell 
  995.    --  renderer(s) as appropriate. 
  996.    --  Func may be null to remove a previously set function. 
  997.    --  Since: gtk+ 2.4 
  998.    --  "cell": a Gtk.Cell_Renderer.Gtk_Cell_Renderer 
  999.    --  "func": the Gtk_Cell_Layout_Data_Func to use, or null 
  1000.  
  1001.    generic 
  1002.       type User_Data_Type (<>) is private; 
  1003.       with procedure Destroy (Data : in out User_Data_Type) is null; 
  1004.    package Set_Cell_Data_Func_User_Data is 
  1005.  
  1006.       type Gtk_Cell_Layout_Data_Func is access procedure 
  1007.         (Cell_Layout : Gtk.Cell_Layout.Gtk_Cell_Layout; 
  1008.          Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  1009.          Tree_Model  : Gtk.Tree_Model.Gtk_Tree_Model; 
  1010.          Iter        : Gtk.Tree_Model.Gtk_Tree_Iter; 
  1011.          Data        : User_Data_Type); 
  1012.       --  A function which should set the value of Cell_Layout's cell renderer(s) 
  1013.       --  as appropriate. 
  1014.       --  "cell_layout": a Gtk.Cell_Layout.Gtk_Cell_Layout 
  1015.       --  "cell": the cell renderer whose value is to be set 
  1016.       --  "tree_model": the model 
  1017.       --  "iter": a Gtk.Tree_Model.Gtk_Tree_Iter indicating the row to set the 
  1018.       --  value for 
  1019.       --  "data": user data passed to Gtk.Cell_Layout.Set_Cell_Data_Func 
  1020.  
  1021.       procedure Set_Cell_Data_Func 
  1022.          (Cell_Layout : not null access Gtk.Cell_Area.Gtk_Cell_Area_Record'Class; 
  1023.           Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  1024.           Func        : Gtk_Cell_Layout_Data_Func; 
  1025.           Func_Data   : User_Data_Type); 
  1026.       --  Sets the Gtk_Cell_Layout_Data_Func to use for Cell_Layout. 
  1027.       --  This function is used instead of the standard attributes mapping for 
  1028.       --  setting the column value, and should set the value of Cell_Layout's 
  1029.       --  cell renderer(s) as appropriate. 
  1030.       --  Func may be null to remove a previously set function. 
  1031.       --  Since: gtk+ 2.4 
  1032.       --  "cell": a Gtk.Cell_Renderer.Gtk_Cell_Renderer 
  1033.       --  "func": the Gtk_Cell_Layout_Data_Func to use, or null 
  1034.       --  "func_data": user data for Func 
  1035.  
  1036.    end Set_Cell_Data_Func_User_Data; 
  1037.  
  1038.    ---------------------- 
  1039.    -- GtkAda additions -- 
  1040.    ---------------------- 
  1041.  
  1042.    function Get_Area 
  1043.      (Context : access Gtk_Cell_Area_Context_Record) 
  1044.    return Gtk.Cell_Area.Gtk_Cell_Area; 
  1045.    --  Fetches the Gtk.Cell_Area.Gtk_Cell_Area this Context was created by. 
  1046.    --  This is generally unneeded by layouting widgets; however it is important 
  1047.    --  for the context implementation itself to fetch information about the 
  1048.    --  area it is being used for. 
  1049.    --  For instance at GtkCellAreaContextClass.allocate time its important to 
  1050.    --  know details about any cell spacing that the Gtk.Cell_Area.Gtk_Cell_Area 
  1051.    --  is configured with in order to compute a proper allocation. 
  1052.    --  Since: gtk+ 3.0 
  1053.  
  1054.    function Get_Area 
  1055.      (Cell_Layout : Gtk_Cell_Layout) return Gtk.Cell_Area.Gtk_Cell_Area; 
  1056.    --  Returns the underlying Gtk.Cell_Area.Gtk_Cell_Area which might be 
  1057.    --  Cell_Layout if called on a Gtk.Cell_Area.Gtk_Cell_Area or might be null 
  1058.    --  if no Gtk.Cell_Area.Gtk_Cell_Area is used by Cell_Layout. 
  1059.    --  Since: gtk+ 3.0 
  1060.  
  1061.    procedure Get_Cell_At_Position 
  1062.      (Self       : access Gtk_Cell_Area_Record; 
  1063.       Context    : access Gtk.Cell_Area_Context.Gtk_Cell_Area_Context_Record'Class; 
  1064.       Widget     : access Gtk.Widget.Gtk_Widget_Record'Class; 
  1065.       Cell_Area  : Gdk.Rectangle.Gdk_Rectangle; 
  1066.       X          : Gint; 
  1067.       Y          : Gint; 
  1068.       Alloc_Area : out Gdk.Rectangle.Gdk_Rectangle; 
  1069.       Renderer   : out Gtk.Cell_Renderer.Gtk_Cell_Renderer); 
  1070.    --  Gets the Gtk.Cell_Renderer.Gtk_Cell_Renderer at X and Y coordinates 
  1071.    --  inside Area and optionally returns the full cell allocation for it 
  1072.    --  inside Cell_Area. 
  1073.    --  Since: gtk+ 3.0 
  1074.    --  "context": the Gtk.Cell_Area_Context.Gtk_Cell_Area_Context used to hold 
  1075.    --  sizes for Area. 
  1076.    --  "widget": the Gtk.Widget.Gtk_Widget that Area is rendering on 
  1077.    --  "cell_area": the whole allocated area for Area in Widget for this row 
  1078.    --  "x": the x position 
  1079.    --  "y": the y position 
  1080.    --  "alloc_area": where to store the inner allocated area of the returned 
  1081.    --  cell renderer, or null. 
  1082.    --  "renderer": the rendered that was found. 
  1083.  
  1084.    --------------------------------------------- 
  1085.    -- Inherited subprograms (from interfaces) -- 
  1086.    --------------------------------------------- 
  1087.    --  Methods inherited from the Buildable interface are not duplicated here 
  1088.    --  since they are meant to be used by tools, mostly. If you need to call 
  1089.    --  them, use an explicit cast through the "-" operator below. 
  1090.  
  1091.    procedure Add_Attribute 
  1092.       (Cell_Layout : not null access Gtk_Cell_Area_Record; 
  1093.        Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  1094.        Attribute   : UTF8_String; 
  1095.        Column      : Gint); 
  1096.  
  1097.    procedure Clear (Cell_Layout : not null access Gtk_Cell_Area_Record); 
  1098.  
  1099.    procedure Clear_Attributes 
  1100.       (Cell_Layout : not null access Gtk_Cell_Area_Record; 
  1101.        Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class); 
  1102.  
  1103.    function Get_Cells 
  1104.       (Cell_Layout : not null access Gtk_Cell_Area_Record) 
  1105.        return Glib.Object.Object_Simple_List.Glist; 
  1106.  
  1107.    procedure Pack_End 
  1108.       (Cell_Layout : not null access Gtk_Cell_Area_Record; 
  1109.        Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  1110.        Expand      : Boolean); 
  1111.  
  1112.    procedure Pack_Start 
  1113.       (Cell_Layout : not null access Gtk_Cell_Area_Record; 
  1114.        Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  1115.        Expand      : Boolean); 
  1116.  
  1117.    procedure Reorder 
  1118.       (Cell_Layout : not null access Gtk_Cell_Area_Record; 
  1119.        Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  1120.        Position    : Gint); 
  1121.  
  1122.    ---------------- 
  1123.    -- Properties -- 
  1124.    ---------------- 
  1125.    --  The following properties are defined for this widget. See 
  1126.    --  Glib.Properties for more information on properties) 
  1127.  
  1128.    Edit_Widget_Property : constant Glib.Properties.Property_Interface; 
  1129.    --  Type: Gtk.Cell_Editable.Gtk_Cell_Editable 
  1130.    --  The widget currently editing the edited cell 
  1131.    -- 
  1132.    --  This property is read-only and only changes as a result of a call 
  1133.    --  Gtk.Cell_Area.Activate_Cell. 
  1134.  
  1135.    Edited_Cell_Property : constant Glib.Properties.Property_Object; 
  1136.    --  Type: Gtk.Cell_Renderer.Gtk_Cell_Renderer 
  1137.    --  The cell in the area that is currently edited 
  1138.    -- 
  1139.    --  This property is read-only and only changes as a result of a call 
  1140.    --  Gtk.Cell_Area.Activate_Cell. 
  1141.  
  1142.    Focus_Cell_Property : constant Glib.Properties.Property_Object; 
  1143.    --  Type: Gtk.Cell_Renderer.Gtk_Cell_Renderer 
  1144.    --  The cell in the area that currently has focus 
  1145.  
  1146.    ------------- 
  1147.    -- Signals -- 
  1148.    ------------- 
  1149.  
  1150.    type Cb_Gtk_Cell_Area_Gtk_Cell_Renderer_Gtk_Cell_Editable_Cairo_Rectangle_Int_UTF8_String_Void is not null access procedure 
  1151.      (Self      : access Gtk_Cell_Area_Record'Class; 
  1152.       Renderer  : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  1153.       Editable  : Gtk.Cell_Editable.Gtk_Cell_Editable; 
  1154.       Cell_Area : Cairo.Region.Cairo_Rectangle_Int; 
  1155.       Path      : UTF8_String); 
  1156.  
  1157.    type Cb_GObject_Gtk_Cell_Renderer_Gtk_Cell_Editable_Cairo_Rectangle_Int_UTF8_String_Void is not null access procedure 
  1158.      (Self      : access Glib.Object.GObject_Record'Class; 
  1159.       Renderer  : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  1160.       Editable  : Gtk.Cell_Editable.Gtk_Cell_Editable; 
  1161.       Cell_Area : Cairo.Region.Cairo_Rectangle_Int; 
  1162.       Path      : UTF8_String); 
  1163.  
  1164.    Signal_Add_Editable : constant Glib.Signal_Name := "add-editable"; 
  1165.    procedure On_Add_Editable 
  1166.       (Self  : not null access Gtk_Cell_Area_Record; 
  1167.        Call  : Cb_Gtk_Cell_Area_Gtk_Cell_Renderer_Gtk_Cell_Editable_Cairo_Rectangle_Int_UTF8_String_Void; 
  1168.        After : Boolean := False); 
  1169.    procedure On_Add_Editable 
  1170.       (Self  : not null access Gtk_Cell_Area_Record; 
  1171.        Call  : Cb_GObject_Gtk_Cell_Renderer_Gtk_Cell_Editable_Cairo_Rectangle_Int_UTF8_String_Void; 
  1172.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1173.        After : Boolean := False); 
  1174.    --  Indicates that editing has started on Renderer and that Editable should 
  1175.    --  be added to the owning cell-layouting widget at Cell_Area. 
  1176.    --  
  1177.    --  Callback parameters: 
  1178.    --    --  "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer that started the 
  1179.    --    --  edited 
  1180.    --    --  "editable": the Gtk.Cell_Editable.Gtk_Cell_Editable widget to add 
  1181.    --    --  "cell_area": the Gtk.Widget.Gtk_Widget relative 
  1182.    --    --  Gdk.Rectangle.Gdk_Rectangle coordinates where Editable should be added 
  1183.    --    --  "path": the Gtk.Tree_Model.Gtk_Tree_Path string this edit was initiated 
  1184.    --    --  for 
  1185.  
  1186.    type Cb_Gtk_Cell_Area_Gtk_Tree_Model_Gtk_Tree_Iter_Boolean_Boolean_Void is not null access procedure 
  1187.      (Self        : access Gtk_Cell_Area_Record'Class; 
  1188.       Model       : Gtk.Tree_Model.Gtk_Tree_Model; 
  1189.       Iter        : Gtk.Tree_Model.Gtk_Tree_Iter; 
  1190.       Is_Expander : Boolean; 
  1191.       Is_Expanded : Boolean); 
  1192.  
  1193.    type Cb_GObject_Gtk_Tree_Model_Gtk_Tree_Iter_Boolean_Boolean_Void is not null access procedure 
  1194.      (Self        : access Glib.Object.GObject_Record'Class; 
  1195.       Model       : Gtk.Tree_Model.Gtk_Tree_Model; 
  1196.       Iter        : Gtk.Tree_Model.Gtk_Tree_Iter; 
  1197.       Is_Expander : Boolean; 
  1198.       Is_Expanded : Boolean); 
  1199.  
  1200.    Signal_Apply_Attributes : constant Glib.Signal_Name := "apply-attributes"; 
  1201.    procedure On_Apply_Attributes 
  1202.       (Self  : not null access Gtk_Cell_Area_Record; 
  1203.        Call  : Cb_Gtk_Cell_Area_Gtk_Tree_Model_Gtk_Tree_Iter_Boolean_Boolean_Void; 
  1204.        After : Boolean := False); 
  1205.    procedure On_Apply_Attributes 
  1206.       (Self  : not null access Gtk_Cell_Area_Record; 
  1207.        Call  : Cb_GObject_Gtk_Tree_Model_Gtk_Tree_Iter_Boolean_Boolean_Void; 
  1208.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1209.        After : Boolean := False); 
  1210.    --  This signal is emitted whenever applying attributes to Area from Model 
  1211.    --  
  1212.    --  Callback parameters: 
  1213.    --    --  "model": the Gtk.Tree_Model.Gtk_Tree_Model to apply the attributes from 
  1214.    --    --  "iter": the Gtk.Tree_Model.Gtk_Tree_Iter indicating which row to apply 
  1215.    --    --  the attributes of 
  1216.    --    --  "is_expander": whether the view shows children for this row 
  1217.    --    --  "is_expanded": whether the view is currently showing the children of 
  1218.    --    --  this row 
  1219.  
  1220.    type Cb_Gtk_Cell_Area_Gtk_Cell_Renderer_UTF8_String_Void is not null access procedure 
  1221.      (Self     : access Gtk_Cell_Area_Record'Class; 
  1222.       Renderer : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  1223.       Path     : UTF8_String); 
  1224.  
  1225.    type Cb_GObject_Gtk_Cell_Renderer_UTF8_String_Void is not null access procedure 
  1226.      (Self     : access Glib.Object.GObject_Record'Class; 
  1227.       Renderer : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  1228.       Path     : UTF8_String); 
  1229.  
  1230.    Signal_Focus_Changed : constant Glib.Signal_Name := "focus-changed"; 
  1231.    procedure On_Focus_Changed 
  1232.       (Self  : not null access Gtk_Cell_Area_Record; 
  1233.        Call  : Cb_Gtk_Cell_Area_Gtk_Cell_Renderer_UTF8_String_Void; 
  1234.        After : Boolean := False); 
  1235.    procedure On_Focus_Changed 
  1236.       (Self  : not null access Gtk_Cell_Area_Record; 
  1237.        Call  : Cb_GObject_Gtk_Cell_Renderer_UTF8_String_Void; 
  1238.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1239.        After : Boolean := False); 
  1240.    --  Indicates that focus changed on this Area. This signal is emitted 
  1241.    --  either as a result of focus handling or event handling. 
  1242.    -- 
  1243.    --  It's possible that the signal is emitted even if the currently focused 
  1244.    --  renderer did not change, this is because focus may change to the same 
  1245.    --  renderer in the same cell area for a different row of data. 
  1246.    --  
  1247.    --  Callback parameters: 
  1248.    --    --  "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer that has focus 
  1249.    --    --  "path": the current Gtk.Tree_Model.Gtk_Tree_Path string set for Area 
  1250.  
  1251.    type Cb_Gtk_Cell_Area_Gtk_Cell_Renderer_Gtk_Cell_Editable_Void is not null access procedure 
  1252.      (Self     : access Gtk_Cell_Area_Record'Class; 
  1253.       Renderer : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  1254.       Editable : Gtk.Cell_Editable.Gtk_Cell_Editable); 
  1255.  
  1256.    type Cb_GObject_Gtk_Cell_Renderer_Gtk_Cell_Editable_Void is not null access procedure 
  1257.      (Self     : access Glib.Object.GObject_Record'Class; 
  1258.       Renderer : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  1259.       Editable : Gtk.Cell_Editable.Gtk_Cell_Editable); 
  1260.  
  1261.    Signal_Remove_Editable : constant Glib.Signal_Name := "remove-editable"; 
  1262.    procedure On_Remove_Editable 
  1263.       (Self  : not null access Gtk_Cell_Area_Record; 
  1264.        Call  : Cb_Gtk_Cell_Area_Gtk_Cell_Renderer_Gtk_Cell_Editable_Void; 
  1265.        After : Boolean := False); 
  1266.    procedure On_Remove_Editable 
  1267.       (Self  : not null access Gtk_Cell_Area_Record; 
  1268.        Call  : Cb_GObject_Gtk_Cell_Renderer_Gtk_Cell_Editable_Void; 
  1269.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1270.        After : Boolean := False); 
  1271.    --  Indicates that editing finished on Renderer and that Editable should be 
  1272.    --  removed from the owning cell-layouting widget. 
  1273.    --  
  1274.    --  Callback parameters: 
  1275.    --    --  "renderer": the Gtk.Cell_Renderer.Gtk_Cell_Renderer that finished 
  1276.    --    --  editeding 
  1277.    --    --  "editable": the Gtk.Cell_Editable.Gtk_Cell_Editable widget to remove 
  1278.  
  1279.    ---------------- 
  1280.    -- Interfaces -- 
  1281.    ---------------- 
  1282.    --  This class implements several interfaces. See Glib.Types 
  1283.    -- 
  1284.    --  - "Buildable" 
  1285.    -- 
  1286.    --  - "CellLayout" 
  1287.  
  1288.    package Implements_Gtk_Buildable is new Glib.Types.Implements 
  1289.      (Gtk.Buildable.Gtk_Buildable, Gtk_Cell_Area_Record, Gtk_Cell_Area); 
  1290.    function "+" 
  1291.      (Widget : access Gtk_Cell_Area_Record'Class) 
  1292.    return Gtk.Buildable.Gtk_Buildable 
  1293.    renames Implements_Gtk_Buildable.To_Interface; 
  1294.    function "-" 
  1295.      (Interf : Gtk.Buildable.Gtk_Buildable) 
  1296.    return Gtk_Cell_Area 
  1297.    renames Implements_Gtk_Buildable.To_Object; 
  1298.  
  1299.    package Implements_Gtk_Cell_Layout is new Glib.Types.Implements 
  1300.      (Gtk.Cell_Layout.Gtk_Cell_Layout, Gtk_Cell_Area_Record, Gtk_Cell_Area); 
  1301.    function "+" 
  1302.      (Widget : access Gtk_Cell_Area_Record'Class) 
  1303.    return Gtk.Cell_Layout.Gtk_Cell_Layout 
  1304.    renames Implements_Gtk_Cell_Layout.To_Interface; 
  1305.    function "-" 
  1306.      (Interf : Gtk.Cell_Layout.Gtk_Cell_Layout) 
  1307.    return Gtk_Cell_Area 
  1308.    renames Implements_Gtk_Cell_Layout.To_Object; 
  1309.  
  1310. private 
  1311.    Focus_Cell_Property : constant Glib.Properties.Property_Object := 
  1312.      Glib.Properties.Build ("focus-cell"); 
  1313.    Edited_Cell_Property : constant Glib.Properties.Property_Object := 
  1314.      Glib.Properties.Build ("edited-cell"); 
  1315.    Edit_Widget_Property : constant Glib.Properties.Property_Interface := 
  1316.      Glib.Properties.Build ("edit-widget"); 
  1317. end Gtk.Cell_Area;