3 * Copyright (C) 2010 Openismus GmbH
6 * Tristan Van Berkom <tristanvb@openismus.com>
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Library General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Library General Public License for more details.
18 * You should have received a copy of the GNU Library General Public
19 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
24 * @Short_Description: An abstract class for laying out GtkCellRenderers
27 * The #GtkCellArea is an abstract class for #GtkCellLayout widgets
28 * (also referred to as "layouting widgets") to interface with an
29 * arbitrary number of #GtkCellRenderers and interact with the user
30 * for a given #GtkTreeModel row.
32 * The cell area handles events, focus navigation, drawing and
33 * size requests and allocations for a given row of data.
35 * Usually users dont have to interact with the #GtkCellArea directly
36 * unless they are implementing a cell-layouting widget themselves.
38 * <refsect2 id="cell-area-geometry-management">
39 * <title>Requesting area sizes</title>
41 * As outlined in <link linkend="geometry-management">GtkWidget's
42 * geometry management section</link>, GTK+ uses a height-for-width
43 * geometry management system to compute the sizes of widgets and user
44 * interfaces. #GtkCellArea uses the same semantics to calculate the
45 * size of an area for an arbitrary number of #GtkTreeModel rows.
47 * When requesting the size of a cell area one needs to calculate
48 * the size for a handful of rows, and this will be done differently by
49 * different layouting widgets. For instance a #GtkTreeViewColumn
50 * always lines up the areas from top to bottom while a #GtkIconView
51 * on the other hand might enforce that all areas received the same
52 * width and wrap the areas around, requesting height for more cell
53 * areas when allocated less width.
55 * It's also important for areas to maintain some cell
56 * alignments with areas rendered for adjacent rows (cells can
57 * appear "columnized" inside an area even when the size of
58 * cells are different in each row). For this reason the #GtkCellArea
59 * uses a #GtkCellAreaContext object to store the alignments
60 * and sizes along the way (as well as the overall largest minimum
61 * and natural size for all the rows which have been calculated
62 * with the said context).
64 * The #GtkCellAreaContext is an opaque object specific to the
65 * #GtkCellArea which created it (see gtk_cell_area_create_context()).
66 * The owning cell-layouting widget can create as many contexts as
67 * it wishes to calculate sizes of rows which should receive the
68 * same size in at least one orientation (horizontally or vertically),
69 * However, it's important that the same #GtkCellAreaContext which
70 * was used to request the sizes for a given #GtkTreeModel row be
71 * used when rendering or processing events for that row.
73 * In order to request the width of all the rows at the root level
74 * of a #GtkTreeModel one would do the following:
76 * <title>Requesting the width of a handful of GtkTreeModel rows</title>
82 * valid = gtk_tree_model_get_iter_first (model, &iter);
85 * gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
86 * gtk_cell_area_get_preferred_width (area, context, widget, NULL, NULL);
88 * valid = gtk_tree_model_iter_next (model, &iter);
90 * gtk_cell_area_context_get_preferred_width (context, &minimum_width, &natural_width);
93 * Note that in this example it's not important to observe the
94 * returned minimum and natural width of the area for each row
95 * unless the cell-layouting object is actually interested in the
96 * widths of individual rows. The overall width is however stored
97 * in the accompanying #GtkCellAreaContext object and can be consulted
100 * This can be useful since #GtkCellLayout widgets usually have to
101 * support requesting and rendering rows in treemodels with an
102 * exceedingly large amount of rows. The #GtkCellLayout widget in
103 * that case would calculate the required width of the rows in an
104 * idle or timeout source (see g_timeout_add()) and when the widget
105 * is requested its actual width in #GtkWidgetClass.get_preferred_width()
106 * it can simply consult the width accumulated so far in the
107 * #GtkCellAreaContext object.
109 * A simple example where rows are rendered from top to bottom and
110 * take up the full width of the layouting widget would look like:
112 * <title>A typical get_preferred_width() implementation</title>
115 * foo_get_preferred_width (GtkWidget *widget,
116 * gint *minimum_size,
117 * gint *natural_size)
119 * Foo *foo = FOO (widget);
120 * FooPrivate *priv = foo->priv;
122 * 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);
128 * In the above example the Foo widget has to make sure that some
129 * row sizes have been calculated (the amount of rows that Foo judged
130 * was appropriate to request space for in a single timeout iteration)
131 * before simply returning the amount of space required by the area via
132 * the #GtkCellAreaContext.
134 * Requesting the height for width (or width for height) of an area is
135 * a similar task except in this case the #GtkCellAreaContext does not
136 * store the data (actually, it does not know how much space the layouting
137 * widget plans to allocate it for every row. It's up to the layouting
138 * widget to render each row of data with the appropriate height and
139 * width which was requested by the #GtkCellArea).
141 * In order to request the height for width of all the rows at the
142 * root level of a #GtkTreeModel one would do the following:
144 * <title>Requesting the height for width of a handful of GtkTreeModel rows</title>
147 * gint minimum_height;
148 * gint natural_height;
149 * gint full_minimum_height = 0;
150 * gint full_natural_height = 0;
152 * valid = gtk_tree_model_get_iter_first (model, &iter);
155 * gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
156 * gtk_cell_area_get_preferred_height_for_width (area, context, widget,
157 * width, &minimum_height, &natural_height);
159 * if (width_is_for_allocation)
160 * cache_row_height (&iter, minimum_height, natural_height);
162 * full_minimum_height += minimum_height;
163 * full_natural_height += natural_height;
165 * valid = gtk_tree_model_iter_next (model, &iter);
169 * Note that in the above example we would need to cache the heights
170 * returned for each row so that we would know what sizes to render the
171 * areas for each row. However we would only want to really cache the
172 * heights if the request is intended for the layouting widgets real
175 * In some cases the layouting widget is requested the height for an
176 * arbitrary for_width, this is a special case for layouting widgets
177 * who need to request size for tens of thousands of rows. For this
178 * case it's only important that the layouting widget calculate
179 * one reasonably sized chunk of rows and return that height
180 * synchronously. The reasoning here is that any layouting widget is
181 * at least capable of synchronously calculating enough height to fill
182 * the screen height (or scrolled window height) in response to a single
183 * call to #GtkWidgetClass.get_preferred_height_for_width(). Returning
184 * a perfect height for width that is larger than the screen area is
185 * inconsequential since after the layouting receives an allocation
186 * from a scrolled window it simply continues to drive the scrollbar
187 * values while more and more height is required for the row heights
188 * that are calculated in the background.
191 * <refsect2 id="cell-area-rendering">
192 * <title>Rendering Areas</title>
194 * Once area sizes have been aquired at least for the rows in the
195 * visible area of the layouting widget they can be rendered at
196 * #GtkWidgetClass.draw() time.
198 * A crude example of how to render all the rows at the root level
201 * <title>Requesting the width of a handful of GtkTreeModel rows</title>
203 * GtkAllocation allocation;
204 * GdkRectangle cell_area = { 0, };
206 * gint minimum_width;
207 * gint natural_width;
209 * gtk_widget_get_allocation (widget, &allocation);
210 * cell_area.width = allocation.width;
212 * valid = gtk_tree_model_get_iter_first (model, &iter);
215 * cell_area.height = get_cached_height_for_row (&iter);
217 * gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
218 * gtk_cell_area_render (area, context, widget, cr,
219 * &cell_area, &cell_area, state_flags, FALSE);
221 * cell_area.y += cell_area.height;
223 * valid = gtk_tree_model_iter_next (model, &iter);
227 * Note that the cached height in this example really depends on how
228 * the layouting widget works. The layouting widget might decide to
229 * give every row its minimum or natural height or, if the model content
230 * is expected to fit inside the layouting widget without scrolling, it
231 * would make sense to calculate the allocation for each row at
232 * #GtkWidget::size-allocate time using gtk_distribute_natural_allocation().
235 * <refsect2 id="cell-area-events-and-focus">
236 * <title>Handling Events and Driving Keyboard Focus</title>
238 * Passing events to the area is as simple as handling events on any
239 * normal widget and then passing them to the gtk_cell_area_event()
240 * API as they come in. Usually #GtkCellArea is only interested in
241 * button events, however some customized derived areas can be implemented
242 * who are interested in handling other events. Handling an event can
243 * trigger the #GtkCellArea::focus-changed signal to fire; as well as
244 * #GtkCellArea::add-editable in the case that an editable cell was
245 * clicked and needs to start editing. You can call
246 * gtk_cell_area_stop_editing() at any time to cancel any cell editing
247 * that is currently in progress.
249 * The #GtkCellArea drives keyboard focus from cell to cell in a way
250 * similar to #GtkWidget. For layouting widgets that support giving
251 * focus to cells it's important to remember to pass %GTK_CELL_RENDERER_FOCUSED
252 * to the area functions for the row that has focus and to tell the
253 * area to paint the focus at render time.
255 * Layouting widgets that accept focus on cells should implement the
256 * #GtkWidgetClass.focus() virtual method. The layouting widget is always
257 * responsible for knowing where #GtkTreeModel rows are rendered inside
258 * the widget, so at #GtkWidgetClass.focus() time the layouting widget
259 * should use the #GtkCellArea methods to navigate focus inside the area
260 * and then observe the GtkDirectionType to pass the focus to adjacent
263 * A basic example of how the #GtkWidgetClass.focus() virtual method
264 * should be implemented:
266 * <title>Implementing keyboard focus navigation</title>
269 * foo_focus (GtkWidget *widget,
270 * GtkDirectionType direction)
272 * Foo *foo = FOO (widget);
273 * FooPrivate *priv = foo->priv;
275 * gboolean have_focus = FALSE;
277 * focus_row = priv->focus_row;
279 * if (!gtk_widget_has_focus (widget))
280 * gtk_widget_grab_focus (widget);
282 * valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, priv->focus_row);
285 * gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE);
287 * if (gtk_cell_area_focus (priv->area, direction))
289 * priv->focus_row = focus_row;
295 * if (direction == GTK_DIR_RIGHT ||
296 * direction == GTK_DIR_LEFT)
298 * else if (direction == GTK_DIR_UP ||
299 * direction == GTK_DIR_TAB_BACKWARD)
301 * if (focus_row == 0)
306 * valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, focus_row);
311 * if (focus_row == last_row)
316 * valid = gtk_tree_model_iter_next (priv->model, &iter);
325 * Note that the layouting widget is responsible for matching the
326 * GtkDirectionType values to the way it lays out its cells.
329 * <refsect2 id="cell-properties">
330 * <title>Cell Properties</title>
332 * The #GtkCellArea introduces <emphasis>cell properties</emphasis>
333 * for #GtkCellRenderers in very much the same way that #GtkContainer
334 * introduces <link linkend="child-properties">child properties</link>
335 * for #GtkWidgets. This provides some general interfaces for defining
336 * the relationship cell areas have with their cells. For instance in a
337 * #GtkCellAreaBox a cell might "expand" and receive extra space when
338 * the area is allocated more than its full natural request, or a cell
339 * might be configured to "align" with adjacent rows which were requested
340 * and rendered with the same #GtkCellAreaContext.
342 * Use gtk_cell_area_class_install_cell_property() to install cell
343 * properties for a cell area class and gtk_cell_area_class_find_cell_property()
344 * or gtk_cell_area_class_list_cell_properties() to get information about
345 * existing cell properties.
347 * To set the value of a cell property, use gtk_cell_area_cell_set_property(),
348 * gtk_cell_area_cell_set() or gtk_cell_area_cell_set_valist(). To obtain
349 * the value of a cell property, use gtk_cell_area_cell_get_property(),
350 * gtk_cell_area_cell_get() or gtk_cell_area_cell_get_valist().
362 #include "gtkcelllayout.h"
363 #include "gtkcellarea.h"
364 #include "gtkcellareacontext.h"
365 #include "gtkmarshalers.h"
366 #include "gtkprivate.h"
368 #include <gobject/gvaluecollector.h>
372 static void gtk_cell_area_dispose (GObject *object);
373 static void gtk_cell_area_finalize (GObject *object);
374 static void gtk_cell_area_set_property (GObject *object,
378 static void gtk_cell_area_get_property (GObject *object,
383 /* GtkCellAreaClass */
384 static void gtk_cell_area_real_add (GtkCellArea *area,
385 GtkCellRenderer *renderer);
386 static void gtk_cell_area_real_remove (GtkCellArea *area,
387 GtkCellRenderer *renderer);
388 static void gtk_cell_area_real_foreach (GtkCellArea *area,
389 GtkCellCallback callback,
390 gpointer callback_data);
391 static void gtk_cell_area_real_foreach_alloc (GtkCellArea *area,
392 GtkCellAreaContext *context,
394 const GdkRectangle *cell_area,
395 const GdkRectangle *background_area,
396 GtkCellAllocCallback callback,
397 gpointer callback_data);
398 static gint gtk_cell_area_real_event (GtkCellArea *area,
399 GtkCellAreaContext *context,
402 const GdkRectangle *cell_area,
403 GtkCellRendererState flags);
404 static void gtk_cell_area_real_render (GtkCellArea *area,
405 GtkCellAreaContext *context,
408 const GdkRectangle *background_area,
409 const GdkRectangle *cell_area,
410 GtkCellRendererState flags,
411 gboolean paint_focus);
412 static void gtk_cell_area_real_apply_attributes (GtkCellArea *area,
413 GtkTreeModel *tree_model,
415 gboolean is_expander,
416 gboolean is_expanded);
418 static GtkCellAreaContext *gtk_cell_area_real_create_context (GtkCellArea *area);
419 static GtkCellAreaContext *gtk_cell_area_real_copy_context (GtkCellArea *area,
420 GtkCellAreaContext *context);
421 static GtkSizeRequestMode gtk_cell_area_real_get_request_mode (GtkCellArea *area);
422 static void gtk_cell_area_real_get_preferred_width (GtkCellArea *area,
423 GtkCellAreaContext *context,
426 gint *natural_width);
427 static void gtk_cell_area_real_get_preferred_height (GtkCellArea *area,
428 GtkCellAreaContext *context,
430 gint *minimum_height,
431 gint *natural_height);
432 static void gtk_cell_area_real_get_preferred_height_for_width (GtkCellArea *area,
433 GtkCellAreaContext *context,
436 gint *minimum_height,
437 gint *natural_height);
438 static void gtk_cell_area_real_get_preferred_width_for_height (GtkCellArea *area,
439 GtkCellAreaContext *context,
443 gint *natural_width);
444 static gboolean gtk_cell_area_real_is_activatable (GtkCellArea *area);
445 static gboolean gtk_cell_area_real_activate (GtkCellArea *area,
446 GtkCellAreaContext *context,
448 const GdkRectangle *cell_area,
449 GtkCellRendererState flags,
451 static gboolean gtk_cell_area_real_focus (GtkCellArea *area,
452 GtkDirectionType direction);
454 /* GtkCellLayoutIface */
455 static void gtk_cell_area_cell_layout_init (GtkCellLayoutIface *iface);
456 static void gtk_cell_area_pack_default (GtkCellLayout *cell_layout,
457 GtkCellRenderer *renderer,
459 static void gtk_cell_area_clear (GtkCellLayout *cell_layout);
460 static void gtk_cell_area_add_attribute (GtkCellLayout *cell_layout,
461 GtkCellRenderer *renderer,
462 const gchar *attribute,
464 static void gtk_cell_area_set_cell_data_func (GtkCellLayout *cell_layout,
465 GtkCellRenderer *cell,
466 GtkCellLayoutDataFunc func,
468 GDestroyNotify destroy);
469 static void gtk_cell_area_clear_attributes (GtkCellLayout *cell_layout,
470 GtkCellRenderer *renderer);
471 static void gtk_cell_area_reorder (GtkCellLayout *cell_layout,
472 GtkCellRenderer *cell,
474 static GList *gtk_cell_area_get_cells (GtkCellLayout *cell_layout);
475 static GtkCellArea *gtk_cell_area_get_area (GtkCellLayout *cell_layout);
477 /* GtkBuildableIface */
478 static void gtk_cell_area_buildable_init (GtkBuildableIface *iface);
479 static void gtk_cell_area_buildable_custom_tag_end (GtkBuildable *buildable,
482 const gchar *tagname,
485 /* Used in foreach loop to check if a child renderer is present */
487 GtkCellRenderer *renderer;
488 gboolean has_renderer;
491 /* Used in foreach loop to get a cell's allocation */
493 GtkCellRenderer *renderer;
494 GdkRectangle allocation;
495 } RendererAllocationData;
497 /* Used in foreach loop to render cells */
502 GdkRectangle focus_rect;
503 GtkCellRendererState render_flags;
504 guint paint_focus : 1;
506 guint first_focus : 1;
509 /* Used in foreach loop to get a cell by position */
513 GtkCellRenderer *renderer;
514 GdkRectangle cell_area;
515 } CellByPositionData;
517 /* Attribute/Cell metadata */
519 const gchar *attribute;
526 GtkCellLayoutDataFunc func;
528 GDestroyNotify destroy;
529 GtkCellLayout *proxy;
532 static CellInfo *cell_info_new (GtkCellLayoutDataFunc func,
534 GDestroyNotify destroy);
535 static void cell_info_free (CellInfo *info);
536 static CellAttribute *cell_attribute_new (GtkCellRenderer *renderer,
537 const gchar *attribute,
539 static void cell_attribute_free (CellAttribute *attribute);
540 static gint cell_attribute_find (CellAttribute *cell_attribute,
541 const gchar *attribute);
543 /* Internal functions/signal emissions */
544 static void gtk_cell_area_add_editable (GtkCellArea *area,
545 GtkCellRenderer *renderer,
546 GtkCellEditable *editable,
547 const GdkRectangle *cell_area);
548 static void gtk_cell_area_remove_editable (GtkCellArea *area,
549 GtkCellRenderer *renderer,
550 GtkCellEditable *editable);
551 static void gtk_cell_area_set_edit_widget (GtkCellArea *area,
552 GtkCellEditable *editable);
553 static void gtk_cell_area_set_edited_cell (GtkCellArea *area,
554 GtkCellRenderer *renderer);
557 /* Struct to pass data along while looping over
558 * cell renderers to apply attributes
564 gboolean is_expander;
565 gboolean is_expanded;
568 struct _GtkCellAreaPrivate
570 /* The GtkCellArea bookkeeps any connected
571 * attributes in this hash table.
573 GHashTable *cell_info;
575 /* Current path is saved as a side-effect
576 * of gtk_cell_area_apply_attributes()
580 /* Current cell being edited and editable widget used */
581 GtkCellEditable *edit_widget;
582 GtkCellRenderer *edited_cell;
584 /* Signal connections to the editable widget */
585 gulong remove_widget_id;
587 /* Currently focused cell */
588 GtkCellRenderer *focus_cell;
590 /* Tracking which cells are focus siblings of focusable cells */
591 GHashTable *focus_siblings;
602 SIGNAL_APPLY_ATTRIBUTES,
604 SIGNAL_REMOVE_EDITABLE,
605 SIGNAL_FOCUS_CHANGED,
609 /* Keep the paramspec pool internal, no need to deliver notifications
610 * on cells. at least no perceived need for now
612 static GParamSpecPool *cell_property_pool = NULL;
613 static guint cell_area_signals[LAST_SIGNAL] = { 0 };
615 #define PARAM_SPEC_PARAM_ID(pspec) ((pspec)->param_id)
616 #define PARAM_SPEC_SET_PARAM_ID(pspec, id) ((pspec)->param_id = (id))
618 G_DEFINE_ABSTRACT_TYPE_WITH_CODE (GtkCellArea, gtk_cell_area, G_TYPE_INITIALLY_UNOWNED,
619 G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,
620 gtk_cell_area_cell_layout_init)
621 G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
622 gtk_cell_area_buildable_init))
625 gtk_cell_area_init (GtkCellArea *area)
627 GtkCellAreaPrivate *priv;
629 area->priv = G_TYPE_INSTANCE_GET_PRIVATE (area,
634 priv->cell_info = g_hash_table_new_full (g_direct_hash,
637 (GDestroyNotify)cell_info_free);
639 priv->focus_siblings = g_hash_table_new_full (g_direct_hash,
642 (GDestroyNotify)g_list_free);
644 priv->focus_cell = NULL;
645 priv->edited_cell = NULL;
646 priv->edit_widget = NULL;
648 priv->remove_widget_id = 0;
652 gtk_cell_area_class_init (GtkCellAreaClass *class)
654 GObjectClass *object_class = G_OBJECT_CLASS (class);
657 object_class->dispose = gtk_cell_area_dispose;
658 object_class->finalize = gtk_cell_area_finalize;
659 object_class->get_property = gtk_cell_area_get_property;
660 object_class->set_property = gtk_cell_area_set_property;
663 class->add = gtk_cell_area_real_add;
664 class->remove = gtk_cell_area_real_remove;
665 class->foreach = gtk_cell_area_real_foreach;
666 class->foreach_alloc = gtk_cell_area_real_foreach_alloc;
667 class->event = gtk_cell_area_real_event;
668 class->render = gtk_cell_area_real_render;
669 class->apply_attributes = gtk_cell_area_real_apply_attributes;
672 class->create_context = gtk_cell_area_real_create_context;
673 class->copy_context = gtk_cell_area_real_copy_context;
674 class->get_request_mode = gtk_cell_area_real_get_request_mode;
675 class->get_preferred_width = gtk_cell_area_real_get_preferred_width;
676 class->get_preferred_height = gtk_cell_area_real_get_preferred_height;
677 class->get_preferred_height_for_width = gtk_cell_area_real_get_preferred_height_for_width;
678 class->get_preferred_width_for_height = gtk_cell_area_real_get_preferred_width_for_height;
681 class->is_activatable = gtk_cell_area_real_is_activatable;
682 class->activate = gtk_cell_area_real_activate;
683 class->focus = gtk_cell_area_real_focus;
687 * GtkCellArea::apply-attributes:
688 * @area: the #GtkCellArea to apply the attributes to
689 * @model: the #GtkTreeModel to apply the attributes from
690 * @iter: the #GtkTreeIter indicating which row to apply the attributes of
691 * @is_expander: whether the view shows children for this row
692 * @is_expanded: whether the view is currently showing the children of this row
694 * This signal is emitted whenever applying attributes to @area from @model
698 cell_area_signals[SIGNAL_APPLY_ATTRIBUTES] =
699 g_signal_new (I_("apply-attributes"),
700 G_OBJECT_CLASS_TYPE (object_class),
702 G_STRUCT_OFFSET (GtkCellAreaClass, apply_attributes),
704 _gtk_marshal_VOID__OBJECT_BOXED_BOOLEAN_BOOLEAN,
710 g_signal_set_va_marshaller (cell_area_signals[SIGNAL_APPLY_ATTRIBUTES], G_TYPE_FROM_CLASS (class),
711 _gtk_marshal_VOID__OBJECT_BOXED_BOOLEAN_BOOLEANv);
714 * GtkCellArea::add-editable:
715 * @area: the #GtkCellArea where editing started
716 * @renderer: the #GtkCellRenderer that started the edited
717 * @editable: the #GtkCellEditable widget to add
718 * @cell_area: the #GtkWidget relative #GdkRectangle coordinates
719 * where @editable should be added
720 * @path: the #GtkTreePath string this edit was initiated for
722 * Indicates that editing has started on @renderer and that @editable
723 * should be added to the owning cell-layouting widget at @cell_area.
727 cell_area_signals[SIGNAL_ADD_EDITABLE] =
728 g_signal_new (I_("add-editable"),
729 G_OBJECT_CLASS_TYPE (object_class),
731 0, /* No class closure here */
733 _gtk_marshal_VOID__OBJECT_OBJECT_BOXED_STRING,
735 GTK_TYPE_CELL_RENDERER,
736 GTK_TYPE_CELL_EDITABLE,
742 * GtkCellArea::remove-editable:
743 * @area: the #GtkCellArea where editing finished
744 * @renderer: the #GtkCellRenderer that finished editeding
745 * @editable: the #GtkCellEditable widget to remove
747 * Indicates that editing finished on @renderer and that @editable
748 * should be removed from the owning cell-layouting widget.
752 cell_area_signals[SIGNAL_REMOVE_EDITABLE] =
753 g_signal_new (I_("remove-editable"),
754 G_OBJECT_CLASS_TYPE (object_class),
756 0, /* No class closure here */
758 _gtk_marshal_VOID__OBJECT_OBJECT,
760 GTK_TYPE_CELL_RENDERER,
761 GTK_TYPE_CELL_EDITABLE);
764 * GtkCellArea::focus-changed:
765 * @area: the #GtkCellArea where focus changed
766 * @renderer: the #GtkCellRenderer that has focus
767 * @path: the current #GtkTreePath string set for @area
769 * Indicates that focus changed on this @area. This signal
770 * is emitted either as a result of focus handling or event
773 * It's possible that the signal is emitted even if the
774 * currently focused renderer did not change, this is
775 * because focus may change to the same renderer in the
776 * same cell area for a different row of data.
780 cell_area_signals[SIGNAL_FOCUS_CHANGED] =
781 g_signal_new (I_("focus-changed"),
782 G_OBJECT_CLASS_TYPE (object_class),
784 0, /* No class closure here */
786 _gtk_marshal_VOID__OBJECT_STRING,
788 GTK_TYPE_CELL_RENDERER,
793 * GtkCellArea:focus-cell:
795 * The cell in the area that currently has focus
799 g_object_class_install_property (object_class,
804 P_("The cell which currently has focus"),
805 GTK_TYPE_CELL_RENDERER,
806 GTK_PARAM_READWRITE));
809 * GtkCellArea:edited-cell:
811 * The cell in the area that is currently edited
813 * This property is read-only and only changes as
814 * a result of a call gtk_cell_area_activate_cell().
818 g_object_class_install_property (object_class,
823 P_("The cell which is currently being edited"),
824 GTK_TYPE_CELL_RENDERER,
828 * GtkCellArea:edit-widget:
830 * The widget currently editing the edited cell
832 * This property is read-only and only changes as
833 * a result of a call gtk_cell_area_activate_cell().
837 g_object_class_install_property (object_class,
842 P_("The widget currently editing the edited cell"),
843 GTK_TYPE_CELL_EDITABLE,
846 /* Pool for Cell Properties */
847 if (!cell_property_pool)
848 cell_property_pool = g_param_spec_pool_new (FALSE);
850 g_type_class_add_private (object_class, sizeof (GtkCellAreaPrivate));
853 /*************************************************************
855 *************************************************************/
857 cell_info_new (GtkCellLayoutDataFunc func,
859 GDestroyNotify destroy)
861 CellInfo *info = g_slice_new0 (CellInfo);
865 info->destroy = destroy;
871 cell_info_free (CellInfo *info)
874 info->destroy (info->data);
876 g_slist_foreach (info->attributes, (GFunc)cell_attribute_free, NULL);
877 g_slist_free (info->attributes);
879 g_slice_free (CellInfo, info);
882 static CellAttribute *
883 cell_attribute_new (GtkCellRenderer *renderer,
884 const gchar *attribute,
889 /* Check if the attribute really exists and point to
890 * the property string installed on the cell renderer
891 * class (dont dup the string)
893 pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (renderer), attribute);
897 CellAttribute *cell_attribute = g_slice_new (CellAttribute);
899 cell_attribute->attribute = pspec->name;
900 cell_attribute->column = column;
902 return cell_attribute;
909 cell_attribute_free (CellAttribute *attribute)
911 g_slice_free (CellAttribute, attribute);
914 /* GCompareFunc for g_slist_find_custom() */
916 cell_attribute_find (CellAttribute *cell_attribute,
917 const gchar *attribute)
919 return g_strcmp0 (cell_attribute->attribute, attribute);
922 /*************************************************************
924 *************************************************************/
926 gtk_cell_area_finalize (GObject *object)
928 GtkCellArea *area = GTK_CELL_AREA (object);
929 GtkCellAreaPrivate *priv = area->priv;
931 /* All cell renderers should already be removed at this point,
932 * just kill our (empty) hash tables here.
934 g_hash_table_destroy (priv->cell_info);
935 g_hash_table_destroy (priv->focus_siblings);
937 g_free (priv->current_path);
939 G_OBJECT_CLASS (gtk_cell_area_parent_class)->finalize (object);
944 gtk_cell_area_dispose (GObject *object)
946 /* This removes every cell renderer that may be added to the GtkCellArea,
947 * subclasses should be breaking references to the GtkCellRenderers
950 gtk_cell_layout_clear (GTK_CELL_LAYOUT (object));
952 /* Remove any ref to a focused/edited cell */
953 gtk_cell_area_set_focus_cell (GTK_CELL_AREA (object), NULL);
954 gtk_cell_area_set_edited_cell (GTK_CELL_AREA (object), NULL);
955 gtk_cell_area_set_edit_widget (GTK_CELL_AREA (object), NULL);
957 G_OBJECT_CLASS (gtk_cell_area_parent_class)->dispose (object);
961 gtk_cell_area_set_property (GObject *object,
966 GtkCellArea *area = GTK_CELL_AREA (object);
970 case PROP_FOCUS_CELL:
971 gtk_cell_area_set_focus_cell (area, (GtkCellRenderer *)g_value_get_object (value));
974 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
980 gtk_cell_area_get_property (GObject *object,
985 GtkCellArea *area = GTK_CELL_AREA (object);
986 GtkCellAreaPrivate *priv = area->priv;
990 case PROP_FOCUS_CELL:
991 g_value_set_object (value, priv->focus_cell);
993 case PROP_EDITED_CELL:
994 g_value_set_object (value, priv->edited_cell);
996 case PROP_EDIT_WIDGET:
997 g_value_set_object (value, priv->edit_widget);
1000 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1005 /*************************************************************
1006 * GtkCellAreaClass *
1007 *************************************************************/
1009 gtk_cell_area_real_add (GtkCellArea *area,
1010 GtkCellRenderer *renderer)
1012 g_warning ("GtkCellAreaClass::add not implemented for `%s'",
1013 g_type_name (G_TYPE_FROM_INSTANCE (area)));
1017 gtk_cell_area_real_remove (GtkCellArea *area,
1018 GtkCellRenderer *renderer)
1020 g_warning ("GtkCellAreaClass::remove not implemented for `%s'",
1021 g_type_name (G_TYPE_FROM_INSTANCE (area)));
1025 gtk_cell_area_real_foreach (GtkCellArea *area,
1026 GtkCellCallback callback,
1027 gpointer callback_data)
1029 g_warning ("GtkCellAreaClass::foreach not implemented for `%s'",
1030 g_type_name (G_TYPE_FROM_INSTANCE (area)));
1034 gtk_cell_area_real_foreach_alloc (GtkCellArea *area,
1035 GtkCellAreaContext *context,
1037 const GdkRectangle *cell_area,
1038 const GdkRectangle *background_area,
1039 GtkCellAllocCallback callback,
1040 gpointer callback_data)
1042 g_warning ("GtkCellAreaClass::foreach_alloc not implemented for `%s'",
1043 g_type_name (G_TYPE_FROM_INSTANCE (area)));
1047 gtk_cell_area_real_event (GtkCellArea *area,
1048 GtkCellAreaContext *context,
1051 const GdkRectangle *cell_area,
1052 GtkCellRendererState flags)
1054 GtkCellAreaPrivate *priv = area->priv;
1055 gboolean retval = FALSE;
1057 if (event->type == GDK_KEY_PRESS && (flags & GTK_CELL_RENDERER_FOCUSED) != 0)
1059 GdkEventKey *key_event = (GdkEventKey *)event;
1061 /* Cancel any edits in progress */
1062 if (priv->edited_cell && (key_event->keyval == GDK_KEY_Escape))
1064 gtk_cell_area_stop_editing (area, TRUE);
1068 else if (event->type == GDK_BUTTON_PRESS)
1070 GdkEventButton *button_event = (GdkEventButton *)event;
1072 if (button_event->button == GDK_BUTTON_PRIMARY)
1074 GtkCellRenderer *renderer = NULL;
1075 GtkCellRenderer *focus_renderer;
1076 GdkRectangle alloc_area;
1077 gint event_x, event_y;
1079 /* We may need some semantics to tell us the offset of the event
1080 * window we are handling events for (i.e. GtkTreeView has a bin_window) */
1081 event_x = button_event->x;
1082 event_y = button_event->y;
1084 /* Dont try to search for an event coordinate that is not in the area, that will
1085 * trigger a runtime warning.
1087 if (event_x >= cell_area->x && event_x <= cell_area->x + cell_area->width &&
1088 event_y >= cell_area->y && event_y <= cell_area->y + cell_area->height)
1090 gtk_cell_area_get_cell_at_position (area, context, widget,
1091 cell_area, event_x, event_y,
1096 focus_renderer = gtk_cell_area_get_focus_from_sibling (area, renderer);
1097 if (!focus_renderer)
1098 focus_renderer = renderer;
1100 /* If we're already editing, cancel it and set focus */
1101 if (gtk_cell_area_get_edited_cell (area))
1103 /* XXX Was it really canceled in this case ? */
1104 gtk_cell_area_stop_editing (area, TRUE);
1105 gtk_cell_area_set_focus_cell (area, focus_renderer);
1110 /* If we are activating via a focus sibling,
1111 * we need to fetch the right cell area for the real event renderer */
1112 if (focus_renderer != renderer)
1113 gtk_cell_area_get_cell_allocation (area, context, widget, focus_renderer,
1114 cell_area, &alloc_area);
1116 gtk_cell_area_set_focus_cell (area, focus_renderer);
1117 retval = gtk_cell_area_activate_cell (area, widget, focus_renderer,
1118 event, &alloc_area, flags);
1128 render_cell (GtkCellRenderer *renderer,
1129 const GdkRectangle *cell_area,
1130 const GdkRectangle *cell_background,
1131 CellRenderData *data)
1133 GtkCellRenderer *focus_cell;
1134 GtkCellRendererState flags;
1135 GdkRectangle inner_area;
1137 focus_cell = gtk_cell_area_get_focus_cell (data->area);
1138 flags = data->render_flags;
1140 gtk_cell_area_inner_cell_area (data->area, data->widget, cell_area, &inner_area);
1142 if ((flags & GTK_CELL_RENDERER_FOCUSED) &&
1145 (renderer == focus_cell ||
1146 gtk_cell_area_is_focus_sibling (data->area, focus_cell, renderer)))))
1148 gint focus_line_width;
1149 GdkRectangle cell_focus;
1151 gtk_cell_renderer_get_aligned_area (renderer, data->widget, flags, &inner_area, &cell_focus);
1153 gtk_widget_style_get (data->widget,
1154 "focus-line-width", &focus_line_width,
1157 /* The focus rectangle is located around the aligned area of the cell */
1158 cell_focus.x -= focus_line_width;
1159 cell_focus.y -= focus_line_width;
1160 cell_focus.width += 2 * focus_line_width;
1161 cell_focus.height += 2 * focus_line_width;
1163 if (data->first_focus)
1165 data->first_focus = FALSE;
1166 data->focus_rect = cell_focus;
1170 gdk_rectangle_union (&data->focus_rect, &cell_focus, &data->focus_rect);
1174 gtk_cell_renderer_render (renderer, data->cr, data->widget,
1175 cell_background, &inner_area, flags);
1181 gtk_cell_area_real_render (GtkCellArea *area,
1182 GtkCellAreaContext *context,
1185 const GdkRectangle *background_area,
1186 const GdkRectangle *cell_area,
1187 GtkCellRendererState flags,
1188 gboolean paint_focus)
1190 CellRenderData render_data =
1201 /* Make sure we dont paint a focus rectangle while there
1202 * is an editable widget in play
1204 if (gtk_cell_area_get_edited_cell (area))
1205 render_data.paint_focus = FALSE;
1207 if (!gtk_widget_has_visible_focus (widget))
1208 render_data.paint_focus = FALSE;
1210 /* If no cell can activate but the caller wants focus painted,
1211 * then we paint focus around all cells */
1212 if ((flags & GTK_CELL_RENDERER_FOCUSED) != 0 && paint_focus &&
1213 !gtk_cell_area_is_activatable (area))
1214 render_data.focus_all = TRUE;
1216 gtk_cell_area_foreach_alloc (area, context, widget, cell_area, background_area,
1217 (GtkCellAllocCallback)render_cell, &render_data);
1219 if (render_data.paint_focus &&
1220 render_data.focus_rect.width != 0 &&
1221 render_data.focus_rect.height != 0)
1223 GtkStyleContext *style_context;
1224 GtkStateFlags renderer_state = 0;
1226 style_context = gtk_widget_get_style_context (widget);
1227 gtk_style_context_save (style_context);
1229 renderer_state = gtk_cell_renderer_get_state (NULL, widget, flags);
1230 gtk_style_context_set_state (style_context, renderer_state);
1234 gdk_cairo_rectangle (cr, background_area);
1237 gtk_render_focus (style_context, cr,
1238 render_data.focus_rect.x, render_data.focus_rect.y,
1239 render_data.focus_rect.width, render_data.focus_rect.height);
1241 gtk_style_context_restore (style_context);
1247 apply_cell_attributes (GtkCellRenderer *renderer,
1249 AttributeData *data)
1251 CellAttribute *attribute;
1253 GValue value = G_VALUE_INIT;
1254 gboolean is_expander;
1255 gboolean is_expanded;
1257 g_object_freeze_notify (G_OBJECT (renderer));
1259 /* Whether a row expands or is presently expanded can only be
1260 * provided by the view (as these states can vary across views
1261 * accessing the same model).
1263 g_object_get (renderer, "is-expander", &is_expander, NULL);
1264 if (is_expander != data->is_expander)
1265 g_object_set (renderer, "is-expander", data->is_expander, NULL);
1267 g_object_get (renderer, "is-expanded", &is_expanded, NULL);
1268 if (is_expanded != data->is_expanded)
1269 g_object_set (renderer, "is-expanded", data->is_expanded, NULL);
1271 /* Apply the attributes directly to the renderer */
1272 for (list = info->attributes; list; list = list->next)
1274 attribute = list->data;
1276 gtk_tree_model_get_value (data->model, data->iter, attribute->column, &value);
1277 g_object_set_property (G_OBJECT (renderer), attribute->attribute, &value);
1278 g_value_unset (&value);
1281 /* Call any GtkCellLayoutDataFunc that may have been set by the user
1284 info->func (info->proxy ? info->proxy : GTK_CELL_LAYOUT (data->area), renderer,
1285 data->model, data->iter, info->data);
1287 g_object_thaw_notify (G_OBJECT (renderer));
1291 gtk_cell_area_real_apply_attributes (GtkCellArea *area,
1292 GtkTreeModel *tree_model,
1294 gboolean is_expander,
1295 gboolean is_expanded)
1298 GtkCellAreaPrivate *priv;
1304 /* Feed in data needed to apply to every renderer */
1306 data.model = tree_model;
1308 data.is_expander = is_expander;
1309 data.is_expanded = is_expanded;
1311 /* Go over any cells that have attributes or custom GtkCellLayoutDataFuncs and
1312 * apply the data from the treemodel */
1313 g_hash_table_foreach (priv->cell_info, (GHFunc)apply_cell_attributes, &data);
1315 /* Update the currently applied path */
1316 g_free (priv->current_path);
1317 path = gtk_tree_model_get_path (tree_model, iter);
1318 priv->current_path = gtk_tree_path_to_string (path);
1319 gtk_tree_path_free (path);
1322 static GtkCellAreaContext *
1323 gtk_cell_area_real_create_context (GtkCellArea *area)
1325 g_warning ("GtkCellAreaClass::create_context not implemented for `%s'",
1326 g_type_name (G_TYPE_FROM_INSTANCE (area)));
1331 static GtkCellAreaContext *
1332 gtk_cell_area_real_copy_context (GtkCellArea *area,
1333 GtkCellAreaContext *context)
1335 g_warning ("GtkCellAreaClass::copy_context not implemented for `%s'",
1336 g_type_name (G_TYPE_FROM_INSTANCE (area)));
1341 static GtkSizeRequestMode
1342 gtk_cell_area_real_get_request_mode (GtkCellArea *area)
1344 /* By default cell areas are height-for-width. */
1345 return GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH;
1349 gtk_cell_area_real_get_preferred_width (GtkCellArea *area,
1350 GtkCellAreaContext *context,
1352 gint *minimum_width,
1353 gint *natural_width)
1355 g_warning ("GtkCellAreaClass::get_preferred_width not implemented for `%s'",
1356 g_type_name (G_TYPE_FROM_INSTANCE (area)));
1360 gtk_cell_area_real_get_preferred_height (GtkCellArea *area,
1361 GtkCellAreaContext *context,
1363 gint *minimum_height,
1364 gint *natural_height)
1366 g_warning ("GtkCellAreaClass::get_preferred_height not implemented for `%s'",
1367 g_type_name (G_TYPE_FROM_INSTANCE (area)));
1371 gtk_cell_area_real_get_preferred_height_for_width (GtkCellArea *area,
1372 GtkCellAreaContext *context,
1375 gint *minimum_height,
1376 gint *natural_height)
1378 /* If the area doesnt do height-for-width, fallback on base preferred height */
1379 GTK_CELL_AREA_GET_CLASS (area)->get_preferred_height (area, context, widget, minimum_height, natural_height);
1383 gtk_cell_area_real_get_preferred_width_for_height (GtkCellArea *area,
1384 GtkCellAreaContext *context,
1387 gint *minimum_width,
1388 gint *natural_width)
1390 /* If the area doesnt do width-for-height, fallback on base preferred width */
1391 GTK_CELL_AREA_GET_CLASS (area)->get_preferred_width (area, context, widget, minimum_width, natural_width);
1395 get_is_activatable (GtkCellRenderer *renderer,
1396 gboolean *activatable)
1399 if (gtk_cell_renderer_is_activatable (renderer))
1400 *activatable = TRUE;
1402 return *activatable;
1406 gtk_cell_area_real_is_activatable (GtkCellArea *area)
1408 gboolean activatable = FALSE;
1410 /* Checks if any renderer can focus for the currently applied
1413 * Subclasses can override this in the case that they are also
1414 * rendering widgets as well as renderers.
1416 gtk_cell_area_foreach (area, (GtkCellCallback)get_is_activatable, &activatable);
1422 gtk_cell_area_real_activate (GtkCellArea *area,
1423 GtkCellAreaContext *context,
1425 const GdkRectangle *cell_area,
1426 GtkCellRendererState flags,
1429 GtkCellAreaPrivate *priv = area->priv;
1430 GdkRectangle renderer_area;
1431 GtkCellRenderer *activate_cell = NULL;
1432 GtkCellRendererMode mode;
1434 if (priv->focus_cell)
1436 g_object_get (priv->focus_cell, "mode", &mode, NULL);
1438 if (gtk_cell_renderer_get_visible (priv->focus_cell) &&
1439 (edit_only ? mode == GTK_CELL_RENDERER_MODE_EDITABLE :
1440 mode != GTK_CELL_RENDERER_MODE_INERT))
1441 activate_cell = priv->focus_cell;
1447 /* GtkTreeView sometimes wants to activate a cell when no
1448 * cells are in focus.
1450 cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (area));
1451 for (l = cells; l && !activate_cell; l = l->next)
1453 GtkCellRenderer *renderer = l->data;
1455 g_object_get (renderer, "mode", &mode, NULL);
1457 if (gtk_cell_renderer_get_visible (renderer) &&
1458 (edit_only ? mode == GTK_CELL_RENDERER_MODE_EDITABLE :
1459 mode != GTK_CELL_RENDERER_MODE_INERT))
1460 activate_cell = renderer;
1462 g_list_free (cells);
1467 /* Get the allocation of the focused cell.
1469 gtk_cell_area_get_cell_allocation (area, context, widget, activate_cell,
1470 cell_area, &renderer_area);
1472 /* Activate or Edit the cell
1474 * Currently just not sending an event, renderers afaics dont use
1475 * the event argument anyway, worst case is we can synthesize one.
1477 if (gtk_cell_area_activate_cell (area, widget, activate_cell, NULL,
1478 &renderer_area, flags))
1486 gtk_cell_area_real_focus (GtkCellArea *area,
1487 GtkDirectionType direction)
1489 g_warning ("GtkCellAreaClass::focus not implemented for `%s'",
1490 g_type_name (G_TYPE_FROM_INSTANCE (area)));
1494 /*************************************************************
1495 * GtkCellLayoutIface *
1496 *************************************************************/
1498 gtk_cell_area_cell_layout_init (GtkCellLayoutIface *iface)
1500 iface->pack_start = gtk_cell_area_pack_default;
1501 iface->pack_end = gtk_cell_area_pack_default;
1502 iface->clear = gtk_cell_area_clear;
1503 iface->add_attribute = gtk_cell_area_add_attribute;
1504 iface->set_cell_data_func = gtk_cell_area_set_cell_data_func;
1505 iface->clear_attributes = gtk_cell_area_clear_attributes;
1506 iface->reorder = gtk_cell_area_reorder;
1507 iface->get_cells = gtk_cell_area_get_cells;
1508 iface->get_area = gtk_cell_area_get_area;
1512 gtk_cell_area_pack_default (GtkCellLayout *cell_layout,
1513 GtkCellRenderer *renderer,
1516 gtk_cell_area_add (GTK_CELL_AREA (cell_layout), renderer);
1520 gtk_cell_area_clear (GtkCellLayout *cell_layout)
1522 GtkCellArea *area = GTK_CELL_AREA (cell_layout);
1524 gtk_cell_layout_get_cells (cell_layout);
1526 for (l = cells; l; l = l->next)
1528 GtkCellRenderer *renderer = l->data;
1529 gtk_cell_area_remove (area, renderer);
1532 g_list_free (cells);
1536 gtk_cell_area_add_attribute (GtkCellLayout *cell_layout,
1537 GtkCellRenderer *renderer,
1538 const gchar *attribute,
1541 gtk_cell_area_attribute_connect (GTK_CELL_AREA (cell_layout),
1542 renderer, attribute, column);
1546 gtk_cell_area_set_cell_data_func (GtkCellLayout *cell_layout,
1547 GtkCellRenderer *renderer,
1548 GtkCellLayoutDataFunc func,
1550 GDestroyNotify destroy)
1552 GtkCellArea *area = GTK_CELL_AREA (cell_layout);
1554 _gtk_cell_area_set_cell_data_func_with_proxy (area, renderer, (GFunc)func, func_data, destroy, NULL);
1558 gtk_cell_area_clear_attributes (GtkCellLayout *cell_layout,
1559 GtkCellRenderer *renderer)
1561 GtkCellArea *area = GTK_CELL_AREA (cell_layout);
1562 GtkCellAreaPrivate *priv = area->priv;
1565 info = g_hash_table_lookup (priv->cell_info, renderer);
1569 g_slist_foreach (info->attributes, (GFunc)cell_attribute_free, NULL);
1570 g_slist_free (info->attributes);
1572 info->attributes = NULL;
1577 gtk_cell_area_reorder (GtkCellLayout *cell_layout,
1578 GtkCellRenderer *cell,
1581 g_warning ("GtkCellLayout::reorder not implemented for `%s'",
1582 g_type_name (G_TYPE_FROM_INSTANCE (cell_layout)));
1586 accum_cells (GtkCellRenderer *renderer,
1589 *accum = g_list_prepend (*accum, renderer);
1595 gtk_cell_area_get_cells (GtkCellLayout *cell_layout)
1597 GList *cells = NULL;
1599 gtk_cell_area_foreach (GTK_CELL_AREA (cell_layout),
1600 (GtkCellCallback)accum_cells,
1603 return g_list_reverse (cells);
1606 static GtkCellArea *
1607 gtk_cell_area_get_area (GtkCellLayout *cell_layout)
1609 return GTK_CELL_AREA (cell_layout);
1612 /*************************************************************
1613 * GtkBuildableIface *
1614 *************************************************************/
1616 gtk_cell_area_buildable_init (GtkBuildableIface *iface)
1618 iface->add_child = _gtk_cell_layout_buildable_add_child;
1619 iface->custom_tag_start = _gtk_cell_layout_buildable_custom_tag_start;
1620 iface->custom_tag_end = gtk_cell_area_buildable_custom_tag_end;
1624 gtk_cell_area_buildable_custom_tag_end (GtkBuildable *buildable,
1625 GtkBuilder *builder,
1627 const gchar *tagname,
1630 /* Just ignore the boolean return from here */
1631 _gtk_cell_layout_buildable_custom_tag_end (buildable, builder, child, tagname, data);
1634 /*************************************************************
1636 *************************************************************/
1639 * gtk_cell_area_add:
1640 * @area: a #GtkCellArea
1641 * @renderer: the #GtkCellRenderer to add to @area
1643 * Adds @renderer to @area with the default child cell properties.
1648 gtk_cell_area_add (GtkCellArea *area,
1649 GtkCellRenderer *renderer)
1651 g_return_if_fail (GTK_IS_CELL_AREA (area));
1652 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
1654 GTK_CELL_AREA_GET_CLASS (area)->add (area, renderer);
1658 * gtk_cell_area_remove:
1659 * @area: a #GtkCellArea
1660 * @renderer: the #GtkCellRenderer to remove from @area
1662 * Removes @renderer from @area.
1667 gtk_cell_area_remove (GtkCellArea *area,
1668 GtkCellRenderer *renderer)
1670 GtkCellAreaPrivate *priv;
1671 GList *renderers, *l;
1673 g_return_if_fail (GTK_IS_CELL_AREA (area));
1674 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
1678 /* Remove any custom attributes and custom cell data func here first */
1679 g_hash_table_remove (priv->cell_info, renderer);
1681 /* Remove focus siblings of this renderer */
1682 g_hash_table_remove (priv->focus_siblings, renderer);
1684 /* Remove this renderer from any focus renderer's sibling list */
1685 renderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (area));
1687 for (l = renderers; l; l = l->next)
1689 GtkCellRenderer *focus_renderer = l->data;
1691 if (gtk_cell_area_is_focus_sibling (area, focus_renderer, renderer))
1693 gtk_cell_area_remove_focus_sibling (area, focus_renderer, renderer);
1698 g_list_free (renderers);
1700 GTK_CELL_AREA_GET_CLASS (area)->remove (area, renderer);
1704 get_has_renderer (GtkCellRenderer *renderer,
1705 HasRendererCheck *check)
1707 if (renderer == check->renderer)
1708 check->has_renderer = TRUE;
1710 return check->has_renderer;
1714 * gtk_cell_area_has_renderer:
1715 * @area: a #GtkCellArea
1716 * @renderer: the #GtkCellRenderer to check
1718 * Checks if @area contains @renderer.
1720 * Return value: %TRUE if @renderer is in the @area.
1725 gtk_cell_area_has_renderer (GtkCellArea *area,
1726 GtkCellRenderer *renderer)
1728 HasRendererCheck check = { renderer, FALSE };
1730 g_return_val_if_fail (GTK_IS_CELL_AREA (area), FALSE);
1731 g_return_val_if_fail (GTK_IS_CELL_RENDERER (renderer), FALSE);
1733 gtk_cell_area_foreach (area, (GtkCellCallback)get_has_renderer, &check);
1735 return check.has_renderer;
1739 * gtk_cell_area_foreach:
1740 * @area: a #GtkCellArea
1741 * @callback: (scope call): the #GtkCellCallback to call
1742 * @callback_data: user provided data pointer
1744 * Calls @callback for every #GtkCellRenderer in @area.
1749 gtk_cell_area_foreach (GtkCellArea *area,
1750 GtkCellCallback callback,
1751 gpointer callback_data)
1753 g_return_if_fail (GTK_IS_CELL_AREA (area));
1754 g_return_if_fail (callback != NULL);
1756 GTK_CELL_AREA_GET_CLASS (area)->foreach (area, callback, callback_data);
1760 * gtk_cell_area_foreach_alloc:
1761 * @area: a #GtkCellArea
1762 * @context: the #GtkCellAreaContext for this row of data.
1763 * @widget: the #GtkWidget that @area is rendering to
1764 * @cell_area: the @widget relative coordinates and size for @area
1765 * @background_area: the @widget relative coordinates of the background area
1766 * @callback: (scope call): the #GtkCellAllocCallback to call
1767 * @callback_data: user provided data pointer
1769 * Calls @callback for every #GtkCellRenderer in @area with the
1770 * allocated rectangle inside @cell_area.
1775 gtk_cell_area_foreach_alloc (GtkCellArea *area,
1776 GtkCellAreaContext *context,
1778 const GdkRectangle *cell_area,
1779 const GdkRectangle *background_area,
1780 GtkCellAllocCallback callback,
1781 gpointer callback_data)
1783 g_return_if_fail (GTK_IS_CELL_AREA (area));
1784 g_return_if_fail (GTK_IS_CELL_AREA_CONTEXT (context));
1785 g_return_if_fail (GTK_IS_WIDGET (widget));
1786 g_return_if_fail (cell_area != NULL);
1787 g_return_if_fail (callback != NULL);
1789 GTK_CELL_AREA_GET_CLASS (area)->foreach_alloc (area, context, widget,
1790 cell_area, background_area,
1791 callback, callback_data);
1795 * gtk_cell_area_event:
1796 * @area: a #GtkCellArea
1797 * @context: the #GtkCellAreaContext for this row of data.
1798 * @widget: the #GtkWidget that @area is rendering to
1799 * @event: the #GdkEvent to handle
1800 * @cell_area: the @widget relative coordinates for @area
1801 * @flags: the #GtkCellRendererState for @area in this row.
1803 * Delegates event handling to a #GtkCellArea.
1805 * Return value: %TRUE if the event was handled by @area.
1810 gtk_cell_area_event (GtkCellArea *area,
1811 GtkCellAreaContext *context,
1814 const GdkRectangle *cell_area,
1815 GtkCellRendererState flags)
1817 GtkCellAreaClass *class;
1819 g_return_val_if_fail (GTK_IS_CELL_AREA (area), 0);
1820 g_return_val_if_fail (GTK_IS_CELL_AREA_CONTEXT (context), 0);
1821 g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
1822 g_return_val_if_fail (event != NULL, 0);
1823 g_return_val_if_fail (cell_area != NULL, 0);
1825 class = GTK_CELL_AREA_GET_CLASS (area);
1828 return class->event (area, context, widget, event, cell_area, flags);
1830 g_warning ("GtkCellAreaClass::event not implemented for `%s'",
1831 g_type_name (G_TYPE_FROM_INSTANCE (area)));
1836 * gtk_cell_area_render:
1837 * @area: a #GtkCellArea
1838 * @context: the #GtkCellAreaContext for this row of data.
1839 * @widget: the #GtkWidget that @area is rendering to
1840 * @cr: the #cairo_t to render with
1841 * @background_area: the @widget relative coordinates for @area's background
1842 * @cell_area: the @widget relative coordinates for @area
1843 * @flags: the #GtkCellRendererState for @area in this row.
1844 * @paint_focus: whether @area should paint focus on focused cells for focused rows or not.
1846 * Renders @area's cells according to @area's layout onto @widget at
1847 * the given coordinates.
1852 gtk_cell_area_render (GtkCellArea *area,
1853 GtkCellAreaContext *context,
1856 const GdkRectangle *background_area,
1857 const GdkRectangle *cell_area,
1858 GtkCellRendererState flags,
1859 gboolean paint_focus)
1861 GtkCellAreaClass *class;
1863 g_return_if_fail (GTK_IS_CELL_AREA (area));
1864 g_return_if_fail (GTK_IS_CELL_AREA_CONTEXT (context));
1865 g_return_if_fail (GTK_IS_WIDGET (widget));
1866 g_return_if_fail (cr != NULL);
1867 g_return_if_fail (background_area != NULL);
1868 g_return_if_fail (cell_area != NULL);
1870 class = GTK_CELL_AREA_GET_CLASS (area);
1873 class->render (area, context, widget, cr, background_area, cell_area, flags, paint_focus);
1875 g_warning ("GtkCellAreaClass::render not implemented for `%s'",
1876 g_type_name (G_TYPE_FROM_INSTANCE (area)));
1880 get_cell_allocation (GtkCellRenderer *renderer,
1881 const GdkRectangle *cell_area,
1882 const GdkRectangle *cell_background,
1883 RendererAllocationData *data)
1885 if (data->renderer == renderer)
1886 data->allocation = *cell_area;
1888 return (data->renderer == renderer);
1892 * gtk_cell_area_get_cell_allocation:
1893 * @area: a #GtkCellArea
1894 * @context: the #GtkCellAreaContext used to hold sizes for @area.
1895 * @widget: the #GtkWidget that @area is rendering on
1896 * @renderer: the #GtkCellRenderer to get the allocation for
1897 * @cell_area: the whole allocated area for @area in @widget
1899 * @allocation: (out): where to store the allocation for @renderer
1901 * Derives the allocation of @renderer inside @area if @area
1902 * were to be renderered in @cell_area.
1907 gtk_cell_area_get_cell_allocation (GtkCellArea *area,
1908 GtkCellAreaContext *context,
1910 GtkCellRenderer *renderer,
1911 const GdkRectangle *cell_area,
1912 GdkRectangle *allocation)
1914 RendererAllocationData data = { renderer, { 0, } };
1916 g_return_if_fail (GTK_IS_CELL_AREA (area));
1917 g_return_if_fail (GTK_IS_CELL_AREA_CONTEXT (context));
1918 g_return_if_fail (GTK_IS_WIDGET (widget));
1919 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
1920 g_return_if_fail (cell_area != NULL);
1921 g_return_if_fail (allocation != NULL);
1923 gtk_cell_area_foreach_alloc (area, context, widget, cell_area, cell_area,
1924 (GtkCellAllocCallback)get_cell_allocation, &data);
1926 *allocation = data.allocation;
1930 get_cell_by_position (GtkCellRenderer *renderer,
1931 const GdkRectangle *cell_area,
1932 const GdkRectangle *cell_background,
1933 CellByPositionData *data)
1935 if (data->x >= cell_area->x && data->x < cell_area->x + cell_area->width &&
1936 data->y >= cell_area->y && data->y < cell_area->y + cell_area->height)
1938 data->renderer = renderer;
1939 data->cell_area = *cell_area;
1942 return (data->renderer != NULL);
1946 * gtk_cell_area_get_cell_at_position:
1947 * @area: a #GtkCellArea
1948 * @context: the #GtkCellAreaContext used to hold sizes for @area.
1949 * @widget: the #GtkWidget that @area is rendering on
1950 * @cell_area: the whole allocated area for @area in @widget
1952 * @x: the x position
1953 * @y: the y position
1954 * @alloc_area: (out) (allow-none): where to store the inner allocated area of the
1955 * returned cell renderer, or %NULL.
1957 * Gets the #GtkCellRenderer at @x and @y coordinates inside @area and optionally
1958 * returns the full cell allocation for it inside @cell_area.
1960 * Return value: (transfer none): the #GtkCellRenderer at @x and @y.
1965 gtk_cell_area_get_cell_at_position (GtkCellArea *area,
1966 GtkCellAreaContext *context,
1968 const GdkRectangle *cell_area,
1971 GdkRectangle *alloc_area)
1973 CellByPositionData data = { x, y, NULL, { 0, } };
1975 g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
1976 g_return_val_if_fail (GTK_IS_CELL_AREA_CONTEXT (context), NULL);
1977 g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
1978 g_return_val_if_fail (cell_area != NULL, NULL);
1979 g_return_val_if_fail (x >= cell_area->x && x <= cell_area->x + cell_area->width, NULL);
1980 g_return_val_if_fail (y >= cell_area->y && y <= cell_area->y + cell_area->height, NULL);
1982 gtk_cell_area_foreach_alloc (area, context, widget, cell_area, cell_area,
1983 (GtkCellAllocCallback)get_cell_by_position, &data);
1986 *alloc_area = data.cell_area;
1988 return data.renderer;
1991 /*************************************************************
1993 *************************************************************/
1995 * gtk_cell_area_create_context:
1996 * @area: a #GtkCellArea
1998 * Creates a #GtkCellAreaContext to be used with @area for
1999 * all purposes. #GtkCellAreaContext stores geometry information
2000 * for rows for which it was operated on, it is important to use
2001 * the same context for the same row of data at all times (i.e.
2002 * one should render and handle events with the same #GtkCellAreaContext
2003 * which was used to request the size of those rows of data).
2005 * Return value: (transfer full): a newly created #GtkCellAreaContext which can be used with @area.
2009 GtkCellAreaContext *
2010 gtk_cell_area_create_context (GtkCellArea *area)
2012 g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
2014 return GTK_CELL_AREA_GET_CLASS (area)->create_context (area);
2018 * gtk_cell_area_copy_context:
2019 * @area: a #GtkCellArea
2020 * @context: the #GtkCellAreaContext to copy
2022 * This is sometimes needed for cases where rows need to share
2023 * alignments in one orientation but may be separately grouped
2024 * in the opposing orientation.
2026 * For instance, #GtkIconView creates all icons (rows) to have
2027 * the same width and the cells theirin to have the same
2028 * horizontal alignments. However each row of icons may have
2029 * a separate collective height. #GtkIconView uses this to
2030 * request the heights of each row based on a context which
2031 * was already used to request all the row widths that are
2034 * Return value: (transfer full): a newly created #GtkCellAreaContext copy of @context.
2038 GtkCellAreaContext *
2039 gtk_cell_area_copy_context (GtkCellArea *area,
2040 GtkCellAreaContext *context)
2042 g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
2043 g_return_val_if_fail (GTK_IS_CELL_AREA_CONTEXT (context), NULL);
2045 return GTK_CELL_AREA_GET_CLASS (area)->copy_context (area, context);
2049 * gtk_cell_area_get_request_mode:
2050 * @area: a #GtkCellArea
2052 * Gets whether the area prefers a height-for-width layout
2053 * or a width-for-height layout.
2055 * Return value: The #GtkSizeRequestMode preferred by @area.
2060 gtk_cell_area_get_request_mode (GtkCellArea *area)
2062 g_return_val_if_fail (GTK_IS_CELL_AREA (area),
2063 GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH);
2065 return GTK_CELL_AREA_GET_CLASS (area)->get_request_mode (area);
2069 * gtk_cell_area_get_preferred_width:
2070 * @area: a #GtkCellArea
2071 * @context: the #GtkCellAreaContext to perform this request with
2072 * @widget: the #GtkWidget where @area will be rendering
2073 * @minimum_width: (out) (allow-none): location to store the minimum width, or %NULL
2074 * @natural_width: (out) (allow-none): location to store the natural width, or %NULL
2076 * Retrieves a cell area's initial minimum and natural width.
2078 * @area will store some geometrical information in @context along the way,
2079 * when requesting sizes over an arbitrary number of rows, its not important
2080 * to check the @minimum_width and @natural_width of this call but rather to
2081 * consult gtk_cell_area_context_get_preferred_width() after a series of
2087 gtk_cell_area_get_preferred_width (GtkCellArea *area,
2088 GtkCellAreaContext *context,
2090 gint *minimum_width,
2091 gint *natural_width)
2093 g_return_if_fail (GTK_IS_CELL_AREA (area));
2094 g_return_if_fail (GTK_IS_WIDGET (widget));
2096 GTK_CELL_AREA_GET_CLASS (area)->get_preferred_width (area, context, widget,
2097 minimum_width, natural_width);
2101 * gtk_cell_area_get_preferred_height_for_width:
2102 * @area: a #GtkCellArea
2103 * @context: the #GtkCellAreaContext which has already been requested for widths.
2104 * @widget: the #GtkWidget where @area will be rendering
2105 * @width: the width for which to check the height of this area
2106 * @minimum_height: (out) (allow-none): location to store the minimum height, or %NULL
2107 * @natural_height: (out) (allow-none): location to store the natural height, or %NULL
2109 * Retrieves a cell area's minimum and natural height if it would be given
2110 * the specified @width.
2112 * @area stores some geometrical information in @context along the way
2113 * while calling gtk_cell_area_get_preferred_width(). It's important to
2114 * perform a series of gtk_cell_area_get_preferred_width() requests with
2115 * @context first and then call gtk_cell_area_get_preferred_height_for_width()
2116 * on each cell area individually to get the height for width of each
2117 * fully requested row.
2119 * If at some point, the width of a single row changes, it should be
2120 * requested with gtk_cell_area_get_preferred_width() again and then
2121 * the full width of the requested rows checked again with
2122 * gtk_cell_area_context_get_preferred_width().
2127 gtk_cell_area_get_preferred_height_for_width (GtkCellArea *area,
2128 GtkCellAreaContext *context,
2131 gint *minimum_height,
2132 gint *natural_height)
2134 GtkCellAreaClass *class;
2136 g_return_if_fail (GTK_IS_CELL_AREA (area));
2137 g_return_if_fail (GTK_IS_WIDGET (widget));
2139 class = GTK_CELL_AREA_GET_CLASS (area);
2140 class->get_preferred_height_for_width (area, context, widget, width, minimum_height, natural_height);
2145 * gtk_cell_area_get_preferred_height:
2146 * @area: a #GtkCellArea
2147 * @context: the #GtkCellAreaContext to perform this request with
2148 * @widget: the #GtkWidget where @area will be rendering
2149 * @minimum_height: (out) (allow-none): location to store the minimum height, or %NULL
2150 * @natural_height: (out) (allow-none): location to store the natural height, or %NULL
2152 * Retrieves a cell area's initial minimum and natural height.
2154 * @area will store some geometrical information in @context along the way,
2155 * when requesting sizes over an arbitrary number of rows, its not important
2156 * to check the @minimum_height and @natural_height of this call but rather to
2157 * consult gtk_cell_area_context_get_preferred_height() after a series of
2163 gtk_cell_area_get_preferred_height (GtkCellArea *area,
2164 GtkCellAreaContext *context,
2166 gint *minimum_height,
2167 gint *natural_height)
2169 g_return_if_fail (GTK_IS_CELL_AREA (area));
2170 g_return_if_fail (GTK_IS_WIDGET (widget));
2172 GTK_CELL_AREA_GET_CLASS (area)->get_preferred_height (area, context, widget,
2173 minimum_height, natural_height);
2177 * gtk_cell_area_get_preferred_width_for_height:
2178 * @area: a #GtkCellArea
2179 * @context: the #GtkCellAreaContext which has already been requested for widths.
2180 * @widget: the #GtkWidget where @area will be rendering
2181 * @height: the height for which to check the width of this area
2182 * @minimum_width: (out) (allow-none): location to store the minimum width, or %NULL
2183 * @natural_width: (out) (allow-none): location to store the natural width, or %NULL
2185 * Retrieves a cell area's minimum and natural width if it would be given
2186 * the specified @height.
2188 * @area stores some geometrical information in @context along the way
2189 * while calling gtk_cell_area_get_preferred_height(). It's important to
2190 * perform a series of gtk_cell_area_get_preferred_height() requests with
2191 * @context first and then call gtk_cell_area_get_preferred_width_for_height()
2192 * on each cell area individually to get the height for width of each
2193 * fully requested row.
2195 * If at some point, the height of a single row changes, it should be
2196 * requested with gtk_cell_area_get_preferred_height() again and then
2197 * the full height of the requested rows checked again with
2198 * gtk_cell_area_context_get_preferred_height().
2203 gtk_cell_area_get_preferred_width_for_height (GtkCellArea *area,
2204 GtkCellAreaContext *context,
2207 gint *minimum_width,
2208 gint *natural_width)
2210 GtkCellAreaClass *class;
2212 g_return_if_fail (GTK_IS_CELL_AREA (area));
2213 g_return_if_fail (GTK_IS_WIDGET (widget));
2215 class = GTK_CELL_AREA_GET_CLASS (area);
2216 class->get_preferred_width_for_height (area, context, widget, height, minimum_width, natural_width);
2219 /*************************************************************
2221 *************************************************************/
2224 * gtk_cell_area_attribute_connect:
2225 * @area: a #GtkCellArea
2226 * @renderer: the #GtkCellRenderer to connect an attribute for
2227 * @attribute: the attribute name
2228 * @column: the #GtkTreeModel column to fetch attribute values from
2230 * Connects an @attribute to apply values from @column for the
2231 * #GtkTreeModel in use.
2236 gtk_cell_area_attribute_connect (GtkCellArea *area,
2237 GtkCellRenderer *renderer,
2238 const gchar *attribute,
2241 GtkCellAreaPrivate *priv;
2243 CellAttribute *cell_attribute;
2245 g_return_if_fail (GTK_IS_CELL_AREA (area));
2246 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
2247 g_return_if_fail (attribute != NULL);
2248 g_return_if_fail (gtk_cell_area_has_renderer (area, renderer));
2251 info = g_hash_table_lookup (priv->cell_info, renderer);
2255 info = cell_info_new (NULL, NULL, NULL);
2257 g_hash_table_insert (priv->cell_info, renderer, info);
2263 /* Check we are not adding the same attribute twice */
2264 if ((node = g_slist_find_custom (info->attributes, attribute,
2265 (GCompareFunc)cell_attribute_find)) != NULL)
2267 cell_attribute = node->data;
2269 g_warning ("Cannot connect attribute `%s' for cell renderer class `%s' "
2270 "since `%s' is already attributed to column %d",
2272 G_OBJECT_TYPE_NAME (renderer),
2273 attribute, cell_attribute->column);
2278 cell_attribute = cell_attribute_new (renderer, attribute, column);
2280 if (!cell_attribute)
2282 g_warning ("Cannot connect attribute `%s' for cell renderer class `%s' "
2283 "since attribute does not exist",
2285 G_OBJECT_TYPE_NAME (renderer));
2289 info->attributes = g_slist_prepend (info->attributes, cell_attribute);
2293 * gtk_cell_area_attribute_disconnect:
2294 * @area: a #GtkCellArea
2295 * @renderer: the #GtkCellRenderer to disconnect an attribute for
2296 * @attribute: the attribute name
2298 * Disconnects @attribute for the @renderer in @area so that
2299 * attribute will no longer be updated with values from the
2305 gtk_cell_area_attribute_disconnect (GtkCellArea *area,
2306 GtkCellRenderer *renderer,
2307 const gchar *attribute)
2309 GtkCellAreaPrivate *priv;
2311 CellAttribute *cell_attribute;
2314 g_return_if_fail (GTK_IS_CELL_AREA (area));
2315 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
2316 g_return_if_fail (attribute != NULL);
2317 g_return_if_fail (gtk_cell_area_has_renderer (area, renderer));
2320 info = g_hash_table_lookup (priv->cell_info, renderer);
2324 node = g_slist_find_custom (info->attributes, attribute,
2325 (GCompareFunc)cell_attribute_find);
2328 cell_attribute = node->data;
2330 cell_attribute_free (cell_attribute);
2332 info->attributes = g_slist_delete_link (info->attributes, node);
2338 * gtk_cell_area_apply_attributes:
2339 * @area: a #GtkCellArea
2340 * @tree_model: the #GtkTreeModel to pull values from
2341 * @iter: the #GtkTreeIter in @tree_model to apply values for
2342 * @is_expander: whether @iter has children
2343 * @is_expanded: whether @iter is expanded in the view and
2344 * children are visible
2346 * Applies any connected attributes to the renderers in
2347 * @area by pulling the values from @tree_model.
2352 gtk_cell_area_apply_attributes (GtkCellArea *area,
2353 GtkTreeModel *tree_model,
2355 gboolean is_expander,
2356 gboolean is_expanded)
2358 g_return_if_fail (GTK_IS_CELL_AREA (area));
2359 g_return_if_fail (GTK_IS_TREE_MODEL (tree_model));
2360 g_return_if_fail (iter != NULL);
2362 g_signal_emit (area, cell_area_signals[SIGNAL_APPLY_ATTRIBUTES], 0,
2363 tree_model, iter, is_expander, is_expanded);
2367 * gtk_cell_area_get_current_path_string:
2368 * @area: a #GtkCellArea
2370 * Gets the current #GtkTreePath string for the currently
2371 * applied #GtkTreeIter, this is implicitly updated when
2372 * gtk_cell_area_apply_attributes() is called and can be
2373 * used to interact with renderers from #GtkCellArea
2376 * Return value: The current #GtkTreePath string for the current
2377 * attributes applied to @area. This string belongs to the area and
2378 * should not be freed.
2383 gtk_cell_area_get_current_path_string (GtkCellArea *area)
2385 GtkCellAreaPrivate *priv;
2387 g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
2391 return priv->current_path;
2395 /*************************************************************
2396 * API: Cell Properties *
2397 *************************************************************/
2399 * gtk_cell_area_class_install_cell_property:
2400 * @aclass: a #GtkCellAreaClass
2401 * @property_id: the id for the property
2402 * @pspec: the #GParamSpec for the property
2404 * Installs a cell property on a cell area class.
2409 gtk_cell_area_class_install_cell_property (GtkCellAreaClass *aclass,
2413 g_return_if_fail (GTK_IS_CELL_AREA_CLASS (aclass));
2414 g_return_if_fail (G_IS_PARAM_SPEC (pspec));
2415 if (pspec->flags & G_PARAM_WRITABLE)
2416 g_return_if_fail (aclass->set_cell_property != NULL);
2417 if (pspec->flags & G_PARAM_READABLE)
2418 g_return_if_fail (aclass->get_cell_property != NULL);
2419 g_return_if_fail (property_id > 0);
2420 g_return_if_fail (PARAM_SPEC_PARAM_ID (pspec) == 0); /* paranoid */
2421 g_return_if_fail ((pspec->flags & (G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT_ONLY)) == 0);
2423 if (g_param_spec_pool_lookup (cell_property_pool, pspec->name, G_OBJECT_CLASS_TYPE (aclass), TRUE))
2425 g_warning (G_STRLOC ": class `%s' already contains a cell property named `%s'",
2426 G_OBJECT_CLASS_NAME (aclass), pspec->name);
2429 g_param_spec_ref (pspec);
2430 g_param_spec_sink (pspec);
2431 PARAM_SPEC_SET_PARAM_ID (pspec, property_id);
2432 g_param_spec_pool_insert (cell_property_pool, pspec, G_OBJECT_CLASS_TYPE (aclass));
2436 * gtk_cell_area_class_find_cell_property:
2437 * @aclass: a #GtkCellAreaClass
2438 * @property_name: the name of the child property to find
2440 * Finds a cell property of a cell area class by name.
2442 * Return value: (transfer none): the #GParamSpec of the child property
2443 * or %NULL if @aclass has no child property with that name.
2448 gtk_cell_area_class_find_cell_property (GtkCellAreaClass *aclass,
2449 const gchar *property_name)
2451 g_return_val_if_fail (GTK_IS_CELL_AREA_CLASS (aclass), NULL);
2452 g_return_val_if_fail (property_name != NULL, NULL);
2454 return g_param_spec_pool_lookup (cell_property_pool,
2456 G_OBJECT_CLASS_TYPE (aclass),
2461 * gtk_cell_area_class_list_cell_properties:
2462 * @aclass: a #GtkCellAreaClass
2463 * @n_properties: location to return the number of cell properties found
2465 * Returns all cell properties of a cell area class.
2467 * Return value: (array length=n_properties) (transfer container): a newly
2468 * allocated %NULL-terminated array of #GParamSpec*. The array
2469 * must be freed with g_free().
2474 gtk_cell_area_class_list_cell_properties (GtkCellAreaClass *aclass,
2475 guint *n_properties)
2477 GParamSpec **pspecs;
2480 g_return_val_if_fail (GTK_IS_CELL_AREA_CLASS (aclass), NULL);
2482 pspecs = g_param_spec_pool_list (cell_property_pool,
2483 G_OBJECT_CLASS_TYPE (aclass),
2492 * gtk_cell_area_add_with_properties:
2493 * @area: a #GtkCellArea
2494 * @renderer: a #GtkCellRenderer to be placed inside @area
2495 * @first_prop_name: the name of the first cell property to set
2496 * @...: a %NULL-terminated list of property names and values, starting
2497 * with @first_prop_name
2499 * Adds @renderer to @area, setting cell properties at the same time.
2500 * See gtk_cell_area_add() and gtk_cell_area_cell_set() for more details.
2505 gtk_cell_area_add_with_properties (GtkCellArea *area,
2506 GtkCellRenderer *renderer,
2507 const gchar *first_prop_name,
2510 GtkCellAreaClass *class;
2512 g_return_if_fail (GTK_IS_CELL_AREA (area));
2513 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
2515 class = GTK_CELL_AREA_GET_CLASS (area);
2521 class->add (area, renderer);
2523 va_start (var_args, first_prop_name);
2524 gtk_cell_area_cell_set_valist (area, renderer, first_prop_name, var_args);
2528 g_warning ("GtkCellAreaClass::add not implemented for `%s'",
2529 g_type_name (G_TYPE_FROM_INSTANCE (area)));
2533 * gtk_cell_area_cell_set:
2534 * @area: a #GtkCellArea
2535 * @renderer: a #GtkCellRenderer which is a cell inside @area
2536 * @first_prop_name: the name of the first cell property to set
2537 * @...: a %NULL-terminated list of property names and values, starting
2538 * with @first_prop_name
2540 * Sets one or more cell properties for @cell in @area.
2545 gtk_cell_area_cell_set (GtkCellArea *area,
2546 GtkCellRenderer *renderer,
2547 const gchar *first_prop_name,
2552 g_return_if_fail (GTK_IS_CELL_AREA (area));
2553 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
2555 va_start (var_args, first_prop_name);
2556 gtk_cell_area_cell_set_valist (area, renderer, first_prop_name, var_args);
2561 * gtk_cell_area_cell_get:
2562 * @area: a #GtkCellArea
2563 * @renderer: a #GtkCellRenderer which is inside @area
2564 * @first_prop_name: the name of the first cell property to get
2565 * @...: return location for the first cell property, followed
2566 * optionally by more name/return location pairs, followed by %NULL
2568 * Gets the values of one or more cell properties for @renderer in @area.
2573 gtk_cell_area_cell_get (GtkCellArea *area,
2574 GtkCellRenderer *renderer,
2575 const gchar *first_prop_name,
2580 g_return_if_fail (GTK_IS_CELL_AREA (area));
2581 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
2583 va_start (var_args, first_prop_name);
2584 gtk_cell_area_cell_get_valist (area, renderer, first_prop_name, var_args);
2589 area_get_cell_property (GtkCellArea *area,
2590 GtkCellRenderer *renderer,
2594 GtkCellAreaClass *class = g_type_class_peek (pspec->owner_type);
2596 class->get_cell_property (area, renderer, PARAM_SPEC_PARAM_ID (pspec), value, pspec);
2600 area_set_cell_property (GtkCellArea *area,
2601 GtkCellRenderer *renderer,
2603 const GValue *value)
2605 GValue tmp_value = G_VALUE_INIT;
2606 GtkCellAreaClass *class = g_type_class_peek (pspec->owner_type);
2608 /* provide a copy to work from, convert (if necessary) and validate */
2609 g_value_init (&tmp_value, G_PARAM_SPEC_VALUE_TYPE (pspec));
2610 if (!g_value_transform (value, &tmp_value))
2611 g_warning ("unable to set cell property `%s' of type `%s' from value of type `%s'",
2613 g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),
2614 G_VALUE_TYPE_NAME (value));
2615 else if (g_param_value_validate (pspec, &tmp_value) && !(pspec->flags & G_PARAM_LAX_VALIDATION))
2617 gchar *contents = g_strdup_value_contents (value);
2619 g_warning ("value \"%s\" of type `%s' is invalid for property `%s' of type `%s'",
2621 G_VALUE_TYPE_NAME (value),
2623 g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)));
2628 class->set_cell_property (area, renderer, PARAM_SPEC_PARAM_ID (pspec), &tmp_value, pspec);
2630 g_value_unset (&tmp_value);
2634 * gtk_cell_area_cell_set_valist:
2635 * @area: a #GtkCellArea
2636 * @renderer: a #GtkCellRenderer which inside @area
2637 * @first_property_name: the name of the first cell property to set
2638 * @var_args: a %NULL-terminated list of property names and values, starting
2639 * with @first_prop_name
2641 * Sets one or more cell properties for @renderer in @area.
2646 gtk_cell_area_cell_set_valist (GtkCellArea *area,
2647 GtkCellRenderer *renderer,
2648 const gchar *first_property_name,
2653 g_return_if_fail (GTK_IS_CELL_AREA (area));
2654 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
2656 name = first_property_name;
2659 GValue value = G_VALUE_INIT;
2660 gchar *error = NULL;
2662 g_param_spec_pool_lookup (cell_property_pool, name,
2663 G_OBJECT_TYPE (area), TRUE);
2666 g_warning ("%s: cell area class `%s' has no cell property named `%s'",
2667 G_STRLOC, G_OBJECT_TYPE_NAME (area), name);
2670 if (!(pspec->flags & G_PARAM_WRITABLE))
2672 g_warning ("%s: cell property `%s' of cell area class `%s' is not writable",
2673 G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (area));
2677 G_VALUE_COLLECT_INIT (&value, G_PARAM_SPEC_VALUE_TYPE (pspec),
2678 var_args, 0, &error);
2681 g_warning ("%s: %s", G_STRLOC, error);
2684 /* we purposely leak the value here, it might not be
2685 * in a sane state if an error condition occoured
2689 area_set_cell_property (area, renderer, pspec, &value);
2690 g_value_unset (&value);
2691 name = va_arg (var_args, gchar*);
2696 * gtk_cell_area_cell_get_valist:
2697 * @area: a #GtkCellArea
2698 * @renderer: a #GtkCellRenderer inside @area
2699 * @first_property_name: the name of the first property to get
2700 * @var_args: return location for the first property, followed
2701 * optionally by more name/return location pairs, followed by %NULL
2703 * Gets the values of one or more cell properties for @renderer in @area.
2708 gtk_cell_area_cell_get_valist (GtkCellArea *area,
2709 GtkCellRenderer *renderer,
2710 const gchar *first_property_name,
2715 g_return_if_fail (GTK_IS_CELL_AREA (area));
2716 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
2718 name = first_property_name;
2721 GValue value = G_VALUE_INIT;
2725 pspec = g_param_spec_pool_lookup (cell_property_pool, name,
2726 G_OBJECT_TYPE (area), TRUE);
2729 g_warning ("%s: cell area class `%s' has no cell property named `%s'",
2730 G_STRLOC, G_OBJECT_TYPE_NAME (area), name);
2733 if (!(pspec->flags & G_PARAM_READABLE))
2735 g_warning ("%s: cell property `%s' of cell area class `%s' is not readable",
2736 G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (area));
2740 g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
2741 area_get_cell_property (area, renderer, pspec, &value);
2742 G_VALUE_LCOPY (&value, var_args, 0, &error);
2745 g_warning ("%s: %s", G_STRLOC, error);
2747 g_value_unset (&value);
2750 g_value_unset (&value);
2751 name = va_arg (var_args, gchar*);
2756 * gtk_cell_area_cell_set_property:
2757 * @area: a #GtkCellArea
2758 * @renderer: a #GtkCellRenderer inside @area
2759 * @property_name: the name of the cell property to set
2760 * @value: the value to set the cell property to
2762 * Sets a cell property for @renderer in @area.
2767 gtk_cell_area_cell_set_property (GtkCellArea *area,
2768 GtkCellRenderer *renderer,
2769 const gchar *property_name,
2770 const GValue *value)
2774 g_return_if_fail (GTK_IS_CELL_AREA (area));
2775 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
2776 g_return_if_fail (property_name != NULL);
2777 g_return_if_fail (G_IS_VALUE (value));
2779 pspec = g_param_spec_pool_lookup (cell_property_pool, property_name,
2780 G_OBJECT_TYPE (area), TRUE);
2782 g_warning ("%s: cell area class `%s' has no cell property named `%s'",
2783 G_STRLOC, G_OBJECT_TYPE_NAME (area), property_name);
2784 else if (!(pspec->flags & G_PARAM_WRITABLE))
2785 g_warning ("%s: cell property `%s' of cell area class `%s' is not writable",
2786 G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (area));
2789 area_set_cell_property (area, renderer, pspec, value);
2794 * gtk_cell_area_cell_get_property:
2795 * @area: a #GtkCellArea
2796 * @renderer: a #GtkCellRenderer inside @area
2797 * @property_name: the name of the property to get
2798 * @value: a location to return the value
2800 * Gets the value of a cell property for @renderer in @area.
2805 gtk_cell_area_cell_get_property (GtkCellArea *area,
2806 GtkCellRenderer *renderer,
2807 const gchar *property_name,
2812 g_return_if_fail (GTK_IS_CELL_AREA (area));
2813 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
2814 g_return_if_fail (property_name != NULL);
2815 g_return_if_fail (G_IS_VALUE (value));
2817 pspec = g_param_spec_pool_lookup (cell_property_pool, property_name,
2818 G_OBJECT_TYPE (area), TRUE);
2820 g_warning ("%s: cell area class `%s' has no cell property named `%s'",
2821 G_STRLOC, G_OBJECT_TYPE_NAME (area), property_name);
2822 else if (!(pspec->flags & G_PARAM_READABLE))
2823 g_warning ("%s: cell property `%s' of cell area class `%s' is not readable",
2824 G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (area));
2827 GValue *prop_value, tmp_value = G_VALUE_INIT;
2829 /* auto-conversion of the callers value type
2831 if (G_VALUE_TYPE (value) == G_PARAM_SPEC_VALUE_TYPE (pspec))
2833 g_value_reset (value);
2836 else if (!g_value_type_transformable (G_PARAM_SPEC_VALUE_TYPE (pspec), G_VALUE_TYPE (value)))
2838 g_warning ("can't retrieve cell property `%s' of type `%s' as value of type `%s'",
2840 g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),
2841 G_VALUE_TYPE_NAME (value));
2846 g_value_init (&tmp_value, G_PARAM_SPEC_VALUE_TYPE (pspec));
2847 prop_value = &tmp_value;
2850 area_get_cell_property (area, renderer, pspec, prop_value);
2852 if (prop_value != value)
2854 g_value_transform (prop_value, value);
2855 g_value_unset (&tmp_value);
2860 /*************************************************************
2862 *************************************************************/
2865 * gtk_cell_area_is_activatable:
2866 * @area: a #GtkCellArea
2868 * Returns whether the area can do anything when activated,
2869 * after applying new attributes to @area.
2871 * Return value: whether @area can do anything when activated.
2876 gtk_cell_area_is_activatable (GtkCellArea *area)
2878 g_return_val_if_fail (GTK_IS_CELL_AREA (area), FALSE);
2880 return GTK_CELL_AREA_GET_CLASS (area)->is_activatable (area);
2884 * gtk_cell_area_focus:
2885 * @area: a #GtkCellArea
2886 * @direction: the #GtkDirectionType
2888 * This should be called by the @area's owning layout widget
2889 * when focus is to be passed to @area, or moved within @area
2890 * for a given @direction and row data.
2892 * Implementing #GtkCellArea classes should implement this
2893 * method to receive and navigate focus in its own way particular
2894 * to how it lays out cells.
2896 * Return value: %TRUE if focus remains inside @area as a result of this call.
2901 gtk_cell_area_focus (GtkCellArea *area,
2902 GtkDirectionType direction)
2904 g_return_val_if_fail (GTK_IS_CELL_AREA (area), FALSE);
2906 return GTK_CELL_AREA_GET_CLASS (area)->focus (area, direction);
2910 * gtk_cell_area_activate:
2911 * @area: a #GtkCellArea
2912 * @context: the #GtkCellAreaContext in context with the current row data
2913 * @widget: the #GtkWidget that @area is rendering on
2914 * @cell_area: the size and location of @area relative to @widget's allocation
2915 * @flags: the #GtkCellRendererState flags for @area for this row of data.
2916 * @edit_only: if %TRUE then only cell renderers that are %GTK_CELL_RENDERER_MODE_EDITABLE
2917 * will be activated.
2919 * Activates @area, usually by activating the currently focused
2920 * cell, however some subclasses which embed widgets in the area
2921 * can also activate a widget if it currently has the focus.
2923 * Return value: Whether @area was successfully activated.
2928 gtk_cell_area_activate (GtkCellArea *area,
2929 GtkCellAreaContext *context,
2931 const GdkRectangle *cell_area,
2932 GtkCellRendererState flags,
2935 g_return_val_if_fail (GTK_IS_CELL_AREA (area), FALSE);
2937 return GTK_CELL_AREA_GET_CLASS (area)->activate (area, context, widget, cell_area, flags, edit_only);
2942 * gtk_cell_area_set_focus_cell:
2943 * @area: a #GtkCellArea
2944 * @renderer: the #GtkCellRenderer to give focus to
2946 * Explicitly sets the currently focused cell to @renderer.
2948 * This is generally called by implementations of
2949 * #GtkCellAreaClass.focus() or #GtkCellAreaClass.event(),
2950 * however it can also be used to implement functions such
2951 * as gtk_tree_view_set_cursor_on_cell().
2956 gtk_cell_area_set_focus_cell (GtkCellArea *area,
2957 GtkCellRenderer *renderer)
2959 GtkCellAreaPrivate *priv;
2961 g_return_if_fail (GTK_IS_CELL_AREA (area));
2962 g_return_if_fail (renderer == NULL || GTK_IS_CELL_RENDERER (renderer));
2966 if (priv->focus_cell != renderer)
2968 if (priv->focus_cell)
2969 g_object_unref (priv->focus_cell);
2971 priv->focus_cell = renderer;
2973 if (priv->focus_cell)
2974 g_object_ref (priv->focus_cell);
2976 g_object_notify (G_OBJECT (area), "focus-cell");
2979 /* Signal that the current focus renderer for this path changed
2980 * (it may be that the focus cell did not change, but the row
2981 * may have changed so we need to signal it) */
2982 g_signal_emit (area, cell_area_signals[SIGNAL_FOCUS_CHANGED], 0,
2983 priv->focus_cell, priv->current_path);
2988 * gtk_cell_area_get_focus_cell:
2989 * @area: a #GtkCellArea
2991 * Retrieves the currently focused cell for @area
2993 * Return value: (transfer none): the currently focused cell in @area.
2998 gtk_cell_area_get_focus_cell (GtkCellArea *area)
3000 GtkCellAreaPrivate *priv;
3002 g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
3006 return priv->focus_cell;
3010 /*************************************************************
3011 * API: Focus Siblings *
3012 *************************************************************/
3015 * gtk_cell_area_add_focus_sibling:
3016 * @area: a #GtkCellArea
3017 * @renderer: the #GtkCellRenderer expected to have focus
3018 * @sibling: the #GtkCellRenderer to add to @renderer's focus area
3020 * Adds @sibling to @renderer's focusable area, focus will be drawn
3021 * around @renderer and all of its siblings if @renderer can
3022 * focus for a given row.
3024 * Events handled by focus siblings can also activate the given
3025 * focusable @renderer.
3030 gtk_cell_area_add_focus_sibling (GtkCellArea *area,
3031 GtkCellRenderer *renderer,
3032 GtkCellRenderer *sibling)
3034 GtkCellAreaPrivate *priv;
3037 g_return_if_fail (GTK_IS_CELL_AREA (area));
3038 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
3039 g_return_if_fail (GTK_IS_CELL_RENDERER (sibling));
3040 g_return_if_fail (renderer != sibling);
3041 g_return_if_fail (gtk_cell_area_has_renderer (area, renderer));
3042 g_return_if_fail (gtk_cell_area_has_renderer (area, sibling));
3043 g_return_if_fail (!gtk_cell_area_is_focus_sibling (area, renderer, sibling));
3045 /* XXX We should also check that sibling is not in any other renderer's sibling
3046 * list already, a renderer can be sibling of only one focusable renderer
3052 siblings = g_hash_table_lookup (priv->focus_siblings, renderer);
3055 siblings = g_list_append (siblings, sibling);
3058 siblings = g_list_append (siblings, sibling);
3059 g_hash_table_insert (priv->focus_siblings, renderer, siblings);
3064 * gtk_cell_area_remove_focus_sibling:
3065 * @area: a #GtkCellArea
3066 * @renderer: the #GtkCellRenderer expected to have focus
3067 * @sibling: the #GtkCellRenderer to remove from @renderer's focus area
3069 * Removes @sibling from @renderer's focus sibling list
3070 * (see gtk_cell_area_add_focus_sibling()).
3075 gtk_cell_area_remove_focus_sibling (GtkCellArea *area,
3076 GtkCellRenderer *renderer,
3077 GtkCellRenderer *sibling)
3079 GtkCellAreaPrivate *priv;
3082 g_return_if_fail (GTK_IS_CELL_AREA (area));
3083 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
3084 g_return_if_fail (GTK_IS_CELL_RENDERER (sibling));
3085 g_return_if_fail (gtk_cell_area_is_focus_sibling (area, renderer, sibling));
3089 siblings = g_hash_table_lookup (priv->focus_siblings, renderer);
3091 siblings = g_list_copy (siblings);
3092 siblings = g_list_remove (siblings, sibling);
3095 g_hash_table_remove (priv->focus_siblings, renderer);
3097 g_hash_table_insert (priv->focus_siblings, renderer, siblings);
3101 * gtk_cell_area_is_focus_sibling:
3102 * @area: a #GtkCellArea
3103 * @renderer: the #GtkCellRenderer expected to have focus
3104 * @sibling: the #GtkCellRenderer to check against @renderer's sibling list
3106 * Returns whether @sibling is one of @renderer's focus siblings
3107 * (see gtk_cell_area_add_focus_sibling()).
3109 * Return value: %TRUE if @sibling is a focus sibling of @renderer
3114 gtk_cell_area_is_focus_sibling (GtkCellArea *area,
3115 GtkCellRenderer *renderer,
3116 GtkCellRenderer *sibling)
3118 GtkCellAreaPrivate *priv;
3119 GList *siblings, *l;
3121 g_return_val_if_fail (GTK_IS_CELL_AREA (area), FALSE);
3122 g_return_val_if_fail (GTK_IS_CELL_RENDERER (renderer), FALSE);
3123 g_return_val_if_fail (GTK_IS_CELL_RENDERER (sibling), FALSE);
3127 siblings = g_hash_table_lookup (priv->focus_siblings, renderer);
3129 for (l = siblings; l; l = l->next)
3131 GtkCellRenderer *a_sibling = l->data;
3133 if (a_sibling == sibling)
3141 * gtk_cell_area_get_focus_siblings:
3142 * @area: a #GtkCellArea
3143 * @renderer: the #GtkCellRenderer expected to have focus
3145 * Gets the focus sibling cell renderers for @renderer.
3147 * Return value: (element-type GtkCellRenderer) (transfer none): A #GList of #GtkCellRenderers.
3148 * The returned list is internal and should not be freed.
3153 gtk_cell_area_get_focus_siblings (GtkCellArea *area,
3154 GtkCellRenderer *renderer)
3156 GtkCellAreaPrivate *priv;
3158 g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
3159 g_return_val_if_fail (GTK_IS_CELL_RENDERER (renderer), NULL);
3163 return g_hash_table_lookup (priv->focus_siblings, renderer);
3167 * gtk_cell_area_get_focus_from_sibling:
3168 * @area: a #GtkCellArea
3169 * @renderer: the #GtkCellRenderer
3171 * Gets the #GtkCellRenderer which is expected to be focusable
3172 * for which @renderer is, or may be a sibling.
3174 * This is handy for #GtkCellArea subclasses when handling events,
3175 * after determining the renderer at the event location it can
3176 * then chose to activate the focus cell for which the event
3177 * cell may have been a sibling.
3179 * Return value: (transfer none): the #GtkCellRenderer for which @renderer
3180 * is a sibling, or %NULL.
3185 gtk_cell_area_get_focus_from_sibling (GtkCellArea *area,
3186 GtkCellRenderer *renderer)
3188 GtkCellRenderer *ret_renderer = NULL;
3189 GList *renderers, *l;
3191 g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
3192 g_return_val_if_fail (GTK_IS_CELL_RENDERER (renderer), NULL);
3194 renderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (area));
3196 for (l = renderers; l; l = l->next)
3198 GtkCellRenderer *a_renderer = l->data;
3201 for (list = gtk_cell_area_get_focus_siblings (area, a_renderer);
3202 list; list = list->next)
3204 GtkCellRenderer *sibling_renderer = list->data;
3206 if (sibling_renderer == renderer)
3208 ret_renderer = a_renderer;
3213 g_list_free (renderers);
3215 return ret_renderer;
3218 /*************************************************************
3219 * API: Cell Activation/Editing *
3220 *************************************************************/
3222 gtk_cell_area_add_editable (GtkCellArea *area,
3223 GtkCellRenderer *renderer,
3224 GtkCellEditable *editable,
3225 const GdkRectangle *cell_area)
3227 g_signal_emit (area, cell_area_signals[SIGNAL_ADD_EDITABLE], 0,
3228 renderer, editable, cell_area, area->priv->current_path);
3232 gtk_cell_area_remove_editable (GtkCellArea *area,
3233 GtkCellRenderer *renderer,
3234 GtkCellEditable *editable)
3236 g_signal_emit (area, cell_area_signals[SIGNAL_REMOVE_EDITABLE], 0, renderer, editable);
3240 cell_area_remove_widget_cb (GtkCellEditable *editable,
3243 GtkCellAreaPrivate *priv = area->priv;
3245 g_assert (priv->edit_widget == editable);
3246 g_assert (priv->edited_cell != NULL);
3248 gtk_cell_area_remove_editable (area, priv->edited_cell, priv->edit_widget);
3250 /* Now that we're done with editing the widget and it can be removed,
3251 * remove our references to the widget and disconnect handlers */
3252 gtk_cell_area_set_edited_cell (area, NULL);
3253 gtk_cell_area_set_edit_widget (area, NULL);
3257 gtk_cell_area_set_edited_cell (GtkCellArea *area,
3258 GtkCellRenderer *renderer)
3260 GtkCellAreaPrivate *priv;
3262 g_return_if_fail (GTK_IS_CELL_AREA (area));
3263 g_return_if_fail (renderer == NULL || GTK_IS_CELL_RENDERER (renderer));
3267 if (priv->edited_cell != renderer)
3269 if (priv->edited_cell)
3270 g_object_unref (priv->edited_cell);
3272 priv->edited_cell = renderer;
3274 if (priv->edited_cell)
3275 g_object_ref (priv->edited_cell);
3277 g_object_notify (G_OBJECT (area), "edited-cell");
3282 gtk_cell_area_set_edit_widget (GtkCellArea *area,
3283 GtkCellEditable *editable)
3285 GtkCellAreaPrivate *priv;
3287 g_return_if_fail (GTK_IS_CELL_AREA (area));
3288 g_return_if_fail (editable == NULL || GTK_IS_CELL_EDITABLE (editable));
3292 if (priv->edit_widget != editable)
3294 if (priv->edit_widget)
3296 g_signal_handler_disconnect (priv->edit_widget, priv->remove_widget_id);
3298 g_object_unref (priv->edit_widget);
3301 priv->edit_widget = editable;
3303 if (priv->edit_widget)
3305 priv->remove_widget_id =
3306 g_signal_connect (priv->edit_widget, "remove-widget",
3307 G_CALLBACK (cell_area_remove_widget_cb), area);
3309 g_object_ref (priv->edit_widget);
3312 g_object_notify (G_OBJECT (area), "edit-widget");
3317 * gtk_cell_area_get_edited_cell:
3318 * @area: a #GtkCellArea
3320 * Gets the #GtkCellRenderer in @area that is currently
3323 * Return value: (transfer none): The currently edited #GtkCellRenderer
3328 gtk_cell_area_get_edited_cell (GtkCellArea *area)
3330 GtkCellAreaPrivate *priv;
3332 g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
3336 return priv->edited_cell;
3340 * gtk_cell_area_get_edit_widget:
3341 * @area: a #GtkCellArea
3343 * Gets the #GtkCellEditable widget currently used
3344 * to edit the currently edited cell.
3346 * Return value: (transfer none): The currently active #GtkCellEditable widget
3351 gtk_cell_area_get_edit_widget (GtkCellArea *area)
3353 GtkCellAreaPrivate *priv;
3355 g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
3359 return priv->edit_widget;
3363 * gtk_cell_area_activate_cell:
3364 * @area: a #GtkCellArea
3365 * @widget: the #GtkWidget that @area is rendering onto
3366 * @renderer: the #GtkCellRenderer in @area to activate
3367 * @event: the #GdkEvent for which cell activation should occur
3368 * @cell_area: the #GdkRectangle in @widget relative coordinates
3369 * of @renderer for the current row.
3370 * @flags: the #GtkCellRendererState for @renderer
3372 * This is used by #GtkCellArea subclasses when handling events
3373 * to activate cells, the base #GtkCellArea class activates cells
3374 * for keyboard events for free in its own GtkCellArea->activate()
3377 * Return value: whether cell activation was successful
3382 gtk_cell_area_activate_cell (GtkCellArea *area,
3384 GtkCellRenderer *renderer,
3386 const GdkRectangle *cell_area,
3387 GtkCellRendererState flags)
3389 GtkCellRendererMode mode;
3390 GtkCellAreaPrivate *priv;
3392 g_return_val_if_fail (GTK_IS_CELL_AREA (area), FALSE);
3393 g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
3394 g_return_val_if_fail (GTK_IS_CELL_RENDERER (renderer), FALSE);
3395 g_return_val_if_fail (cell_area != NULL, FALSE);
3399 if (!gtk_cell_renderer_get_sensitive (renderer))
3402 g_object_get (renderer, "mode", &mode, NULL);
3404 if (mode == GTK_CELL_RENDERER_MODE_ACTIVATABLE)
3406 if (gtk_cell_renderer_activate (renderer,
3414 else if (mode == GTK_CELL_RENDERER_MODE_EDITABLE)
3416 GtkCellEditable *editable_widget;
3417 GdkRectangle inner_area;
3419 gtk_cell_area_inner_cell_area (area, widget, cell_area, &inner_area);
3422 gtk_cell_renderer_start_editing (renderer,
3429 if (editable_widget != NULL)
3431 g_return_val_if_fail (GTK_IS_CELL_EDITABLE (editable_widget), FALSE);
3433 gtk_cell_area_set_edited_cell (area, renderer);
3434 gtk_cell_area_set_edit_widget (area, editable_widget);
3436 /* Signal that editing started so that callers can get
3437 * a handle on the editable_widget */
3438 gtk_cell_area_add_editable (area, priv->focus_cell, editable_widget, cell_area);
3440 /* If the signal was successfully handled start the editing */
3441 if (gtk_widget_get_parent (GTK_WIDGET (editable_widget)))
3443 gtk_cell_editable_start_editing (editable_widget, NULL);
3444 gtk_widget_grab_focus (GTK_WIDGET (editable_widget));
3448 /* Otherwise clear the editing state and fire a warning */
3449 gtk_cell_area_set_edited_cell (area, NULL);
3450 gtk_cell_area_set_edit_widget (area, NULL);
3452 g_warning ("GtkCellArea::add-editable fired in the dark, no cell editing was started.");
3463 * gtk_cell_area_stop_editing:
3464 * @area: a #GtkCellArea
3465 * @canceled: whether editing was canceled.
3467 * Explicitly stops the editing of the currently edited cell.
3469 * If @canceled is %TRUE, the currently edited cell renderer
3470 * will emit the ::editing-canceled signal, otherwise the
3471 * the ::editing-done signal will be emitted on the current
3474 * See gtk_cell_area_get_edited_cell() and gtk_cell_area_get_edit_widget().
3479 gtk_cell_area_stop_editing (GtkCellArea *area,
3482 GtkCellAreaPrivate *priv;
3484 g_return_if_fail (GTK_IS_CELL_AREA (area));
3488 if (priv->edited_cell)
3490 GtkCellEditable *edit_widget = g_object_ref (priv->edit_widget);
3491 GtkCellRenderer *edit_cell = g_object_ref (priv->edited_cell);
3493 /* Stop editing of the cell renderer */
3494 gtk_cell_renderer_stop_editing (priv->edited_cell, canceled);
3496 /* When editing is explicitly halted either
3497 * the "editing-canceled" signal is emitted on the cell
3498 * renderer or the "editing-done" signal on the GtkCellEditable widget
3501 gtk_cell_editable_editing_done (edit_widget);
3503 /* Remove any references to the editable widget */
3504 gtk_cell_area_set_edited_cell (area, NULL);
3505 gtk_cell_area_set_edit_widget (area, NULL);
3507 /* Send the remove-widget signal explicitly (this is done after setting
3508 * the edit cell/widget NULL to avoid feedback)
3510 gtk_cell_area_remove_editable (area, edit_cell, edit_widget);
3511 g_object_unref (edit_cell);
3512 g_object_unref (edit_widget);
3516 /*************************************************************
3517 * API: Convenience for area implementations *
3518 *************************************************************/
3521 * gtk_cell_area_inner_cell_area:
3522 * @area: a #GtkCellArea
3523 * @widget: the #GtkWidget that @area is rendering onto
3524 * @cell_area: the @widget relative coordinates where one of @area's cells
3526 * @inner_area: (out): the return location for the inner cell area
3528 * This is a convenience function for #GtkCellArea implementations
3529 * to get the inner area where a given #GtkCellRenderer will be
3530 * rendered. It removes any padding previously added by gtk_cell_area_request_renderer().
3535 gtk_cell_area_inner_cell_area (GtkCellArea *area,
3537 const GdkRectangle *cell_area,
3538 GdkRectangle *inner_area)
3540 gint focus_line_width;
3542 g_return_if_fail (GTK_IS_CELL_AREA (area));
3543 g_return_if_fail (GTK_IS_WIDGET (widget));
3544 g_return_if_fail (cell_area != NULL);
3545 g_return_if_fail (inner_area != NULL);
3547 gtk_widget_style_get (widget, "focus-line-width", &focus_line_width, NULL);
3549 *inner_area = *cell_area;
3551 inner_area->x += focus_line_width;
3552 inner_area->width -= focus_line_width * 2;
3553 inner_area->y += focus_line_width;
3554 inner_area->height -= focus_line_width * 2;
3558 * gtk_cell_area_request_renderer:
3559 * @area: a #GtkCellArea
3560 * @renderer: the #GtkCellRenderer to request size for
3561 * @orientation: the #GtkOrientation in which to request size
3562 * @widget: the #GtkWidget that @area is rendering onto
3563 * @for_size: the allocation contextual size to request for, or -1 if
3564 * the base request for the orientation is to be returned.
3565 * @minimum_size: (out) (allow-none): location to store the minimum size, or %NULL
3566 * @natural_size: (out) (allow-none): location to store the natural size, or %NULL
3568 * This is a convenience function for #GtkCellArea implementations
3569 * to request size for cell renderers. It's important to use this
3570 * function to request size and then use gtk_cell_area_inner_cell_area()
3571 * at render and event time since this function will add padding
3572 * around the cell for focus painting.
3577 gtk_cell_area_request_renderer (GtkCellArea *area,
3578 GtkCellRenderer *renderer,
3579 GtkOrientation orientation,
3585 gint focus_line_width;
3587 g_return_if_fail (GTK_IS_CELL_AREA (area));
3588 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
3589 g_return_if_fail (GTK_IS_WIDGET (widget));
3590 g_return_if_fail (minimum_size != NULL);
3591 g_return_if_fail (natural_size != NULL);
3593 gtk_widget_style_get (widget, "focus-line-width", &focus_line_width, NULL);
3595 focus_line_width *= 2;
3597 if (orientation == GTK_ORIENTATION_HORIZONTAL)
3600 gtk_cell_renderer_get_preferred_width (renderer, widget, minimum_size, natural_size);
3603 for_size = MAX (0, for_size - focus_line_width);
3605 gtk_cell_renderer_get_preferred_width_for_height (renderer, widget, for_size,
3606 minimum_size, natural_size);
3609 else /* GTK_ORIENTATION_VERTICAL */
3612 gtk_cell_renderer_get_preferred_height (renderer, widget, minimum_size, natural_size);
3615 for_size = MAX (0, for_size - focus_line_width);
3617 gtk_cell_renderer_get_preferred_height_for_width (renderer, widget, for_size,
3618 minimum_size, natural_size);
3622 *minimum_size += focus_line_width;
3623 *natural_size += focus_line_width;
3627 _gtk_cell_area_set_cell_data_func_with_proxy (GtkCellArea *area,
3628 GtkCellRenderer *cell,
3631 GDestroyNotify destroy,
3634 GtkCellAreaPrivate *priv;
3637 g_return_if_fail (GTK_IS_CELL_AREA (area));
3638 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
3642 info = g_hash_table_lookup (priv->cell_info, cell);
3644 /* Note we do not take a reference to the proxy, the proxy is a GtkCellLayout
3645 * that is forwarding its implementation to a delegate GtkCellArea therefore
3646 * its life-cycle is longer than the area's life cycle.
3650 if (info->destroy && info->data)
3651 info->destroy (info->data);
3655 info->func = (GtkCellLayoutDataFunc)func;
3656 info->data = func_data;
3657 info->destroy = destroy;
3658 info->proxy = proxy;
3664 info->destroy = NULL;
3670 info = cell_info_new ((GtkCellLayoutDataFunc)func, func_data, destroy);
3671 info->proxy = proxy;
3673 g_hash_table_insert (priv->cell_info, cell, info);