1 /*
2  * This file is part of gtkD.
3  *
4  * gtkD is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License
6  * as published by the Free Software Foundation; either version 3
7  * of the License, or (at your option) any later version, with
8  * some exceptions, please read the COPYING file.
9  *
10  * gtkD is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public License
16  * along with gtkD; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
18  */
19 
20 // generated automatically - do not change
21 // find conversion definition on APILookup.txt
22 // implement new conversion functionalities on the wrap.utils pakage
23 
24 
25 module gtk.CellArea;
26 
27 private import cairo.Context;
28 private import gdk.Event;
29 private import glib.ListG;
30 private import glib.Str;
31 private import gobject.ObjectG;
32 private import gobject.Signals;
33 private import gobject.Value;
34 private import gtk.BuildableIF;
35 private import gtk.BuildableT;
36 private import gtk.CellAreaContext;
37 private import gtk.CellEditableIF;
38 private import gtk.CellLayoutIF;
39 private import gtk.CellLayoutT;
40 private import gtk.CellRenderer;
41 private import gtk.TreeIter;
42 private import gtk.TreeModelIF;
43 private import gtk.Widget;
44 private import gtk.c.functions;
45 public  import gtk.c.types;
46 public  import gtkc.gtktypes;
47 private import std.algorithm;
48 
49 
50 /**
51  * The #GtkCellArea is an abstract class for #GtkCellLayout widgets
52  * (also referred to as "layouting widgets") to interface with an
53  * arbitrary number of #GtkCellRenderers and interact with the user
54  * for a given #GtkTreeModel row.
55  * 
56  * The cell area handles events, focus navigation, drawing and
57  * size requests and allocations for a given row of data.
58  * 
59  * Usually users dont have to interact with the #GtkCellArea directly
60  * unless they are implementing a cell-layouting widget themselves.
61  * 
62  * # Requesting area sizes
63  * 
64  * As outlined in
65  * [GtkWidget’s geometry management section][geometry-management],
66  * GTK+ uses a height-for-width
67  * geometry management system to compute the sizes of widgets and user
68  * interfaces. #GtkCellArea uses the same semantics to calculate the
69  * size of an area for an arbitrary number of #GtkTreeModel rows.
70  * 
71  * When requesting the size of a cell area one needs to calculate
72  * the size for a handful of rows, and this will be done differently by
73  * different layouting widgets. For instance a #GtkTreeViewColumn
74  * always lines up the areas from top to bottom while a #GtkIconView
75  * on the other hand might enforce that all areas received the same
76  * width and wrap the areas around, requesting height for more cell
77  * areas when allocated less width.
78  * 
79  * It’s also important for areas to maintain some cell
80  * alignments with areas rendered for adjacent rows (cells can
81  * appear “columnized” inside an area even when the size of
82  * cells are different in each row). For this reason the #GtkCellArea
83  * uses a #GtkCellAreaContext object to store the alignments
84  * and sizes along the way (as well as the overall largest minimum
85  * and natural size for all the rows which have been calculated
86  * with the said context).
87  * 
88  * The #GtkCellAreaContext is an opaque object specific to the
89  * #GtkCellArea which created it (see gtk_cell_area_create_context()).
90  * The owning cell-layouting widget can create as many contexts as
91  * it wishes to calculate sizes of rows which should receive the
92  * same size in at least one orientation (horizontally or vertically),
93  * However, it’s important that the same #GtkCellAreaContext which
94  * was used to request the sizes for a given #GtkTreeModel row be
95  * used when rendering or processing events for that row.
96  * 
97  * In order to request the width of all the rows at the root level
98  * of a #GtkTreeModel one would do the following:
99  * 
100  * |[<!-- language="C" -->
101  * GtkTreeIter iter;
102  * gint        minimum_width;
103  * gint        natural_width;
104  * 
105  * valid = gtk_tree_model_get_iter_first (model, &iter);
106  * while (valid)
107  * {
108  * gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
109  * gtk_cell_area_get_preferred_width (area, context, widget, NULL, NULL);
110  * 
111  * valid = gtk_tree_model_iter_next (model, &iter);
112  * }
113  * gtk_cell_area_context_get_preferred_width (context, &minimum_width, &natural_width);
114  * ]|
115  * 
116  * Note that in this example it’s not important to observe the
117  * returned minimum and natural width of the area for each row
118  * unless the cell-layouting object is actually interested in the
119  * widths of individual rows. The overall width is however stored
120  * in the accompanying #GtkCellAreaContext object and can be consulted
121  * at any time.
122  * 
123  * This can be useful since #GtkCellLayout widgets usually have to
124  * support requesting and rendering rows in treemodels with an
125  * exceedingly large amount of rows. The #GtkCellLayout widget in
126  * that case would calculate the required width of the rows in an
127  * idle or timeout source (see g_timeout_add()) and when the widget
128  * is requested its actual width in #GtkWidgetClass.get_preferred_width()
129  * it can simply consult the width accumulated so far in the
130  * #GtkCellAreaContext object.
131  * 
132  * A simple example where rows are rendered from top to bottom and
133  * take up the full width of the layouting widget would look like:
134  * 
135  * |[<!-- language="C" -->
136  * static void
137  * foo_get_preferred_width (GtkWidget       *widget,
138  * gint            *minimum_size,
139  * gint            *natural_size)
140  * {
141  * Foo        *foo  = FOO (widget);
142  * FooPrivate *priv = foo->priv;
143  * 
144  * foo_ensure_at_least_one_handfull_of_rows_have_been_requested (foo);
145  * 
146  * gtk_cell_area_context_get_preferred_width (priv->context, minimum_size, natural_size);
147  * }
148  * ]|
149  * 
150  * In the above example the Foo widget has to make sure that some
151  * row sizes have been calculated (the amount of rows that Foo judged
152  * was appropriate to request space for in a single timeout iteration)
153  * before simply returning the amount of space required by the area via
154  * the #GtkCellAreaContext.
155  * 
156  * Requesting the height for width (or width for height) of an area is
157  * a similar task except in this case the #GtkCellAreaContext does not
158  * store the data (actually, it does not know how much space the layouting
159  * widget plans to allocate it for every row. It’s up to the layouting
160  * widget to render each row of data with the appropriate height and
161  * width which was requested by the #GtkCellArea).
162  * 
163  * In order to request the height for width of all the rows at the
164  * root level of a #GtkTreeModel one would do the following:
165  * 
166  * |[<!-- language="C" -->
167  * GtkTreeIter iter;
168  * gint        minimum_height;
169  * gint        natural_height;
170  * gint        full_minimum_height = 0;
171  * gint        full_natural_height = 0;
172  * 
173  * valid = gtk_tree_model_get_iter_first (model, &iter);
174  * while (valid)
175  * {
176  * gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
177  * gtk_cell_area_get_preferred_height_for_width (area, context, widget,
178  * width, &minimum_height, &natural_height);
179  * 
180  * if (width_is_for_allocation)
181  * cache_row_height (&iter, minimum_height, natural_height);
182  * 
183  * full_minimum_height += minimum_height;
184  * full_natural_height += natural_height;
185  * 
186  * valid = gtk_tree_model_iter_next (model, &iter);
187  * }
188  * ]|
189  * 
190  * Note that in the above example we would need to cache the heights
191  * returned for each row so that we would know what sizes to render the
192  * areas for each row. However we would only want to really cache the
193  * heights if the request is intended for the layouting widgets real
194  * allocation.
195  * 
196  * In some cases the layouting widget is requested the height for an
197  * arbitrary for_width, this is a special case for layouting widgets
198  * who need to request size for tens of thousands  of rows. For this
199  * case it’s only important that the layouting widget calculate
200  * one reasonably sized chunk of rows and return that height
201  * synchronously. The reasoning here is that any layouting widget is
202  * at least capable of synchronously calculating enough height to fill
203  * the screen height (or scrolled window height) in response to a single
204  * call to #GtkWidgetClass.get_preferred_height_for_width(). Returning
205  * a perfect height for width that is larger than the screen area is
206  * inconsequential since after the layouting receives an allocation
207  * from a scrolled window it simply continues to drive the scrollbar
208  * values while more and more height is required for the row heights
209  * that are calculated in the background.
210  * 
211  * # Rendering Areas
212  * 
213  * Once area sizes have been aquired at least for the rows in the
214  * visible area of the layouting widget they can be rendered at
215  * #GtkWidgetClass.draw() time.
216  * 
217  * A crude example of how to render all the rows at the root level
218  * runs as follows:
219  * 
220  * |[<!-- language="C" -->
221  * GtkAllocation allocation;
222  * GdkRectangle  cell_area = { 0, };
223  * GtkTreeIter   iter;
224  * gint          minimum_width;
225  * gint          natural_width;
226  * 
227  * gtk_widget_get_allocation (widget, &allocation);
228  * cell_area.width = allocation.width;
229  * 
230  * valid = gtk_tree_model_get_iter_first (model, &iter);
231  * while (valid)
232  * {
233  * cell_area.height = get_cached_height_for_row (&iter);
234  * 
235  * gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
236  * gtk_cell_area_render (area, context, widget, cr,
237  * &cell_area, &cell_area, state_flags, FALSE);
238  * 
239  * cell_area.y += cell_area.height;
240  * 
241  * valid = gtk_tree_model_iter_next (model, &iter);
242  * }
243  * ]|
244  * 
245  * Note that the cached height in this example really depends on how
246  * the layouting widget works. The layouting widget might decide to
247  * give every row its minimum or natural height or, if the model content
248  * is expected to fit inside the layouting widget without scrolling, it
249  * would make sense to calculate the allocation for each row at
250  * #GtkWidget::size-allocate time using gtk_distribute_natural_allocation().
251  * 
252  * # Handling Events and Driving Keyboard Focus
253  * 
254  * Passing events to the area is as simple as handling events on any
255  * normal widget and then passing them to the gtk_cell_area_event()
256  * API as they come in. Usually #GtkCellArea is only interested in
257  * button events, however some customized derived areas can be implemented
258  * who are interested in handling other events. Handling an event can
259  * trigger the #GtkCellArea::focus-changed signal to fire; as well as
260  * #GtkCellArea::add-editable in the case that an editable cell was
261  * clicked and needs to start editing. You can call
262  * gtk_cell_area_stop_editing() at any time to cancel any cell editing
263  * that is currently in progress.
264  * 
265  * The #GtkCellArea drives keyboard focus from cell to cell in a way
266  * similar to #GtkWidget. For layouting widgets that support giving
267  * focus to cells it’s important to remember to pass %GTK_CELL_RENDERER_FOCUSED
268  * to the area functions for the row that has focus and to tell the
269  * area to paint the focus at render time.
270  * 
271  * Layouting widgets that accept focus on cells should implement the
272  * #GtkWidgetClass.focus() virtual method. The layouting widget is always
273  * responsible for knowing where #GtkTreeModel rows are rendered inside
274  * the widget, so at #GtkWidgetClass.focus() time the layouting widget
275  * should use the #GtkCellArea methods to navigate focus inside the area
276  * and then observe the GtkDirectionType to pass the focus to adjacent
277  * rows and areas.
278  * 
279  * A basic example of how the #GtkWidgetClass.focus() virtual method
280  * should be implemented:
281  * 
282  * |[<!-- language="C" -->
283  * static gboolean
284  * foo_focus (GtkWidget       *widget,
285  * GtkDirectionType direction)
286  * {
287  * Foo        *foo  = FOO (widget);
288  * FooPrivate *priv = foo->priv;
289  * gint        focus_row;
290  * gboolean    have_focus = FALSE;
291  * 
292  * focus_row = priv->focus_row;
293  * 
294  * if (!gtk_widget_has_focus (widget))
295  * gtk_widget_grab_focus (widget);
296  * 
297  * valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, priv->focus_row);
298  * while (valid)
299  * {
300  * gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE);
301  * 
302  * if (gtk_cell_area_focus (priv->area, direction))
303  * {
304  * priv->focus_row = focus_row;
305  * have_focus = TRUE;
306  * break;
307  * }
308  * else
309  * {
310  * if (direction == GTK_DIR_RIGHT ||
311  * direction == GTK_DIR_LEFT)
312  * break;
313  * else if (direction == GTK_DIR_UP ||
314  * direction == GTK_DIR_TAB_BACKWARD)
315  * {
316  * if (focus_row == 0)
317  * break;
318  * else
319  * {
320  * focus_row--;
321  * valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, focus_row);
322  * }
323  * }
324  * else
325  * {
326  * if (focus_row == last_row)
327  * break;
328  * else
329  * {
330  * focus_row++;
331  * valid = gtk_tree_model_iter_next (priv->model, &iter);
332  * }
333  * }
334  * }
335  * }
336  * return have_focus;
337  * }
338  * ]|
339  * 
340  * Note that the layouting widget is responsible for matching the
341  * GtkDirectionType values to the way it lays out its cells.
342  * 
343  * # Cell Properties
344  * 
345  * The #GtkCellArea introduces cell properties for #GtkCellRenderers
346  * in very much the same way that #GtkContainer introduces
347  * [child properties][child-properties]
348  * for #GtkWidgets. This provides some general interfaces for defining
349  * the relationship cell areas have with their cells. For instance in a
350  * #GtkCellAreaBox a cell might “expand” and receive extra space when
351  * the area is allocated more than its full natural request, or a cell
352  * might be configured to “align” with adjacent rows which were requested
353  * and rendered with the same #GtkCellAreaContext.
354  * 
355  * Use gtk_cell_area_class_install_cell_property() to install cell
356  * properties for a cell area class and gtk_cell_area_class_find_cell_property()
357  * or gtk_cell_area_class_list_cell_properties() to get information about
358  * existing cell properties.
359  * 
360  * To set the value of a cell property, use gtk_cell_area_cell_set_property(),
361  * gtk_cell_area_cell_set() or gtk_cell_area_cell_set_valist(). To obtain
362  * the value of a cell property, use gtk_cell_area_cell_get_property(),
363  * gtk_cell_area_cell_get() or gtk_cell_area_cell_get_valist().
364  */
365 public class CellArea : ObjectG, BuildableIF, CellLayoutIF
366 {
367 	/** the main Gtk struct */
368 	protected GtkCellArea* gtkCellArea;
369 
370 	/** Get the main Gtk struct */
371 	public GtkCellArea* getCellAreaStruct(bool transferOwnership = false)
372 	{
373 		if (transferOwnership)
374 			ownedRef = false;
375 		return gtkCellArea;
376 	}
377 
378 	/** the main Gtk struct as a void* */
379 	protected override void* getStruct()
380 	{
381 		return cast(void*)gtkCellArea;
382 	}
383 
384 	protected override void setStruct(GObject* obj)
385 	{
386 		gtkCellArea = cast(GtkCellArea*)obj;
387 		super.setStruct(obj);
388 	}
389 
390 	/**
391 	 * Sets our main struct and passes it to the parent class.
392 	 */
393 	public this (GtkCellArea* gtkCellArea, bool ownedRef = false)
394 	{
395 		this.gtkCellArea = gtkCellArea;
396 		super(cast(GObject*)gtkCellArea, ownedRef);
397 	}
398 
399 	// add the Buildable capabilities
400 	mixin BuildableT!(GtkCellArea);
401 
402 	// add the CellLayout capabilities
403 	mixin CellLayoutT!(GtkCellArea);
404 
405 
406 	/** */
407 	public static GType getType()
408 	{
409 		return gtk_cell_area_get_type();
410 	}
411 
412 	/**
413 	 * Activates @area, usually by activating the currently focused
414 	 * cell, however some subclasses which embed widgets in the area
415 	 * can also activate a widget if it currently has the focus.
416 	 *
417 	 * Params:
418 	 *     context = the #GtkCellAreaContext in context with the current row data
419 	 *     widget = the #GtkWidget that @area is rendering on
420 	 *     cellArea = the size and location of @area relative to @widget’s allocation
421 	 *     flags = the #GtkCellRendererState flags for @area for this row of data.
422 	 *     editOnly = if %TRUE then only cell renderers that are %GTK_CELL_RENDERER_MODE_EDITABLE
423 	 *         will be activated.
424 	 *
425 	 * Returns: Whether @area was successfully activated.
426 	 *
427 	 * Since: 3.0
428 	 */
429 	public bool activate(CellAreaContext context, Widget widget, GdkRectangle* cellArea, GtkCellRendererState flags, bool editOnly)
430 	{
431 		return gtk_cell_area_activate(gtkCellArea, (context is null) ? null : context.getCellAreaContextStruct(), (widget is null) ? null : widget.getWidgetStruct(), cellArea, flags, editOnly) != 0;
432 	}
433 
434 	/**
435 	 * This is used by #GtkCellArea subclasses when handling events
436 	 * to activate cells, the base #GtkCellArea class activates cells
437 	 * for keyboard events for free in its own GtkCellArea->activate()
438 	 * implementation.
439 	 *
440 	 * Params:
441 	 *     widget = the #GtkWidget that @area is rendering onto
442 	 *     renderer = the #GtkCellRenderer in @area to activate
443 	 *     event = the #GdkEvent for which cell activation should occur
444 	 *     cellArea = the #GdkRectangle in @widget relative coordinates
445 	 *         of @renderer for the current row.
446 	 *     flags = the #GtkCellRendererState for @renderer
447 	 *
448 	 * Returns: whether cell activation was successful
449 	 *
450 	 * Since: 3.0
451 	 */
452 	public bool activateCell(Widget widget, CellRenderer renderer, Event event, GdkRectangle* cellArea, GtkCellRendererState flags)
453 	{
454 		return gtk_cell_area_activate_cell(gtkCellArea, (widget is null) ? null : widget.getWidgetStruct(), (renderer is null) ? null : renderer.getCellRendererStruct(), (event is null) ? null : event.getEventStruct(), cellArea, flags) != 0;
455 	}
456 
457 	/**
458 	 * Adds @renderer to @area with the default child cell properties.
459 	 *
460 	 * Params:
461 	 *     renderer = the #GtkCellRenderer to add to @area
462 	 *
463 	 * Since: 3.0
464 	 */
465 	public void add(CellRenderer renderer)
466 	{
467 		gtk_cell_area_add(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct());
468 	}
469 
470 	/**
471 	 * Adds @sibling to @renderer’s focusable area, focus will be drawn
472 	 * around @renderer and all of its siblings if @renderer can
473 	 * focus for a given row.
474 	 *
475 	 * Events handled by focus siblings can also activate the given
476 	 * focusable @renderer.
477 	 *
478 	 * Params:
479 	 *     renderer = the #GtkCellRenderer expected to have focus
480 	 *     sibling = the #GtkCellRenderer to add to @renderer’s focus area
481 	 *
482 	 * Since: 3.0
483 	 */
484 	public void addFocusSibling(CellRenderer renderer, CellRenderer sibling)
485 	{
486 		gtk_cell_area_add_focus_sibling(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct(), (sibling is null) ? null : sibling.getCellRendererStruct());
487 	}
488 
489 	/**
490 	 * Applies any connected attributes to the renderers in
491 	 * @area by pulling the values from @tree_model.
492 	 *
493 	 * Params:
494 	 *     treeModel = the #GtkTreeModel to pull values from
495 	 *     iter = the #GtkTreeIter in @tree_model to apply values for
496 	 *     isExpander = whether @iter has children
497 	 *     isExpanded = whether @iter is expanded in the view and
498 	 *         children are visible
499 	 *
500 	 * Since: 3.0
501 	 */
502 	public void applyAttributes(TreeModelIF treeModel, TreeIter iter, bool isExpander, bool isExpanded)
503 	{
504 		gtk_cell_area_apply_attributes(gtkCellArea, (treeModel is null) ? null : treeModel.getTreeModelStruct(), (iter is null) ? null : iter.getTreeIterStruct(), isExpander, isExpanded);
505 	}
506 
507 	/**
508 	 * Connects an @attribute to apply values from @column for the
509 	 * #GtkTreeModel in use.
510 	 *
511 	 * Params:
512 	 *     renderer = the #GtkCellRenderer to connect an attribute for
513 	 *     attribute = the attribute name
514 	 *     column = the #GtkTreeModel column to fetch attribute values from
515 	 *
516 	 * Since: 3.0
517 	 */
518 	public void attributeConnect(CellRenderer renderer, string attribute, int column)
519 	{
520 		gtk_cell_area_attribute_connect(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct(), Str.toStringz(attribute), column);
521 	}
522 
523 	/**
524 	 * Disconnects @attribute for the @renderer in @area so that
525 	 * attribute will no longer be updated with values from the
526 	 * model.
527 	 *
528 	 * Params:
529 	 *     renderer = the #GtkCellRenderer to disconnect an attribute for
530 	 *     attribute = the attribute name
531 	 *
532 	 * Since: 3.0
533 	 */
534 	public void attributeDisconnect(CellRenderer renderer, string attribute)
535 	{
536 		gtk_cell_area_attribute_disconnect(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct(), Str.toStringz(attribute));
537 	}
538 
539 	/**
540 	 * Returns the model column that an attribute has been mapped to,
541 	 * or -1 if the attribute is not mapped.
542 	 *
543 	 * Params:
544 	 *     renderer = a #GtkCellRenderer
545 	 *     attribute = an attribute on the renderer
546 	 *
547 	 * Returns: the model column, or -1
548 	 *
549 	 * Since: 3.14
550 	 */
551 	public int attributeGetColumn(CellRenderer renderer, string attribute)
552 	{
553 		return gtk_cell_area_attribute_get_column(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct(), Str.toStringz(attribute));
554 	}
555 
556 	/**
557 	 * Gets the value of a cell property for @renderer in @area.
558 	 *
559 	 * Params:
560 	 *     renderer = a #GtkCellRenderer inside @area
561 	 *     propertyName = the name of the property to get
562 	 *     value = a location to return the value
563 	 *
564 	 * Since: 3.0
565 	 */
566 	public void cellGetProperty(CellRenderer renderer, string propertyName, Value value)
567 	{
568 		gtk_cell_area_cell_get_property(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct(), Str.toStringz(propertyName), (value is null) ? null : value.getValueStruct());
569 	}
570 
571 	/**
572 	 * Gets the values of one or more cell properties for @renderer in @area.
573 	 *
574 	 * Params:
575 	 *     renderer = a #GtkCellRenderer inside @area
576 	 *     firstPropertyName = the name of the first property to get
577 	 *     varArgs = return location for the first property, followed
578 	 *         optionally by more name/return location pairs, followed by %NULL
579 	 *
580 	 * Since: 3.0
581 	 */
582 	public void cellGetValist(CellRenderer renderer, string firstPropertyName, void* varArgs)
583 	{
584 		gtk_cell_area_cell_get_valist(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct(), Str.toStringz(firstPropertyName), varArgs);
585 	}
586 
587 	/**
588 	 * Sets a cell property for @renderer in @area.
589 	 *
590 	 * Params:
591 	 *     renderer = a #GtkCellRenderer inside @area
592 	 *     propertyName = the name of the cell property to set
593 	 *     value = the value to set the cell property to
594 	 *
595 	 * Since: 3.0
596 	 */
597 	public void cellSetProperty(CellRenderer renderer, string propertyName, Value value)
598 	{
599 		gtk_cell_area_cell_set_property(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct(), Str.toStringz(propertyName), (value is null) ? null : value.getValueStruct());
600 	}
601 
602 	/**
603 	 * Sets one or more cell properties for @renderer in @area.
604 	 *
605 	 * Params:
606 	 *     renderer = a #GtkCellRenderer which inside @area
607 	 *     firstPropertyName = the name of the first cell property to set
608 	 *     varArgs = a %NULL-terminated list of property names and values, starting
609 	 *         with @first_prop_name
610 	 *
611 	 * Since: 3.0
612 	 */
613 	public void cellSetValist(CellRenderer renderer, string firstPropertyName, void* varArgs)
614 	{
615 		gtk_cell_area_cell_set_valist(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct(), Str.toStringz(firstPropertyName), varArgs);
616 	}
617 
618 	/**
619 	 * This is sometimes needed for cases where rows need to share
620 	 * alignments in one orientation but may be separately grouped
621 	 * in the opposing orientation.
622 	 *
623 	 * For instance, #GtkIconView creates all icons (rows) to have
624 	 * the same width and the cells theirin to have the same
625 	 * horizontal alignments. However each row of icons may have
626 	 * a separate collective height. #GtkIconView uses this to
627 	 * request the heights of each row based on a context which
628 	 * was already used to request all the row widths that are
629 	 * to be displayed.
630 	 *
631 	 * Params:
632 	 *     context = the #GtkCellAreaContext to copy
633 	 *
634 	 * Returns: a newly created #GtkCellAreaContext copy of @context.
635 	 *
636 	 * Since: 3.0
637 	 */
638 	public CellAreaContext copyContext(CellAreaContext context)
639 	{
640 		auto p = gtk_cell_area_copy_context(gtkCellArea, (context is null) ? null : context.getCellAreaContextStruct());
641 
642 		if(p is null)
643 		{
644 			return null;
645 		}
646 
647 		return ObjectG.getDObject!(CellAreaContext)(cast(GtkCellAreaContext*) p, true);
648 	}
649 
650 	/**
651 	 * Creates a #GtkCellAreaContext to be used with @area for
652 	 * all purposes. #GtkCellAreaContext stores geometry information
653 	 * for rows for which it was operated on, it is important to use
654 	 * the same context for the same row of data at all times (i.e.
655 	 * one should render and handle events with the same #GtkCellAreaContext
656 	 * which was used to request the size of those rows of data).
657 	 *
658 	 * Returns: a newly created #GtkCellAreaContext which can be used with @area.
659 	 *
660 	 * Since: 3.0
661 	 */
662 	public CellAreaContext createContext()
663 	{
664 		auto p = gtk_cell_area_create_context(gtkCellArea);
665 
666 		if(p is null)
667 		{
668 			return null;
669 		}
670 
671 		return ObjectG.getDObject!(CellAreaContext)(cast(GtkCellAreaContext*) p, true);
672 	}
673 
674 	/**
675 	 * Delegates event handling to a #GtkCellArea.
676 	 *
677 	 * Params:
678 	 *     context = the #GtkCellAreaContext for this row of data.
679 	 *     widget = the #GtkWidget that @area is rendering to
680 	 *     event = the #GdkEvent to handle
681 	 *     cellArea = the @widget relative coordinates for @area
682 	 *     flags = the #GtkCellRendererState for @area in this row.
683 	 *
684 	 * Returns: %TRUE if the event was handled by @area.
685 	 *
686 	 * Since: 3.0
687 	 */
688 	public int event(CellAreaContext context, Widget widget, Event event, GdkRectangle* cellArea, GtkCellRendererState flags)
689 	{
690 		return gtk_cell_area_event(gtkCellArea, (context is null) ? null : context.getCellAreaContextStruct(), (widget is null) ? null : widget.getWidgetStruct(), (event is null) ? null : event.getEventStruct(), cellArea, flags);
691 	}
692 
693 	/**
694 	 * This should be called by the @area’s owning layout widget
695 	 * when focus is to be passed to @area, or moved within @area
696 	 * for a given @direction and row data.
697 	 *
698 	 * Implementing #GtkCellArea classes should implement this
699 	 * method to receive and navigate focus in its own way particular
700 	 * to how it lays out cells.
701 	 *
702 	 * Params:
703 	 *     direction = the #GtkDirectionType
704 	 *
705 	 * Returns: %TRUE if focus remains inside @area as a result of this call.
706 	 *
707 	 * Since: 3.0
708 	 */
709 	public bool focus(GtkDirectionType direction)
710 	{
711 		return gtk_cell_area_focus(gtkCellArea, direction) != 0;
712 	}
713 
714 	/**
715 	 * Calls @callback for every #GtkCellRenderer in @area.
716 	 *
717 	 * Params:
718 	 *     callback = the #GtkCellCallback to call
719 	 *     callbackData = user provided data pointer
720 	 *
721 	 * Since: 3.0
722 	 */
723 	public void foreac(GtkCellCallback callback, void* callbackData)
724 	{
725 		gtk_cell_area_foreach(gtkCellArea, callback, callbackData);
726 	}
727 
728 	/**
729 	 * Calls @callback for every #GtkCellRenderer in @area with the
730 	 * allocated rectangle inside @cell_area.
731 	 *
732 	 * Params:
733 	 *     context = the #GtkCellAreaContext for this row of data.
734 	 *     widget = the #GtkWidget that @area is rendering to
735 	 *     cellArea = the @widget relative coordinates and size for @area
736 	 *     backgroundArea = the @widget relative coordinates of the background area
737 	 *     callback = the #GtkCellAllocCallback to call
738 	 *     callbackData = user provided data pointer
739 	 *
740 	 * Since: 3.0
741 	 */
742 	public void foreachAlloc(CellAreaContext context, Widget widget, GdkRectangle* cellArea, GdkRectangle* backgroundArea, GtkCellAllocCallback callback, void* callbackData)
743 	{
744 		gtk_cell_area_foreach_alloc(gtkCellArea, (context is null) ? null : context.getCellAreaContextStruct(), (widget is null) ? null : widget.getWidgetStruct(), cellArea, backgroundArea, callback, callbackData);
745 	}
746 
747 	/**
748 	 * Derives the allocation of @renderer inside @area if @area
749 	 * were to be renderered in @cell_area.
750 	 *
751 	 * Params:
752 	 *     context = the #GtkCellAreaContext used to hold sizes for @area.
753 	 *     widget = the #GtkWidget that @area is rendering on
754 	 *     renderer = the #GtkCellRenderer to get the allocation for
755 	 *     cellArea = the whole allocated area for @area in @widget
756 	 *         for this row
757 	 *     allocation = where to store the allocation for @renderer
758 	 *
759 	 * Since: 3.0
760 	 */
761 	public void getCellAllocation(CellAreaContext context, Widget widget, CellRenderer renderer, GdkRectangle* cellArea, out GdkRectangle allocation)
762 	{
763 		gtk_cell_area_get_cell_allocation(gtkCellArea, (context is null) ? null : context.getCellAreaContextStruct(), (widget is null) ? null : widget.getWidgetStruct(), (renderer is null) ? null : renderer.getCellRendererStruct(), cellArea, &allocation);
764 	}
765 
766 	/**
767 	 * Gets the #GtkCellRenderer at @x and @y coordinates inside @area and optionally
768 	 * returns the full cell allocation for it inside @cell_area.
769 	 *
770 	 * Params:
771 	 *     context = the #GtkCellAreaContext used to hold sizes for @area.
772 	 *     widget = the #GtkWidget that @area is rendering on
773 	 *     cellArea = the whole allocated area for @area in @widget
774 	 *         for this row
775 	 *     x = the x position
776 	 *     y = the y position
777 	 *     allocArea = where to store the inner allocated area of the
778 	 *         returned cell renderer, or %NULL.
779 	 *
780 	 * Returns: the #GtkCellRenderer at @x and @y.
781 	 *
782 	 * Since: 3.0
783 	 */
784 	public CellRenderer getCellAtPosition(CellAreaContext context, Widget widget, GdkRectangle* cellArea, int x, int y, out GdkRectangle allocArea)
785 	{
786 		auto p = gtk_cell_area_get_cell_at_position(gtkCellArea, (context is null) ? null : context.getCellAreaContextStruct(), (widget is null) ? null : widget.getWidgetStruct(), cellArea, x, y, &allocArea);
787 
788 		if(p is null)
789 		{
790 			return null;
791 		}
792 
793 		return ObjectG.getDObject!(CellRenderer)(cast(GtkCellRenderer*) p);
794 	}
795 
796 	/**
797 	 * Gets the current #GtkTreePath string for the currently
798 	 * applied #GtkTreeIter, this is implicitly updated when
799 	 * gtk_cell_area_apply_attributes() is called and can be
800 	 * used to interact with renderers from #GtkCellArea
801 	 * subclasses.
802 	 *
803 	 * Returns: The current #GtkTreePath string for the current
804 	 *     attributes applied to @area. This string belongs to the area and
805 	 *     should not be freed.
806 	 *
807 	 * Since: 3.0
808 	 */
809 	public string getCurrentPathString()
810 	{
811 		return Str.toString(gtk_cell_area_get_current_path_string(gtkCellArea));
812 	}
813 
814 	/**
815 	 * Gets the #GtkCellEditable widget currently used
816 	 * to edit the currently edited cell.
817 	 *
818 	 * Returns: The currently active #GtkCellEditable widget
819 	 *
820 	 * Since: 3.0
821 	 */
822 	public CellEditableIF getEditWidget()
823 	{
824 		auto p = gtk_cell_area_get_edit_widget(gtkCellArea);
825 
826 		if(p is null)
827 		{
828 			return null;
829 		}
830 
831 		return ObjectG.getDObject!(CellEditableIF)(cast(GtkCellEditable*) p);
832 	}
833 
834 	/**
835 	 * Gets the #GtkCellRenderer in @area that is currently
836 	 * being edited.
837 	 *
838 	 * Returns: The currently edited #GtkCellRenderer
839 	 *
840 	 * Since: 3.0
841 	 */
842 	public CellRenderer getEditedCell()
843 	{
844 		auto p = gtk_cell_area_get_edited_cell(gtkCellArea);
845 
846 		if(p is null)
847 		{
848 			return null;
849 		}
850 
851 		return ObjectG.getDObject!(CellRenderer)(cast(GtkCellRenderer*) p);
852 	}
853 
854 	/**
855 	 * Retrieves the currently focused cell for @area
856 	 *
857 	 * Returns: the currently focused cell in @area.
858 	 *
859 	 * Since: 3.0
860 	 */
861 	public CellRenderer getFocusCell()
862 	{
863 		auto p = gtk_cell_area_get_focus_cell(gtkCellArea);
864 
865 		if(p is null)
866 		{
867 			return null;
868 		}
869 
870 		return ObjectG.getDObject!(CellRenderer)(cast(GtkCellRenderer*) p);
871 	}
872 
873 	/**
874 	 * Gets the #GtkCellRenderer which is expected to be focusable
875 	 * for which @renderer is, or may be a sibling.
876 	 *
877 	 * This is handy for #GtkCellArea subclasses when handling events,
878 	 * after determining the renderer at the event location it can
879 	 * then chose to activate the focus cell for which the event
880 	 * cell may have been a sibling.
881 	 *
882 	 * Params:
883 	 *     renderer = the #GtkCellRenderer
884 	 *
885 	 * Returns: the #GtkCellRenderer for which @renderer
886 	 *     is a sibling, or %NULL.
887 	 *
888 	 * Since: 3.0
889 	 */
890 	public CellRenderer getFocusFromSibling(CellRenderer renderer)
891 	{
892 		auto p = gtk_cell_area_get_focus_from_sibling(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct());
893 
894 		if(p is null)
895 		{
896 			return null;
897 		}
898 
899 		return ObjectG.getDObject!(CellRenderer)(cast(GtkCellRenderer*) p);
900 	}
901 
902 	/**
903 	 * Gets the focus sibling cell renderers for @renderer.
904 	 *
905 	 * Params:
906 	 *     renderer = the #GtkCellRenderer expected to have focus
907 	 *
908 	 * Returns: A #GList of #GtkCellRenderers.
909 	 *     The returned list is internal and should not be freed.
910 	 *
911 	 * Since: 3.0
912 	 */
913 	public ListG getFocusSiblings(CellRenderer renderer)
914 	{
915 		auto p = gtk_cell_area_get_focus_siblings(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct());
916 
917 		if(p is null)
918 		{
919 			return null;
920 		}
921 
922 		return new ListG(cast(GList*) p);
923 	}
924 
925 	/**
926 	 * Retrieves a cell area’s initial minimum and natural height.
927 	 *
928 	 * @area will store some geometrical information in @context along the way;
929 	 * when requesting sizes over an arbitrary number of rows, it’s not important
930 	 * to check the @minimum_height and @natural_height of this call but rather to
931 	 * consult gtk_cell_area_context_get_preferred_height() after a series of
932 	 * requests.
933 	 *
934 	 * Params:
935 	 *     context = the #GtkCellAreaContext to perform this request with
936 	 *     widget = the #GtkWidget where @area will be rendering
937 	 *     minimumHeight = location to store the minimum height, or %NULL
938 	 *     naturalHeight = location to store the natural height, or %NULL
939 	 *
940 	 * Since: 3.0
941 	 */
942 	public void getPreferredHeight(CellAreaContext context, Widget widget, out int minimumHeight, out int naturalHeight)
943 	{
944 		gtk_cell_area_get_preferred_height(gtkCellArea, (context is null) ? null : context.getCellAreaContextStruct(), (widget is null) ? null : widget.getWidgetStruct(), &minimumHeight, &naturalHeight);
945 	}
946 
947 	/**
948 	 * Retrieves a cell area’s minimum and natural height if it would be given
949 	 * the specified @width.
950 	 *
951 	 * @area stores some geometrical information in @context along the way
952 	 * while calling gtk_cell_area_get_preferred_width(). It’s important to
953 	 * perform a series of gtk_cell_area_get_preferred_width() requests with
954 	 * @context first and then call gtk_cell_area_get_preferred_height_for_width()
955 	 * on each cell area individually to get the height for width of each
956 	 * fully requested row.
957 	 *
958 	 * If at some point, the width of a single row changes, it should be
959 	 * requested with gtk_cell_area_get_preferred_width() again and then
960 	 * the full width of the requested rows checked again with
961 	 * gtk_cell_area_context_get_preferred_width().
962 	 *
963 	 * Params:
964 	 *     context = the #GtkCellAreaContext which has already been requested for widths.
965 	 *     widget = the #GtkWidget where @area will be rendering
966 	 *     width = the width for which to check the height of this area
967 	 *     minimumHeight = location to store the minimum height, or %NULL
968 	 *     naturalHeight = location to store the natural height, or %NULL
969 	 *
970 	 * Since: 3.0
971 	 */
972 	public void getPreferredHeightForWidth(CellAreaContext context, Widget widget, int width, out int minimumHeight, out int naturalHeight)
973 	{
974 		gtk_cell_area_get_preferred_height_for_width(gtkCellArea, (context is null) ? null : context.getCellAreaContextStruct(), (widget is null) ? null : widget.getWidgetStruct(), width, &minimumHeight, &naturalHeight);
975 	}
976 
977 	/**
978 	 * Retrieves a cell area’s initial minimum and natural width.
979 	 *
980 	 * @area will store some geometrical information in @context along the way;
981 	 * when requesting sizes over an arbitrary number of rows, it’s not important
982 	 * to check the @minimum_width and @natural_width of this call but rather to
983 	 * consult gtk_cell_area_context_get_preferred_width() after a series of
984 	 * requests.
985 	 *
986 	 * Params:
987 	 *     context = the #GtkCellAreaContext to perform this request with
988 	 *     widget = the #GtkWidget where @area will be rendering
989 	 *     minimumWidth = location to store the minimum width, or %NULL
990 	 *     naturalWidth = location to store the natural width, or %NULL
991 	 *
992 	 * Since: 3.0
993 	 */
994 	public void getPreferredWidth(CellAreaContext context, Widget widget, out int minimumWidth, out int naturalWidth)
995 	{
996 		gtk_cell_area_get_preferred_width(gtkCellArea, (context is null) ? null : context.getCellAreaContextStruct(), (widget is null) ? null : widget.getWidgetStruct(), &minimumWidth, &naturalWidth);
997 	}
998 
999 	/**
1000 	 * Retrieves a cell area’s minimum and natural width if it would be given
1001 	 * the specified @height.
1002 	 *
1003 	 * @area stores some geometrical information in @context along the way
1004 	 * while calling gtk_cell_area_get_preferred_height(). It’s important to
1005 	 * perform a series of gtk_cell_area_get_preferred_height() requests with
1006 	 * @context first and then call gtk_cell_area_get_preferred_width_for_height()
1007 	 * on each cell area individually to get the height for width of each
1008 	 * fully requested row.
1009 	 *
1010 	 * If at some point, the height of a single row changes, it should be
1011 	 * requested with gtk_cell_area_get_preferred_height() again and then
1012 	 * the full height of the requested rows checked again with
1013 	 * gtk_cell_area_context_get_preferred_height().
1014 	 *
1015 	 * Params:
1016 	 *     context = the #GtkCellAreaContext which has already been requested for widths.
1017 	 *     widget = the #GtkWidget where @area will be rendering
1018 	 *     height = the height for which to check the width of this area
1019 	 *     minimumWidth = location to store the minimum width, or %NULL
1020 	 *     naturalWidth = location to store the natural width, or %NULL
1021 	 *
1022 	 * Since: 3.0
1023 	 */
1024 	public void getPreferredWidthForHeight(CellAreaContext context, Widget widget, int height, out int minimumWidth, out int naturalWidth)
1025 	{
1026 		gtk_cell_area_get_preferred_width_for_height(gtkCellArea, (context is null) ? null : context.getCellAreaContextStruct(), (widget is null) ? null : widget.getWidgetStruct(), height, &minimumWidth, &naturalWidth);
1027 	}
1028 
1029 	/**
1030 	 * Gets whether the area prefers a height-for-width layout
1031 	 * or a width-for-height layout.
1032 	 *
1033 	 * Returns: The #GtkSizeRequestMode preferred by @area.
1034 	 *
1035 	 * Since: 3.0
1036 	 */
1037 	public GtkSizeRequestMode getRequestMode()
1038 	{
1039 		return gtk_cell_area_get_request_mode(gtkCellArea);
1040 	}
1041 
1042 	/**
1043 	 * Checks if @area contains @renderer.
1044 	 *
1045 	 * Params:
1046 	 *     renderer = the #GtkCellRenderer to check
1047 	 *
1048 	 * Returns: %TRUE if @renderer is in the @area.
1049 	 *
1050 	 * Since: 3.0
1051 	 */
1052 	public bool hasRenderer(CellRenderer renderer)
1053 	{
1054 		return gtk_cell_area_has_renderer(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct()) != 0;
1055 	}
1056 
1057 	/**
1058 	 * This is a convenience function for #GtkCellArea implementations
1059 	 * to get the inner area where a given #GtkCellRenderer will be
1060 	 * rendered. It removes any padding previously added by gtk_cell_area_request_renderer().
1061 	 *
1062 	 * Params:
1063 	 *     widget = the #GtkWidget that @area is rendering onto
1064 	 *     cellArea = the @widget relative coordinates where one of @area’s cells
1065 	 *         is to be placed
1066 	 *     innerArea = the return location for the inner cell area
1067 	 *
1068 	 * Since: 3.0
1069 	 */
1070 	public void innerCellArea(Widget widget, GdkRectangle* cellArea, out GdkRectangle innerArea)
1071 	{
1072 		gtk_cell_area_inner_cell_area(gtkCellArea, (widget is null) ? null : widget.getWidgetStruct(), cellArea, &innerArea);
1073 	}
1074 
1075 	/**
1076 	 * Returns whether the area can do anything when activated,
1077 	 * after applying new attributes to @area.
1078 	 *
1079 	 * Returns: whether @area can do anything when activated.
1080 	 *
1081 	 * Since: 3.0
1082 	 */
1083 	public bool isActivatable()
1084 	{
1085 		return gtk_cell_area_is_activatable(gtkCellArea) != 0;
1086 	}
1087 
1088 	/**
1089 	 * Returns whether @sibling is one of @renderer’s focus siblings
1090 	 * (see gtk_cell_area_add_focus_sibling()).
1091 	 *
1092 	 * Params:
1093 	 *     renderer = the #GtkCellRenderer expected to have focus
1094 	 *     sibling = the #GtkCellRenderer to check against @renderer’s sibling list
1095 	 *
1096 	 * Returns: %TRUE if @sibling is a focus sibling of @renderer
1097 	 *
1098 	 * Since: 3.0
1099 	 */
1100 	public bool isFocusSibling(CellRenderer renderer, CellRenderer sibling)
1101 	{
1102 		return gtk_cell_area_is_focus_sibling(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct(), (sibling is null) ? null : sibling.getCellRendererStruct()) != 0;
1103 	}
1104 
1105 	/**
1106 	 * Removes @renderer from @area.
1107 	 *
1108 	 * Params:
1109 	 *     renderer = the #GtkCellRenderer to remove from @area
1110 	 *
1111 	 * Since: 3.0
1112 	 */
1113 	public void remove(CellRenderer renderer)
1114 	{
1115 		gtk_cell_area_remove(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct());
1116 	}
1117 
1118 	/**
1119 	 * Removes @sibling from @renderer’s focus sibling list
1120 	 * (see gtk_cell_area_add_focus_sibling()).
1121 	 *
1122 	 * Params:
1123 	 *     renderer = the #GtkCellRenderer expected to have focus
1124 	 *     sibling = the #GtkCellRenderer to remove from @renderer’s focus area
1125 	 *
1126 	 * Since: 3.0
1127 	 */
1128 	public void removeFocusSibling(CellRenderer renderer, CellRenderer sibling)
1129 	{
1130 		gtk_cell_area_remove_focus_sibling(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct(), (sibling is null) ? null : sibling.getCellRendererStruct());
1131 	}
1132 
1133 	/**
1134 	 * Renders @area’s cells according to @area’s layout onto @widget at
1135 	 * the given coordinates.
1136 	 *
1137 	 * Params:
1138 	 *     context = the #GtkCellAreaContext for this row of data.
1139 	 *     widget = the #GtkWidget that @area is rendering to
1140 	 *     cr = the #cairo_t to render with
1141 	 *     backgroundArea = the @widget relative coordinates for @area’s background
1142 	 *     cellArea = the @widget relative coordinates for @area
1143 	 *     flags = the #GtkCellRendererState for @area in this row.
1144 	 *     paintFocus = whether @area should paint focus on focused cells for focused rows or not.
1145 	 *
1146 	 * Since: 3.0
1147 	 */
1148 	public void render(CellAreaContext context, Widget widget, Context cr, GdkRectangle* backgroundArea, GdkRectangle* cellArea, GtkCellRendererState flags, bool paintFocus)
1149 	{
1150 		gtk_cell_area_render(gtkCellArea, (context is null) ? null : context.getCellAreaContextStruct(), (widget is null) ? null : widget.getWidgetStruct(), (cr is null) ? null : cr.getContextStruct(), backgroundArea, cellArea, flags, paintFocus);
1151 	}
1152 
1153 	/**
1154 	 * This is a convenience function for #GtkCellArea implementations
1155 	 * to request size for cell renderers. It’s important to use this
1156 	 * function to request size and then use gtk_cell_area_inner_cell_area()
1157 	 * at render and event time since this function will add padding
1158 	 * around the cell for focus painting.
1159 	 *
1160 	 * Params:
1161 	 *     renderer = the #GtkCellRenderer to request size for
1162 	 *     orientation = the #GtkOrientation in which to request size
1163 	 *     widget = the #GtkWidget that @area is rendering onto
1164 	 *     forSize = the allocation contextual size to request for, or -1 if
1165 	 *         the base request for the orientation is to be returned.
1166 	 *     minimumSize = location to store the minimum size, or %NULL
1167 	 *     naturalSize = location to store the natural size, or %NULL
1168 	 *
1169 	 * Since: 3.0
1170 	 */
1171 	public void requestRenderer(CellRenderer renderer, GtkOrientation orientation, Widget widget, int forSize, out int minimumSize, out int naturalSize)
1172 	{
1173 		gtk_cell_area_request_renderer(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct(), orientation, (widget is null) ? null : widget.getWidgetStruct(), forSize, &minimumSize, &naturalSize);
1174 	}
1175 
1176 	/**
1177 	 * Explicitly sets the currently focused cell to @renderer.
1178 	 *
1179 	 * This is generally called by implementations of
1180 	 * #GtkCellAreaClass.focus() or #GtkCellAreaClass.event(),
1181 	 * however it can also be used to implement functions such
1182 	 * as gtk_tree_view_set_cursor_on_cell().
1183 	 *
1184 	 * Params:
1185 	 *     renderer = the #GtkCellRenderer to give focus to
1186 	 *
1187 	 * Since: 3.0
1188 	 */
1189 	public void setFocusCell(CellRenderer renderer)
1190 	{
1191 		gtk_cell_area_set_focus_cell(gtkCellArea, (renderer is null) ? null : renderer.getCellRendererStruct());
1192 	}
1193 
1194 	/**
1195 	 * Explicitly stops the editing of the currently edited cell.
1196 	 *
1197 	 * If @canceled is %TRUE, the currently edited cell renderer
1198 	 * will emit the ::editing-canceled signal, otherwise the
1199 	 * the ::editing-done signal will be emitted on the current
1200 	 * edit widget.
1201 	 *
1202 	 * See gtk_cell_area_get_edited_cell() and gtk_cell_area_get_edit_widget().
1203 	 *
1204 	 * Params:
1205 	 *     canceled = whether editing was canceled.
1206 	 *
1207 	 * Since: 3.0
1208 	 */
1209 	public void stopEditing(bool canceled)
1210 	{
1211 		gtk_cell_area_stop_editing(gtkCellArea, canceled);
1212 	}
1213 
1214 	protected class OnAddEditableDelegateWrapper
1215 	{
1216 		void delegate(CellRenderer, CellEditableIF, GdkRectangle*, string, CellArea) dlg;
1217 		gulong handlerId;
1218 
1219 		this(void delegate(CellRenderer, CellEditableIF, GdkRectangle*, string, CellArea) dlg)
1220 		{
1221 			this.dlg = dlg;
1222 			onAddEditableListeners ~= this;
1223 		}
1224 
1225 		void remove(OnAddEditableDelegateWrapper source)
1226 		{
1227 			foreach(index, wrapper; onAddEditableListeners)
1228 			{
1229 				if (wrapper.handlerId == source.handlerId)
1230 				{
1231 					onAddEditableListeners[index] = null;
1232 					onAddEditableListeners = std.algorithm.remove(onAddEditableListeners, index);
1233 					break;
1234 				}
1235 			}
1236 		}
1237 	}
1238 	OnAddEditableDelegateWrapper[] onAddEditableListeners;
1239 
1240 	/**
1241 	 * Indicates that editing has started on @renderer and that @editable
1242 	 * should be added to the owning cell-layouting widget at @cell_area.
1243 	 *
1244 	 * Params:
1245 	 *     renderer = the #GtkCellRenderer that started the edited
1246 	 *     editable = the #GtkCellEditable widget to add
1247 	 *     cellArea = the #GtkWidget relative #GdkRectangle coordinates
1248 	 *         where @editable should be added
1249 	 *     path = the #GtkTreePath string this edit was initiated for
1250 	 *
1251 	 * Since: 3.0
1252 	 */
1253 	gulong addOnAddEditable(void delegate(CellRenderer, CellEditableIF, GdkRectangle*, string, CellArea) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1254 	{
1255 		auto wrapper = new OnAddEditableDelegateWrapper(dlg);
1256 		wrapper.handlerId = Signals.connectData(
1257 			this,
1258 			"add-editable",
1259 			cast(GCallback)&callBackAddEditable,
1260 			cast(void*)wrapper,
1261 			cast(GClosureNotify)&callBackAddEditableDestroy,
1262 			connectFlags);
1263 		return wrapper.handlerId;
1264 	}
1265 
1266 	extern(C) static void callBackAddEditable(GtkCellArea* cellareaStruct, GtkCellRenderer* renderer, GtkCellEditable* editable, GdkRectangle* cellArea, char* path, OnAddEditableDelegateWrapper wrapper)
1267 	{
1268 		wrapper.dlg(ObjectG.getDObject!(CellRenderer)(renderer), ObjectG.getDObject!(CellEditableIF)(editable), cellArea, Str.toString(path), wrapper.outer);
1269 	}
1270 
1271 	extern(C) static void callBackAddEditableDestroy(OnAddEditableDelegateWrapper wrapper, GClosure* closure)
1272 	{
1273 		wrapper.remove(wrapper);
1274 	}
1275 
1276 	protected class OnApplyAttributesDelegateWrapper
1277 	{
1278 		void delegate(TreeModelIF, TreeIter, bool, bool, CellArea) dlg;
1279 		gulong handlerId;
1280 
1281 		this(void delegate(TreeModelIF, TreeIter, bool, bool, CellArea) dlg)
1282 		{
1283 			this.dlg = dlg;
1284 			onApplyAttributesListeners ~= this;
1285 		}
1286 
1287 		void remove(OnApplyAttributesDelegateWrapper source)
1288 		{
1289 			foreach(index, wrapper; onApplyAttributesListeners)
1290 			{
1291 				if (wrapper.handlerId == source.handlerId)
1292 				{
1293 					onApplyAttributesListeners[index] = null;
1294 					onApplyAttributesListeners = std.algorithm.remove(onApplyAttributesListeners, index);
1295 					break;
1296 				}
1297 			}
1298 		}
1299 	}
1300 	OnApplyAttributesDelegateWrapper[] onApplyAttributesListeners;
1301 
1302 	/**
1303 	 * This signal is emitted whenever applying attributes to @area from @model
1304 	 *
1305 	 * Params:
1306 	 *     model = the #GtkTreeModel to apply the attributes from
1307 	 *     iter = the #GtkTreeIter indicating which row to apply the attributes of
1308 	 *     isExpander = whether the view shows children for this row
1309 	 *     isExpanded = whether the view is currently showing the children of this row
1310 	 *
1311 	 * Since: 3.0
1312 	 */
1313 	gulong addOnApplyAttributes(void delegate(TreeModelIF, TreeIter, bool, bool, CellArea) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1314 	{
1315 		auto wrapper = new OnApplyAttributesDelegateWrapper(dlg);
1316 		wrapper.handlerId = Signals.connectData(
1317 			this,
1318 			"apply-attributes",
1319 			cast(GCallback)&callBackApplyAttributes,
1320 			cast(void*)wrapper,
1321 			cast(GClosureNotify)&callBackApplyAttributesDestroy,
1322 			connectFlags);
1323 		return wrapper.handlerId;
1324 	}
1325 
1326 	extern(C) static void callBackApplyAttributes(GtkCellArea* cellareaStruct, GtkTreeModel* model, GtkTreeIter* iter, bool isExpander, bool isExpanded, OnApplyAttributesDelegateWrapper wrapper)
1327 	{
1328 		wrapper.dlg(ObjectG.getDObject!(TreeModelIF)(model), ObjectG.getDObject!(TreeIter)(iter), isExpander, isExpanded, wrapper.outer);
1329 	}
1330 
1331 	extern(C) static void callBackApplyAttributesDestroy(OnApplyAttributesDelegateWrapper wrapper, GClosure* closure)
1332 	{
1333 		wrapper.remove(wrapper);
1334 	}
1335 
1336 	protected class OnFocusChangedDelegateWrapper
1337 	{
1338 		void delegate(CellRenderer, string, CellArea) dlg;
1339 		gulong handlerId;
1340 
1341 		this(void delegate(CellRenderer, string, CellArea) dlg)
1342 		{
1343 			this.dlg = dlg;
1344 			onFocusChangedListeners ~= this;
1345 		}
1346 
1347 		void remove(OnFocusChangedDelegateWrapper source)
1348 		{
1349 			foreach(index, wrapper; onFocusChangedListeners)
1350 			{
1351 				if (wrapper.handlerId == source.handlerId)
1352 				{
1353 					onFocusChangedListeners[index] = null;
1354 					onFocusChangedListeners = std.algorithm.remove(onFocusChangedListeners, index);
1355 					break;
1356 				}
1357 			}
1358 		}
1359 	}
1360 	OnFocusChangedDelegateWrapper[] onFocusChangedListeners;
1361 
1362 	/**
1363 	 * Indicates that focus changed on this @area. This signal
1364 	 * is emitted either as a result of focus handling or event
1365 	 * handling.
1366 	 *
1367 	 * It's possible that the signal is emitted even if the
1368 	 * currently focused renderer did not change, this is
1369 	 * because focus may change to the same renderer in the
1370 	 * same cell area for a different row of data.
1371 	 *
1372 	 * Params:
1373 	 *     renderer = the #GtkCellRenderer that has focus
1374 	 *     path = the current #GtkTreePath string set for @area
1375 	 *
1376 	 * Since: 3.0
1377 	 */
1378 	gulong addOnFocusChanged(void delegate(CellRenderer, string, CellArea) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1379 	{
1380 		auto wrapper = new OnFocusChangedDelegateWrapper(dlg);
1381 		wrapper.handlerId = Signals.connectData(
1382 			this,
1383 			"focus-changed",
1384 			cast(GCallback)&callBackFocusChanged,
1385 			cast(void*)wrapper,
1386 			cast(GClosureNotify)&callBackFocusChangedDestroy,
1387 			connectFlags);
1388 		return wrapper.handlerId;
1389 	}
1390 
1391 	extern(C) static void callBackFocusChanged(GtkCellArea* cellareaStruct, GtkCellRenderer* renderer, char* path, OnFocusChangedDelegateWrapper wrapper)
1392 	{
1393 		wrapper.dlg(ObjectG.getDObject!(CellRenderer)(renderer), Str.toString(path), wrapper.outer);
1394 	}
1395 
1396 	extern(C) static void callBackFocusChangedDestroy(OnFocusChangedDelegateWrapper wrapper, GClosure* closure)
1397 	{
1398 		wrapper.remove(wrapper);
1399 	}
1400 
1401 	protected class OnRemoveEditableDelegateWrapper
1402 	{
1403 		void delegate(CellRenderer, CellEditableIF, CellArea) dlg;
1404 		gulong handlerId;
1405 
1406 		this(void delegate(CellRenderer, CellEditableIF, CellArea) dlg)
1407 		{
1408 			this.dlg = dlg;
1409 			onRemoveEditableListeners ~= this;
1410 		}
1411 
1412 		void remove(OnRemoveEditableDelegateWrapper source)
1413 		{
1414 			foreach(index, wrapper; onRemoveEditableListeners)
1415 			{
1416 				if (wrapper.handlerId == source.handlerId)
1417 				{
1418 					onRemoveEditableListeners[index] = null;
1419 					onRemoveEditableListeners = std.algorithm.remove(onRemoveEditableListeners, index);
1420 					break;
1421 				}
1422 			}
1423 		}
1424 	}
1425 	OnRemoveEditableDelegateWrapper[] onRemoveEditableListeners;
1426 
1427 	/**
1428 	 * Indicates that editing finished on @renderer and that @editable
1429 	 * should be removed from the owning cell-layouting widget.
1430 	 *
1431 	 * Params:
1432 	 *     renderer = the #GtkCellRenderer that finished editeding
1433 	 *     editable = the #GtkCellEditable widget to remove
1434 	 *
1435 	 * Since: 3.0
1436 	 */
1437 	gulong addOnRemoveEditable(void delegate(CellRenderer, CellEditableIF, CellArea) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1438 	{
1439 		auto wrapper = new OnRemoveEditableDelegateWrapper(dlg);
1440 		wrapper.handlerId = Signals.connectData(
1441 			this,
1442 			"remove-editable",
1443 			cast(GCallback)&callBackRemoveEditable,
1444 			cast(void*)wrapper,
1445 			cast(GClosureNotify)&callBackRemoveEditableDestroy,
1446 			connectFlags);
1447 		return wrapper.handlerId;
1448 	}
1449 
1450 	extern(C) static void callBackRemoveEditable(GtkCellArea* cellareaStruct, GtkCellRenderer* renderer, GtkCellEditable* editable, OnRemoveEditableDelegateWrapper wrapper)
1451 	{
1452 		wrapper.dlg(ObjectG.getDObject!(CellRenderer)(renderer), ObjectG.getDObject!(CellEditableIF)(editable), wrapper.outer);
1453 	}
1454 
1455 	extern(C) static void callBackRemoveEditableDestroy(OnRemoveEditableDelegateWrapper wrapper, GClosure* closure)
1456 	{
1457 		wrapper.remove(wrapper);
1458 	}
1459 }