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, write to the
20 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21 * Boston, MA 02111-1307, USA.
26 * @Short_Description: An abstract class for laying out GtkCellRenderers
29 * The #GtkCellArea is an abstract class for #GtkCellLayout widgets
30 * (also referred to as "layouting widgets") to interface with an
31 * arbitrary number of #GtkCellRenderers and interact with the user
32 * for a given #GtkTreeModel row.
34 * The cell area handles events, focus navigation, drawing and
35 * size requests and allocations for a given row of data.
37 * Usually users dont have to interact with the #GtkCellArea directly
38 * unless they are implementing a cell layouting widget themselves.
40 * <refsect2 id="cell-area-geometry-management">
41 * <title>Requesting area sizes</title>
43 * As outlined in <link linkend="geometry-management">GtkWidget's
44 * geometry management section</link>, GTK+ uses a height-for-width
45 * geometry management system to compute the sizes of widgets and user
46 * interfaces. #GtkCellArea uses the same semantics to calculate the
47 * size of an area for an arbitrary number of #GtkTreeModel rows.
49 * When requesting the size of a cell area one needs to calculate
50 * the size for a handful of rows, this will be done differently by
51 * different layouting widgets. For instance a #GtkTreeViewColumn
52 * always lines up the areas from top to bottom while a #GtkIconView
53 * on the other hand might enforce that all areas received the same
54 * width and wrap the areas around, requesting height for more cell
55 * areas when allocated less width.
57 * It's also important for areas to maintain some cell
58 * alignments with areas rendered for adjacent rows (cells can
59 * appear "columnized" inside an area even when the size of
60 * cells are different in each row). For this reason the #GtkCellArea
61 * uses a #GtkCellAreaContext object to store the alignments
62 * and sizes along the way (as well as the overall largest minimum
63 * and natural size for all the rows which have been calculated
64 * with the said context).
66 * The #GtkCellAreaContext is an opaque object specific to the
67 * #GtkCellArea which created it (see gtk_cell_area_create_context()).
68 * The owning cell layouting widget can create as many contexts as
69 * it wishes to calculate sizes of rows which should receive the
70 * same size in at least one orientation (horizontally or vertically),
71 * however it's important that the same #GtkCellAreaContext which
72 * was used to request the sizes for a given #GtkTreeModel row be
73 * used when rendering or processing events for that row.
75 * In order to request the width of all the rows at the root level
76 * of a #GtkTreeModel one would do the following:
78 * <title>Requesting the width of a handful of GtkTreeModel rows</title>
84 * valid = gtk_tree_model_get_iter_first (model, &iter);
87 * gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
88 * gtk_cell_area_get_preferred_width (area, context, widget, NULL, NULL);
90 * valid = gtk_tree_model_iter_next (model, &iter);
92 * gtk_cell_area_context_get_preferred_width (context, &minimum_width, &natural_width);
95 * Note that in this example it's not important to observe the
96 * returned minimum and natural width of the area for each row
97 * unless the cell layouting object is actually interested in the
98 * widths of individual rows. The overall width is however stored
99 * in the accompanying #GtkCellAreaContext object and can be consulted
102 * This can be useful since #GtkCellLayout widgets usually have to
103 * support requesting and rendering rows in treemodels with an
104 * exceedingly large amount of rows. The #GtkCellLayout widget in
105 * that case would calculate the required width of the rows in an
106 * idle or timeout source (see g_timeout_add()) and when the widget
107 * is requested its actual width in #GtkWidgetClass.get_preferred_width()
108 * it can simply consult the width accumulated so far in the
109 * #GtkCellAreaContext object.
111 * A simple example where rows are rendered from top to bottom and
112 * take up the full width of the layouting widget would look like:
114 * <title>A typical get_preferred_width() implementation</title>
117 * foo_get_preferred_width (GtkWidget *widget,
118 * gint *minimum_size,
119 * gint *natural_size)
121 * Foo *foo = FOO (widget);
122 * FooPrivate *priv = foo->priv;
124 * foo_ensure_at_least_one_handfull_of_rows_have_been_requested (foo);
126 * gtk_cell_area_context_get_preferred_width (priv->context, minimum_size, natural_size);
130 * In the above example the Foo widget has to make sure that some
131 * row sizes have been calculated (the amount of rows that Foo judged
132 * was appropriate to request space for in a single timeout iteration)
133 * before simply returning the amount of space required by the area via
134 * the #GtkCellAreaContext.
136 * Requesting the height for width (or width for height) of an area is
137 * a similar task except in this case the #GtkCellAreaContext does not
138 * store the data (actually, it does not know how much space the layouting
139 * widget plans to allocate it for every row, it's up to the layouting
140 * widget to render each row of data with the appropriate height and
141 * width which was requested by the #GtkCellArea).
143 * In order to request the height for width of all the rows at the
144 * root level of a #GtkTreeModel one would do the following:
146 * <title>Requesting the height for width of a handful of GtkTreeModel rows</title>
149 * gint minimum_height;
150 * gint natural_height;
151 * gint full_minimum_height = 0;
152 * gint full_natural_height = 0;
154 * valid = gtk_tree_model_get_iter_first (model, &iter);
157 * gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
158 * gtk_cell_area_get_preferred_height_for_width (area, context, widget,
159 * width, &minimum_height, &natural_height);
161 * if (width_is_for_allocation)
162 * cache_row_height (&iter, minimum_height, natural_height);
164 * full_minimum_height += minimum_height;
165 * full_natural_height += natural_height;
167 * valid = gtk_tree_model_iter_next (model, &iter);
171 * Note that in the above example we would need to cache the heights
172 * returned for each row so that we would know what sizes to render the
173 * areas for each row. However we would only want to really cache the
174 * heights if the request is intended for the layouting widgets real
177 * In some cases the layouting widget is requested the height for an
178 * arbitrary for_width, this is a special case for layouting widgets
179 * who need to request size for tens of thousands of rows. For this
180 * case it's only important that the layouting widget calculate
181 * one reasonably sized chunk of rows and return that height
182 * synchronously. The reasoning here is that any layouting widget is
183 * at least capable of synchronously calculating enough height to fill
184 * the screen height (or scrolled window height) in response to a single
185 * call to #GtkWidgetClass.get_preferred_height_for_width(). Returning
186 * a perfect height for width that is larger than the screen area is
187 * inconsequential since after the layouting receives an allocation
188 * from a scrolled window it simply continues to drive the the scrollbar
189 * values while more and more height is required for the row heights
190 * that are calculated in the background.
193 * <refsect2 id="cell-area-rendering">
194 * <title>Rendering Areas</title>
196 * Once area sizes have been aquired at least for the rows in the
197 * visible area of the layouting widget they can be rendered at
198 * #GtkWidgetClass.draw() time.
200 * A crude example of how to render all the rows at the root level
203 * <title>Requesting the width of a handful of GtkTreeModel rows</title>
205 * GtkAllocation allocation;
206 * GdkRectangle cell_area = { 0, };
208 * gint minimum_width;
209 * gint natural_width;
211 * gtk_widget_get_allocation (widget, &allocation);
212 * cell_area.width = allocation.width;
214 * valid = gtk_tree_model_get_iter_first (model, &iter);
217 * cell_area.height = get_cached_height_for_row (&iter);
219 * gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
220 * gtk_cell_area_render (area, context, widget, cr,
221 * &cell_area, &cell_area, state_flags, FALSE);
223 * cell_area.y += cell_area.height;
225 * valid = gtk_tree_model_iter_next (model, &iter);
229 * Note that the cached height in this example really depends on how
230 * the layouting widget works. The layouting widget might decide to
231 * give every row it's minimum or natural height or, if the model content
232 * is expected to fit inside the layouting widget without scrolling, it
233 * would make sense to calculate the allocation for each row at
234 * #GtkWidget::size-allocate time using gtk_distribute_natural_allocation().
237 * <refsect2 id="cell-area-events-and-focus">
238 * <title>Handling Events and Driving Keyboard Focus</title>
240 * Passing events to the area is as simple as handling events on any
241 * normal widget and then passing them to the gtk_cell_area_event()
242 * API as they come in. Usually #GtkCellArea is only interested in
243 * button events, however some customized derived areas can be implemented
244 * who are interested in handling other events. Handling an event can
245 * trigger the #GtkCellArea::focus-changed signal to fire; as well as
246 * #GtkCellArea::add-editable in the case that an editable cell was
247 * clicked and needs to start editing. You can call
248 * gtk_cell_area_stop_editing() at any time to cancel any cell editing
249 * that is currently in progress.
251 * The #GtkCellArea drives keyboard focus from cell to cell in a way
252 * similar to #GtkWidget. For layouting widgets that support giving
253 * focus to cells it's important to remember to pass %GTK_CELL_RENDERER_FOCUSED
254 * to the area functions for the row that has focus and to tell the
255 * area to paint the focus at render time.
257 * Layouting widgets that accept focus on cells should implement the
258 * #GtkWidgetClass.focus() virtual method. The layouting widget is always
259 * responsible for knowing where #GtkTreeModel rows are rendered inside
260 * the widget, so at #GtkWidgetClass.focus() time the layouting widget
261 * should use the #GtkCellArea methods to navigate focus inside the area
262 * and then observe the GtkDirectionType to pass the focus to adjacent
265 * A basic example of how the #GtkWidgetClass.focus() virtual method
266 * should be implemented:
268 * <title>Implementing keyboard focus navigation</title>
271 * foo_focus (GtkWidget *widget,
272 * GtkDirectionType direction)
274 * Foo *foo = FOO (widget);
275 * FooPrivate *priv = foo->priv;
277 * gboolean have_focus = FALSE;
279 * focus_row = priv->focus_row;
281 * if (!gtk_widget_has_focus (widget))
282 * gtk_widget_grab_focus (widget);
284 * valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, priv->focus_row);
287 * gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE);
289 * if (gtk_cell_area_focus (priv->area, direction))
291 * priv->focus_row = focus_row;
297 * if (direction == GTK_DIR_RIGHT ||
298 * direction == GTK_DIR_LEFT)
300 * else if (direction == GTK_DIR_UP ||
301 * direction == GTK_DIR_TAB_BACKWARD)
303 * if (focus_row == 0)
308 * valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, focus_row);
313 * if (focus_row == last_row)
318 * valid = gtk_tree_model_iter_next (priv->model, &iter);
327 * Note that the layouting widget is responsible for matching the
328 * GtkDirectionType values to the way it lays out its cells.
331 * <refsect2 id="cell-properties">
332 * <title>Cell Properties</title>
334 * The #GtkCellArea introduces <emphasis>cell properties</emphasis>
335 * for #GtkCellRenderers in very much the same way that #GtkContainer
336 * introduces <link linkend="child-properties">child properties</link>
337 * for #GtkWidgets. This provides some general interfaces for defining
338 * the relationship cell areas have with their cells. For instance in a
339 * #GtkCellAreaBox a cell might "expand" and receive extra space when
340 * the area is allocated more than it's full natural request, or a cell
341 * might be configured to "align" with adjacent rows which were requested
342 * and rendered with the same #GtkCellAreaContext.
344 * Use gtk_cell_area_class_install_cell_property() to install cell
345 * properties for a cell area class and gtk_cell_area_class_find_cell_property()
346 * or gtk_cell_area_class_list_cell_properties() to get information about
347 * existing cell properties.
349 * To set the value of a cell property, use gtk_cell_area_cell_set_property(),
350 * gtk_cell_area_cell_set() or gtk_cell_area_cell_set_valist(). To obtain
351 * the value of a cell property, use gtk_cell_area_cell_get_property(),
352 * gtk_cell_area_cell_get() or gtk_cell_area_cell_get_valist().
364 #include "gtkcelllayout.h"
365 #include "gtkcellarea.h"
366 #include "gtkcellareacontext.h"
367 #include "gtkmarshalers.h"
368 #include "gtkprivate.h"
370 #include <gobject/gvaluecollector.h>
374 static void gtk_cell_area_dispose (GObject *object);
375 static void gtk_cell_area_finalize (GObject *object);
376 static void gtk_cell_area_set_property (GObject *object,
380 static void gtk_cell_area_get_property (GObject *object,
385 /* GtkCellAreaClass */
386 static gint gtk_cell_area_real_event (GtkCellArea *area,
387 GtkCellAreaContext *context,
390 const GdkRectangle *cell_area,
391 GtkCellRendererState flags);
392 static void gtk_cell_area_real_render (GtkCellArea *area,
393 GtkCellAreaContext *context,
396 const GdkRectangle *background_area,
397 const GdkRectangle *cell_area,
398 GtkCellRendererState flags,
399 gboolean paint_focus);
400 static void gtk_cell_area_real_apply_attributes (GtkCellArea *area,
401 GtkTreeModel *tree_model,
403 gboolean is_expander,
404 gboolean is_expanded);
405 static void gtk_cell_area_real_get_preferred_height_for_width (GtkCellArea *area,
406 GtkCellAreaContext *context,
409 gint *minimum_height,
410 gint *natural_height);
411 static void gtk_cell_area_real_get_preferred_width_for_height (GtkCellArea *area,
412 GtkCellAreaContext *context,
416 gint *natural_width);
417 static gboolean gtk_cell_area_real_is_activatable (GtkCellArea *area);
418 static gboolean gtk_cell_area_real_activate (GtkCellArea *area,
419 GtkCellAreaContext *context,
421 const GdkRectangle *cell_area,
422 GtkCellRendererState flags,
425 /* GtkCellLayoutIface */
426 static void gtk_cell_area_cell_layout_init (GtkCellLayoutIface *iface);
427 static void gtk_cell_area_pack_default (GtkCellLayout *cell_layout,
428 GtkCellRenderer *renderer,
430 static void gtk_cell_area_clear (GtkCellLayout *cell_layout);
431 static void gtk_cell_area_add_attribute (GtkCellLayout *cell_layout,
432 GtkCellRenderer *renderer,
433 const gchar *attribute,
435 static void gtk_cell_area_set_cell_data_func (GtkCellLayout *cell_layout,
436 GtkCellRenderer *cell,
437 GtkCellLayoutDataFunc func,
439 GDestroyNotify destroy);
440 static void gtk_cell_area_clear_attributes (GtkCellLayout *cell_layout,
441 GtkCellRenderer *renderer);
442 static void gtk_cell_area_reorder (GtkCellLayout *cell_layout,
443 GtkCellRenderer *cell,
445 static GList *gtk_cell_area_get_cells (GtkCellLayout *cell_layout);
446 static GtkCellArea *gtk_cell_area_get_area (GtkCellLayout *cell_layout);
448 /* GtkBuildableIface */
449 static void gtk_cell_area_buildable_init (GtkBuildableIface *iface);
450 static void gtk_cell_area_buildable_custom_tag_end (GtkBuildable *buildable,
453 const gchar *tagname,
456 /* Used in foreach loop to check if a child renderer is present */
458 GtkCellRenderer *renderer;
459 gboolean has_renderer;
462 /* Used in foreach loop to get a cell's allocation */
464 GtkCellRenderer *renderer;
465 GdkRectangle allocation;
466 } RendererAllocationData;
468 /* Used in foreach loop to render cells */
473 GdkRectangle focus_rect;
474 GtkCellRendererState render_flags;
475 guint paint_focus : 1;
477 guint first_focus : 1;
480 /* Used in foreach loop to get a cell by position */
484 GtkCellRenderer *renderer;
485 GdkRectangle cell_area;
486 } CellByPositionData;
488 /* Attribute/Cell metadata */
490 const gchar *attribute;
497 GtkCellLayoutDataFunc func;
499 GDestroyNotify destroy;
500 GtkCellLayout *proxy;
503 static CellInfo *cell_info_new (GtkCellLayoutDataFunc func,
505 GDestroyNotify destroy);
506 static void cell_info_free (CellInfo *info);
507 static CellAttribute *cell_attribute_new (GtkCellRenderer *renderer,
508 const gchar *attribute,
510 static void cell_attribute_free (CellAttribute *attribute);
511 static gint cell_attribute_find (CellAttribute *cell_attribute,
512 const gchar *attribute);
514 /* Internal functions/signal emissions */
515 static void gtk_cell_area_add_editable (GtkCellArea *area,
516 GtkCellRenderer *renderer,
517 GtkCellEditable *editable,
518 const GdkRectangle *cell_area);
519 static void gtk_cell_area_remove_editable (GtkCellArea *area,
520 GtkCellRenderer *renderer,
521 GtkCellEditable *editable);
522 static void gtk_cell_area_set_edit_widget (GtkCellArea *area,
523 GtkCellEditable *editable);
524 static void gtk_cell_area_set_edited_cell (GtkCellArea *area,
525 GtkCellRenderer *renderer);
528 /* Struct to pass data along while looping over
529 * cell renderers to apply attributes
535 gboolean is_expander;
536 gboolean is_expanded;
539 struct _GtkCellAreaPrivate
541 /* The GtkCellArea bookkeeps any connected
542 * attributes in this hash table.
544 GHashTable *cell_info;
546 /* Current path is saved as a side-effect
547 * of gtk_cell_area_apply_attributes()
551 /* Current cell being edited and editable widget used */
552 GtkCellEditable *edit_widget;
553 GtkCellRenderer *edited_cell;
555 /* Signal connections to the editable widget */
556 gulong remove_widget_id;
558 /* Currently focused cell */
559 GtkCellRenderer *focus_cell;
561 /* Tracking which cells are focus siblings of focusable cells */
562 GHashTable *focus_siblings;
564 /* Detail string to pass to gtk_paint_*() functions */
576 SIGNAL_APPLY_ATTRIBUTES,
578 SIGNAL_REMOVE_EDITABLE,
579 SIGNAL_FOCUS_CHANGED,
583 /* Keep the paramspec pool internal, no need to deliver notifications
584 * on cells. at least no perceived need for now
586 static GParamSpecPool *cell_property_pool = NULL;
587 static guint cell_area_signals[LAST_SIGNAL] = { 0 };
589 #define PARAM_SPEC_PARAM_ID(pspec) ((pspec)->param_id)
590 #define PARAM_SPEC_SET_PARAM_ID(pspec, id) ((pspec)->param_id = (id))
592 G_DEFINE_ABSTRACT_TYPE_WITH_CODE (GtkCellArea, gtk_cell_area, G_TYPE_INITIALLY_UNOWNED,
593 G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_LAYOUT,
594 gtk_cell_area_cell_layout_init)
595 G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
596 gtk_cell_area_buildable_init))
599 gtk_cell_area_init (GtkCellArea *area)
601 GtkCellAreaPrivate *priv;
603 area->priv = G_TYPE_INSTANCE_GET_PRIVATE (area,
608 priv->cell_info = g_hash_table_new_full (g_direct_hash,
611 (GDestroyNotify)cell_info_free);
613 priv->focus_siblings = g_hash_table_new_full (g_direct_hash,
616 (GDestroyNotify)g_list_free);
618 priv->focus_cell = NULL;
619 priv->edited_cell = NULL;
620 priv->edit_widget = NULL;
622 priv->remove_widget_id = 0;
626 gtk_cell_area_class_init (GtkCellAreaClass *class)
628 GObjectClass *object_class = G_OBJECT_CLASS (class);
631 object_class->dispose = gtk_cell_area_dispose;
632 object_class->finalize = gtk_cell_area_finalize;
633 object_class->get_property = gtk_cell_area_get_property;
634 object_class->set_property = gtk_cell_area_set_property;
638 class->remove = NULL;
639 class->foreach = NULL;
640 class->event = gtk_cell_area_real_event;
641 class->render = gtk_cell_area_real_render;
642 class->apply_attributes = gtk_cell_area_real_apply_attributes;
645 class->create_context = NULL;
646 class->get_request_mode = NULL;
647 class->get_preferred_width = NULL;
648 class->get_preferred_height = NULL;
649 class->get_preferred_height_for_width = gtk_cell_area_real_get_preferred_height_for_width;
650 class->get_preferred_width_for_height = gtk_cell_area_real_get_preferred_width_for_height;
653 class->is_activatable = gtk_cell_area_real_is_activatable;
654 class->activate = gtk_cell_area_real_activate;
659 * GtkCellArea::apply-attributes:
660 * @area: the #GtkCellArea to apply the attributes to
661 * @model: the #GtkTreeModel to apply the attributes from
662 * @iter: the #GtkTreeIter indicating which row to apply the attributes of
663 * @is_expander: whether the view shows children for this row
664 * @is_expanded: whether the view is currently showing the children of this row
666 * This signal is emitted whenever applying attributes to @area from @model
670 cell_area_signals[SIGNAL_APPLY_ATTRIBUTES] =
671 g_signal_new (I_("apply-attributes"),
672 G_OBJECT_CLASS_TYPE (object_class),
674 G_STRUCT_OFFSET (GtkCellAreaClass, apply_attributes),
676 _gtk_marshal_VOID__OBJECT_BOXED_BOOLEAN_BOOLEAN,
684 * GtkCellArea::add-editable:
685 * @area: the #GtkCellArea where editing started
686 * @renderer: the #GtkCellRenderer that started the edited
687 * @editable: the #GtkCellEditable widget to add
688 * @cell_area: the #GtkWidget relative #GdkRectangle coordinates
689 * where @editable should be added
690 * @path: the #GtkTreePath string this edit was initiated for
692 * Indicates that editing has started on @renderer and that @editable
693 * should be added to the owning cell layouting widget at @cell_area.
697 cell_area_signals[SIGNAL_ADD_EDITABLE] =
698 g_signal_new (I_("add-editable"),
699 G_OBJECT_CLASS_TYPE (object_class),
701 0, /* No class closure here */
703 _gtk_marshal_VOID__OBJECT_OBJECT_BOXED_STRING,
705 GTK_TYPE_CELL_RENDERER,
706 GTK_TYPE_CELL_EDITABLE,
712 * GtkCellArea::remove-editable:
713 * @area: the #GtkCellArea where editing finished
714 * @renderer: the #GtkCellRenderer that finished editeding
715 * @editable: the #GtkCellEditable widget to remove
717 * Indicates that editing finished on @renderer and that @editable
718 * should be removed from the owning cell layouting widget.
722 cell_area_signals[SIGNAL_REMOVE_EDITABLE] =
723 g_signal_new (I_("remove-editable"),
724 G_OBJECT_CLASS_TYPE (object_class),
726 0, /* No class closure here */
728 _gtk_marshal_VOID__OBJECT_OBJECT,
730 GTK_TYPE_CELL_RENDERER,
731 GTK_TYPE_CELL_EDITABLE);
734 * GtkCellArea::focus-changed:
735 * @area: the #GtkCellArea where focus changed
736 * @renderer: the #GtkCellRenderer that has focus
737 * @path: the current #GtkTreePath string set for @area
739 * Indicates that focus changed on this @area. This signal
740 * is emitted either as a result of focus handling or event
743 * It's possible that the signal is emitted even if the
744 * currently focused renderer did not change, this is
745 * because focus may change to the same renderer in the
746 * same cell area for a different row of data.
750 cell_area_signals[SIGNAL_FOCUS_CHANGED] =
751 g_signal_new (I_("focus-changed"),
752 G_OBJECT_CLASS_TYPE (object_class),
754 0, /* No class closure here */
756 _gtk_marshal_VOID__OBJECT_STRING,
758 GTK_TYPE_CELL_RENDERER,
763 * GtkCellArea:focus-cell:
765 * The cell in the area that currently has focus
769 g_object_class_install_property (object_class,
774 P_("The cell which currently has focus"),
775 GTK_TYPE_CELL_RENDERER,
776 GTK_PARAM_READWRITE));
779 * GtkCellArea:edited-cell:
781 * The cell in the area that is currently edited
783 * This property is read-only and only changes as
784 * a result of a call gtk_cell_area_activate_cell().
788 g_object_class_install_property (object_class,
793 P_("The cell which is currently being edited"),
794 GTK_TYPE_CELL_RENDERER,
798 * GtkCellArea:edit-widget:
800 * The widget currently editing the edited cell
802 * This property is read-only and only changes as
803 * a result of a call gtk_cell_area_activate_cell().
807 g_object_class_install_property (object_class,
812 P_("The widget currently editing the edited cell"),
813 GTK_TYPE_CELL_EDITABLE,
816 /* Pool for Cell Properties */
817 if (!cell_property_pool)
818 cell_property_pool = g_param_spec_pool_new (FALSE);
820 g_type_class_add_private (object_class, sizeof (GtkCellAreaPrivate));
823 /*************************************************************
825 *************************************************************/
827 cell_info_new (GtkCellLayoutDataFunc func,
829 GDestroyNotify destroy)
831 CellInfo *info = g_slice_new0 (CellInfo);
835 info->destroy = destroy;
841 cell_info_free (CellInfo *info)
844 info->destroy (info->data);
846 g_slist_foreach (info->attributes, (GFunc)cell_attribute_free, NULL);
847 g_slist_free (info->attributes);
849 g_slice_free (CellInfo, info);
852 static CellAttribute *
853 cell_attribute_new (GtkCellRenderer *renderer,
854 const gchar *attribute,
859 /* Check if the attribute really exists and point to
860 * the property string installed on the cell renderer
861 * class (dont dup the string)
863 pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (renderer), attribute);
867 CellAttribute *cell_attribute = g_slice_new (CellAttribute);
869 cell_attribute->attribute = pspec->name;
870 cell_attribute->column = column;
872 return cell_attribute;
879 cell_attribute_free (CellAttribute *attribute)
881 g_slice_free (CellAttribute, attribute);
884 /* GCompareFunc for g_slist_find_custom() */
886 cell_attribute_find (CellAttribute *cell_attribute,
887 const gchar *attribute)
889 return g_strcmp0 (cell_attribute->attribute, attribute);
892 /*************************************************************
894 *************************************************************/
896 gtk_cell_area_finalize (GObject *object)
898 GtkCellArea *area = GTK_CELL_AREA (object);
899 GtkCellAreaPrivate *priv = area->priv;
901 /* All cell renderers should already be removed at this point,
902 * just kill our (empty) hash tables here.
904 g_hash_table_destroy (priv->cell_info);
905 g_hash_table_destroy (priv->focus_siblings);
907 g_free (priv->current_path);
908 g_free (priv->style_detail);
910 G_OBJECT_CLASS (gtk_cell_area_parent_class)->finalize (object);
915 gtk_cell_area_dispose (GObject *object)
917 /* This removes every cell renderer that may be added to the GtkCellArea,
918 * subclasses should be breaking references to the GtkCellRenderers
921 gtk_cell_layout_clear (GTK_CELL_LAYOUT (object));
923 /* Remove any ref to a focused/edited cell */
924 gtk_cell_area_set_focus_cell (GTK_CELL_AREA (object), NULL);
925 gtk_cell_area_set_edited_cell (GTK_CELL_AREA (object), NULL);
926 gtk_cell_area_set_edit_widget (GTK_CELL_AREA (object), NULL);
928 G_OBJECT_CLASS (gtk_cell_area_parent_class)->dispose (object);
932 gtk_cell_area_set_property (GObject *object,
937 GtkCellArea *area = GTK_CELL_AREA (object);
941 case PROP_FOCUS_CELL:
942 gtk_cell_area_set_focus_cell (area, (GtkCellRenderer *)g_value_get_object (value));
945 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
951 gtk_cell_area_get_property (GObject *object,
956 GtkCellArea *area = GTK_CELL_AREA (object);
957 GtkCellAreaPrivate *priv = area->priv;
961 case PROP_FOCUS_CELL:
962 g_value_set_object (value, priv->focus_cell);
964 case PROP_EDITED_CELL:
965 g_value_set_object (value, priv->edited_cell);
967 case PROP_EDIT_WIDGET:
968 g_value_set_object (value, priv->edit_widget);
971 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
976 /*************************************************************
978 *************************************************************/
980 gtk_cell_area_real_event (GtkCellArea *area,
981 GtkCellAreaContext *context,
984 const GdkRectangle *cell_area,
985 GtkCellRendererState flags)
987 GtkCellAreaPrivate *priv = area->priv;
988 gboolean retval = FALSE;
990 if (event->type == GDK_KEY_PRESS && (flags & GTK_CELL_RENDERER_FOCUSED) != 0)
992 GdkEventKey *key_event = (GdkEventKey *)event;
994 /* Cancel any edits in progress */
995 if (priv->edited_cell && (key_event->keyval == GDK_KEY_Escape))
997 gtk_cell_area_stop_editing (area, TRUE);
1001 else if (event->type == GDK_BUTTON_PRESS)
1003 GdkEventButton *button_event = (GdkEventButton *)event;
1005 if (button_event->button == 1)
1007 GtkCellRenderer *renderer = NULL;
1008 GtkCellRenderer *focus_renderer;
1009 GdkRectangle alloc_area;
1010 gint event_x, event_y;
1012 /* We may need some semantics to tell us the offset of the event
1013 * window we are handling events for (i.e. GtkTreeView has a bin_window) */
1014 event_x = button_event->x;
1015 event_y = button_event->y;
1017 /* Dont try to search for an event coordinate that is not in the area, that will
1018 * trigger a runtime warning.
1020 if (event_x >= cell_area->x && event_x <= cell_area->x + cell_area->width &&
1021 event_y >= cell_area->y && event_y <= cell_area->y + cell_area->height)
1023 gtk_cell_area_get_cell_at_position (area, context, widget,
1024 cell_area, event_x, event_y,
1029 focus_renderer = gtk_cell_area_get_focus_from_sibling (area, renderer);
1030 if (!focus_renderer)
1031 focus_renderer = renderer;
1033 /* If we're already editing, cancel it and set focus */
1034 if (gtk_cell_area_get_edited_cell (area))
1036 /* XXX Was it really canceled in this case ? */
1037 gtk_cell_area_stop_editing (area, TRUE);
1038 gtk_cell_area_set_focus_cell (area, focus_renderer);
1043 /* If we are activating via a focus sibling,
1044 * we need to fetch the right cell area for the real event renderer */
1045 if (focus_renderer != renderer)
1046 gtk_cell_area_get_cell_allocation (area, context, widget, focus_renderer,
1047 cell_area, &alloc_area);
1049 gtk_cell_area_set_focus_cell (area, focus_renderer);
1050 retval = gtk_cell_area_activate_cell (area, widget, focus_renderer,
1051 event, &alloc_area, flags);
1061 render_cell (GtkCellRenderer *renderer,
1062 const GdkRectangle *cell_area,
1063 const GdkRectangle *cell_background,
1064 CellRenderData *data)
1066 GtkCellRenderer *focus_cell;
1067 GtkCellRendererState flags;
1068 GdkRectangle inner_area;
1070 focus_cell = gtk_cell_area_get_focus_cell (data->area);
1071 flags = data->render_flags;
1073 gtk_cell_area_inner_cell_area (data->area, data->widget, cell_area, &inner_area);
1075 if ((flags & GTK_CELL_RENDERER_FOCUSED) &&
1078 (renderer == focus_cell ||
1079 gtk_cell_area_is_focus_sibling (data->area, focus_cell, renderer)))))
1081 gint focus_line_width;
1082 GdkRectangle cell_focus;
1084 gtk_cell_renderer_get_aligned_area (renderer, data->widget, flags, &inner_area, &cell_focus);
1086 gtk_widget_style_get (data->widget,
1087 "focus-line-width", &focus_line_width,
1090 /* The focus rectangle is located around the aligned area of the cell */
1091 cell_focus.x -= focus_line_width;
1092 cell_focus.y -= focus_line_width;
1093 cell_focus.width += 2 * focus_line_width;
1094 cell_focus.height += 2 * focus_line_width;
1096 if (data->first_focus)
1098 data->first_focus = FALSE;
1099 data->focus_rect = cell_focus;
1103 gdk_rectangle_union (&data->focus_rect, &cell_focus, &data->focus_rect);
1107 flags &= ~GTK_CELL_RENDERER_FOCUSED;
1109 gtk_cell_renderer_render (renderer, data->cr, data->widget,
1110 cell_background, &inner_area, flags);
1116 gtk_cell_area_real_render (GtkCellArea *area,
1117 GtkCellAreaContext *context,
1120 const GdkRectangle *background_area,
1121 const GdkRectangle *cell_area,
1122 GtkCellRendererState flags,
1123 gboolean paint_focus)
1125 CellRenderData render_data =
1136 /* Make sure we dont paint a focus rectangle while there
1137 * is an editable widget in play
1139 if (gtk_cell_area_get_edited_cell (area))
1140 render_data.paint_focus = FALSE;
1142 /* If no cell can activate but the caller wants focus painted,
1143 * then we paint focus around all cells */
1144 if ((flags & GTK_CELL_RENDERER_FOCUSED) != 0 && paint_focus &&
1145 !gtk_cell_area_is_activatable (area))
1146 render_data.focus_all = TRUE;
1148 gtk_cell_area_foreach_alloc (area, context, widget, cell_area, background_area,
1149 (GtkCellAllocCallback)render_cell, &render_data);
1151 if (render_data.paint_focus &&
1152 render_data.focus_rect.width != 0 &&
1153 render_data.focus_rect.height != 0)
1155 GtkStateType renderer_state =
1156 flags & GTK_CELL_RENDERER_SELECTED ? GTK_STATE_SELECTED :
1157 (flags & GTK_CELL_RENDERER_PRELIT ? GTK_STATE_PRELIGHT :
1158 (flags & GTK_CELL_RENDERER_INSENSITIVE ? GTK_STATE_INSENSITIVE : GTK_STATE_NORMAL));
1162 gdk_cairo_rectangle (cr, background_area);
1165 gtk_paint_focus (gtk_widget_get_style (widget), cr,
1166 renderer_state, widget,
1167 gtk_cell_area_get_style_detail (area),
1168 render_data.focus_rect.x, render_data.focus_rect.y,
1169 render_data.focus_rect.width, render_data.focus_rect.height);
1176 apply_cell_attributes (GtkCellRenderer *renderer,
1178 AttributeData *data)
1180 CellAttribute *attribute;
1182 GValue value = { 0, };
1183 gboolean is_expander;
1184 gboolean is_expanded;
1186 g_object_freeze_notify (G_OBJECT (renderer));
1188 /* Whether a row expands or is presently expanded can only be
1189 * provided by the view (as these states can vary across views
1190 * accessing the same model).
1192 g_object_get (renderer, "is-expander", &is_expander, NULL);
1193 if (is_expander != data->is_expander)
1194 g_object_set (renderer, "is-expander", data->is_expander, NULL);
1196 g_object_get (renderer, "is-expanded", &is_expanded, NULL);
1197 if (is_expanded != data->is_expanded)
1198 g_object_set (renderer, "is-expanded", data->is_expanded, NULL);
1200 /* Apply the attributes directly to the renderer */
1201 for (list = info->attributes; list; list = list->next)
1203 attribute = list->data;
1205 gtk_tree_model_get_value (data->model, data->iter, attribute->column, &value);
1206 g_object_set_property (G_OBJECT (renderer), attribute->attribute, &value);
1207 g_value_unset (&value);
1210 /* Call any GtkCellLayoutDataFunc that may have been set by the user
1213 info->func (info->proxy ? info->proxy : GTK_CELL_LAYOUT (data->area), renderer,
1214 data->model, data->iter, info->data);
1216 g_object_thaw_notify (G_OBJECT (renderer));
1220 gtk_cell_area_real_apply_attributes (GtkCellArea *area,
1221 GtkTreeModel *tree_model,
1223 gboolean is_expander,
1224 gboolean is_expanded)
1227 GtkCellAreaPrivate *priv;
1233 /* Feed in data needed to apply to every renderer */
1235 data.model = tree_model;
1237 data.is_expander = is_expander;
1238 data.is_expanded = is_expanded;
1240 /* Go over any cells that have attributes or custom GtkCellLayoutDataFuncs and
1241 * apply the data from the treemodel */
1242 g_hash_table_foreach (priv->cell_info, (GHFunc)apply_cell_attributes, &data);
1244 /* Update the currently applied path */
1245 g_free (priv->current_path);
1246 path = gtk_tree_model_get_path (tree_model, iter);
1247 priv->current_path = gtk_tree_path_to_string (path);
1248 gtk_tree_path_free (path);
1252 gtk_cell_area_real_get_preferred_height_for_width (GtkCellArea *area,
1253 GtkCellAreaContext *context,
1256 gint *minimum_height,
1257 gint *natural_height)
1259 /* If the area doesnt do height-for-width, fallback on base preferred height */
1260 GTK_CELL_AREA_GET_CLASS (area)->get_preferred_width (area, context, widget, minimum_height, natural_height);
1264 gtk_cell_area_real_get_preferred_width_for_height (GtkCellArea *area,
1265 GtkCellAreaContext *context,
1268 gint *minimum_width,
1269 gint *natural_width)
1271 /* If the area doesnt do width-for-height, fallback on base preferred width */
1272 GTK_CELL_AREA_GET_CLASS (area)->get_preferred_width (area, context, widget, minimum_width, natural_width);
1276 get_is_activatable (GtkCellRenderer *renderer,
1277 gboolean *activatable)
1280 if (gtk_cell_renderer_is_activatable (renderer))
1281 *activatable = TRUE;
1283 return *activatable;
1287 gtk_cell_area_real_is_activatable (GtkCellArea *area)
1289 gboolean activatable = FALSE;
1291 /* Checks if any renderer can focus for the currently applied
1294 * Subclasses can override this in the case that they are also
1295 * rendering widgets as well as renderers.
1297 gtk_cell_area_foreach (area, (GtkCellCallback)get_is_activatable, &activatable);
1303 gtk_cell_area_real_activate (GtkCellArea *area,
1304 GtkCellAreaContext *context,
1306 const GdkRectangle *cell_area,
1307 GtkCellRendererState flags,
1310 GtkCellAreaPrivate *priv = area->priv;
1311 GdkRectangle renderer_area;
1312 GtkCellRenderer *activate_cell = NULL;
1313 GtkCellRendererMode mode;
1315 if (priv->focus_cell)
1317 g_object_get (priv->focus_cell, "mode", &mode, NULL);
1319 if (gtk_cell_renderer_get_visible (priv->focus_cell) &&
1320 (edit_only ? mode == GTK_CELL_RENDERER_MODE_EDITABLE :
1321 mode != GTK_CELL_RENDERER_MODE_INERT))
1322 activate_cell = priv->focus_cell;
1328 /* GtkTreeView sometimes wants to activate a cell when no
1329 * cells are in focus.
1331 cells = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (area));
1332 for (l = cells; l && !activate_cell; l = l->next)
1334 GtkCellRenderer *renderer = l->data;
1336 g_object_get (renderer, "mode", &mode, NULL);
1338 if (gtk_cell_renderer_get_visible (renderer) &&
1339 (edit_only ? mode == GTK_CELL_RENDERER_MODE_EDITABLE :
1340 mode != GTK_CELL_RENDERER_MODE_INERT))
1341 activate_cell = renderer;
1343 g_list_free (cells);
1348 /* Get the allocation of the focused cell.
1350 gtk_cell_area_get_cell_allocation (area, context, widget, activate_cell,
1351 cell_area, &renderer_area);
1353 /* Activate or Edit the cell
1355 * Currently just not sending an event, renderers afaics dont use
1356 * the event argument anyway, worst case is we can synthesize one.
1358 if (gtk_cell_area_activate_cell (area, widget, activate_cell, NULL,
1359 &renderer_area, flags))
1366 /*************************************************************
1367 * GtkCellLayoutIface *
1368 *************************************************************/
1370 gtk_cell_area_cell_layout_init (GtkCellLayoutIface *iface)
1372 iface->pack_start = gtk_cell_area_pack_default;
1373 iface->pack_end = gtk_cell_area_pack_default;
1374 iface->clear = gtk_cell_area_clear;
1375 iface->add_attribute = gtk_cell_area_add_attribute;
1376 iface->set_cell_data_func = gtk_cell_area_set_cell_data_func;
1377 iface->clear_attributes = gtk_cell_area_clear_attributes;
1378 iface->reorder = gtk_cell_area_reorder;
1379 iface->get_cells = gtk_cell_area_get_cells;
1380 iface->get_area = gtk_cell_area_get_area;
1384 gtk_cell_area_pack_default (GtkCellLayout *cell_layout,
1385 GtkCellRenderer *renderer,
1388 gtk_cell_area_add (GTK_CELL_AREA (cell_layout), renderer);
1392 gtk_cell_area_clear (GtkCellLayout *cell_layout)
1394 GtkCellArea *area = GTK_CELL_AREA (cell_layout);
1396 gtk_cell_layout_get_cells (cell_layout);
1398 for (l = cells; l; l = l->next)
1400 GtkCellRenderer *renderer = l->data;
1401 gtk_cell_area_remove (area, renderer);
1404 g_list_free (cells);
1408 gtk_cell_area_add_attribute (GtkCellLayout *cell_layout,
1409 GtkCellRenderer *renderer,
1410 const gchar *attribute,
1413 gtk_cell_area_attribute_connect (GTK_CELL_AREA (cell_layout),
1414 renderer, attribute, column);
1418 gtk_cell_area_set_cell_data_func (GtkCellLayout *cell_layout,
1419 GtkCellRenderer *renderer,
1420 GtkCellLayoutDataFunc func,
1422 GDestroyNotify destroy)
1424 GtkCellArea *area = GTK_CELL_AREA (cell_layout);
1426 _gtk_cell_area_set_cell_data_func_with_proxy (area, renderer, (GFunc)func, func_data, destroy, NULL);
1430 gtk_cell_area_clear_attributes (GtkCellLayout *cell_layout,
1431 GtkCellRenderer *renderer)
1433 GtkCellArea *area = GTK_CELL_AREA (cell_layout);
1434 GtkCellAreaPrivate *priv = area->priv;
1437 info = g_hash_table_lookup (priv->cell_info, renderer);
1441 g_slist_foreach (info->attributes, (GFunc)cell_attribute_free, NULL);
1442 g_slist_free (info->attributes);
1444 info->attributes = NULL;
1449 gtk_cell_area_reorder (GtkCellLayout *cell_layout,
1450 GtkCellRenderer *cell,
1453 g_warning ("GtkCellLayout::reorder not implemented for `%s'",
1454 g_type_name (G_TYPE_FROM_INSTANCE (cell_layout)));
1458 accum_cells (GtkCellRenderer *renderer,
1461 *accum = g_list_prepend (*accum, renderer);
1467 gtk_cell_area_get_cells (GtkCellLayout *cell_layout)
1469 GList *cells = NULL;
1471 gtk_cell_area_foreach (GTK_CELL_AREA (cell_layout),
1472 (GtkCellCallback)accum_cells,
1475 return g_list_reverse (cells);
1478 static GtkCellArea *
1479 gtk_cell_area_get_area (GtkCellLayout *cell_layout)
1481 return GTK_CELL_AREA (cell_layout);
1484 /*************************************************************
1485 * GtkBuildableIface *
1486 *************************************************************/
1488 gtk_cell_area_buildable_init (GtkBuildableIface *iface)
1490 iface->add_child = _gtk_cell_layout_buildable_add_child;
1491 iface->custom_tag_start = _gtk_cell_layout_buildable_custom_tag_start;
1492 iface->custom_tag_end = gtk_cell_area_buildable_custom_tag_end;
1496 gtk_cell_area_buildable_custom_tag_end (GtkBuildable *buildable,
1497 GtkBuilder *builder,
1499 const gchar *tagname,
1502 /* Just ignore the boolean return from here */
1503 _gtk_cell_layout_buildable_custom_tag_end (buildable, builder, child, tagname, data);
1506 /*************************************************************
1508 *************************************************************/
1511 * gtk_cell_area_add:
1512 * @area: a #GtkCellArea
1513 * @renderer: the #GtkCellRenderer to add to @area
1515 * Adds @renderer to @area with the default child cell properties.
1520 gtk_cell_area_add (GtkCellArea *area,
1521 GtkCellRenderer *renderer)
1523 GtkCellAreaClass *class;
1525 g_return_if_fail (GTK_IS_CELL_AREA (area));
1526 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
1528 class = GTK_CELL_AREA_GET_CLASS (area);
1531 class->add (area, renderer);
1533 g_warning ("GtkCellAreaClass::add not implemented for `%s'",
1534 g_type_name (G_TYPE_FROM_INSTANCE (area)));
1538 * gtk_cell_area_remove:
1539 * @area: a #GtkCellArea
1540 * @renderer: the #GtkCellRenderer to remove from @area
1542 * Removes @renderer from @area.
1547 gtk_cell_area_remove (GtkCellArea *area,
1548 GtkCellRenderer *renderer)
1550 GtkCellAreaClass *class;
1551 GtkCellAreaPrivate *priv;
1552 GList *renderers, *l;
1554 g_return_if_fail (GTK_IS_CELL_AREA (area));
1555 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
1557 class = GTK_CELL_AREA_GET_CLASS (area);
1560 /* Remove any custom attributes and custom cell data func here first */
1561 g_hash_table_remove (priv->cell_info, renderer);
1563 /* Remove focus siblings of this renderer */
1564 g_hash_table_remove (priv->focus_siblings, renderer);
1566 /* Remove this renderer from any focus renderer's sibling list */
1567 renderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (area));
1569 for (l = renderers; l; l = l->next)
1571 GtkCellRenderer *focus_renderer = l->data;
1573 if (gtk_cell_area_is_focus_sibling (area, focus_renderer, renderer))
1575 gtk_cell_area_remove_focus_sibling (area, focus_renderer, renderer);
1580 g_list_free (renderers);
1583 class->remove (area, renderer);
1585 g_warning ("GtkCellAreaClass::remove not implemented for `%s'",
1586 g_type_name (G_TYPE_FROM_INSTANCE (area)));
1590 get_has_renderer (GtkCellRenderer *renderer,
1591 HasRendererCheck *check)
1593 if (renderer == check->renderer)
1594 check->has_renderer = TRUE;
1596 return check->has_renderer;
1600 * gtk_cell_area_has_renderer:
1601 * @area: a #GtkCellArea
1602 * @renderer: the #GtkCellRenderer to check
1604 * Checks if @area contains @renderer.
1606 * Return value: %TRUE if @renderer is in the @area.
1611 gtk_cell_area_has_renderer (GtkCellArea *area,
1612 GtkCellRenderer *renderer)
1614 HasRendererCheck check = { renderer, FALSE };
1616 g_return_val_if_fail (GTK_IS_CELL_AREA (area), FALSE);
1617 g_return_val_if_fail (GTK_IS_CELL_RENDERER (renderer), FALSE);
1619 gtk_cell_area_foreach (area, (GtkCellCallback)get_has_renderer, &check);
1621 return check.has_renderer;
1625 * gtk_cell_area_foreach:
1626 * @area: a #GtkCellArea
1627 * @callback: (scope call): the #GtkCellCallback to call
1628 * @callback_data: user provided data pointer
1630 * Calls @callback for every #GtkCellRenderer in @area.
1635 gtk_cell_area_foreach (GtkCellArea *area,
1636 GtkCellCallback callback,
1637 gpointer callback_data)
1639 GtkCellAreaClass *class;
1641 g_return_if_fail (GTK_IS_CELL_AREA (area));
1642 g_return_if_fail (callback != NULL);
1644 class = GTK_CELL_AREA_GET_CLASS (area);
1647 class->foreach (area, callback, callback_data);
1649 g_warning ("GtkCellAreaClass::foreach not implemented for `%s'",
1650 g_type_name (G_TYPE_FROM_INSTANCE (area)));
1654 * gtk_cell_area_foreach_alloc:
1655 * @area: a #GtkCellArea
1656 * @context: the #GtkCellAreaContext for this row of data.
1657 * @widget: the #GtkWidget that @area is rendering to
1658 * @cell_area: the @widget relative coordinates and size for @area
1659 * @background_area: the @widget relative coordinates of the background area
1660 * @callback: (scope call): the #GtkCellAllocCallback to call
1661 * @callback_data: user provided data pointer
1663 * Calls @callback for every #GtkCellRenderer in @area with the
1664 * allocated rectangle inside @cell_area.
1669 gtk_cell_area_foreach_alloc (GtkCellArea *area,
1670 GtkCellAreaContext *context,
1672 const GdkRectangle *cell_area,
1673 const GdkRectangle *background_area,
1674 GtkCellAllocCallback callback,
1675 gpointer callback_data)
1677 GtkCellAreaClass *class;
1679 g_return_if_fail (GTK_IS_CELL_AREA (area));
1680 g_return_if_fail (GTK_IS_CELL_AREA_CONTEXT (context));
1681 g_return_if_fail (GTK_IS_WIDGET (widget));
1682 g_return_if_fail (cell_area != NULL);
1683 g_return_if_fail (callback != NULL);
1685 class = GTK_CELL_AREA_GET_CLASS (area);
1687 if (class->foreach_alloc)
1688 class->foreach_alloc (area, context, widget, cell_area, background_area, callback, callback_data);
1690 g_warning ("GtkCellAreaClass::foreach_alloc not implemented for `%s'",
1691 g_type_name (G_TYPE_FROM_INSTANCE (area)));
1695 * gtk_cell_area_event:
1696 * @area: a #GtkCellArea
1697 * @context: the #GtkCellAreaContext for this row of data.
1698 * @widget: the #GtkWidget that @area is rendering to
1699 * @event: the #GdkEvent to handle
1700 * @cell_area: the @widget relative coordinates for @area
1701 * @flags: the #GtkCellRendererState for @area in this row.
1703 * Delegates event handling to a #GtkCellArea.
1705 * Return value: %TRUE if the event was handled by @area.
1710 gtk_cell_area_event (GtkCellArea *area,
1711 GtkCellAreaContext *context,
1714 const GdkRectangle *cell_area,
1715 GtkCellRendererState flags)
1717 GtkCellAreaClass *class;
1719 g_return_val_if_fail (GTK_IS_CELL_AREA (area), 0);
1720 g_return_val_if_fail (GTK_IS_CELL_AREA_CONTEXT (context), 0);
1721 g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
1722 g_return_val_if_fail (event != NULL, 0);
1723 g_return_val_if_fail (cell_area != NULL, 0);
1725 class = GTK_CELL_AREA_GET_CLASS (area);
1728 return class->event (area, context, widget, event, cell_area, flags);
1730 g_warning ("GtkCellAreaClass::event not implemented for `%s'",
1731 g_type_name (G_TYPE_FROM_INSTANCE (area)));
1736 * gtk_cell_area_render:
1737 * @area: a #GtkCellArea
1738 * @context: the #GtkCellAreaContext for this row of data.
1739 * @widget: the #GtkWidget that @area is rendering to
1740 * @cr: the #cairo_t to render with
1741 * @background_area: the @widget relative coordinates for @area's background
1742 * @cell_area: the @widget relative coordinates for @area
1743 * @flags: the #GtkCellRendererState for @area in this row.
1744 * @paint_focus: whether @area should paint focus on focused cells for focused rows or not.
1746 * Renders @area's cells according to @area's layout onto @widget at
1747 * the given coordinates.
1752 gtk_cell_area_render (GtkCellArea *area,
1753 GtkCellAreaContext *context,
1756 const GdkRectangle *background_area,
1757 const GdkRectangle *cell_area,
1758 GtkCellRendererState flags,
1759 gboolean paint_focus)
1761 GtkCellAreaClass *class;
1763 g_return_if_fail (GTK_IS_CELL_AREA (area));
1764 g_return_if_fail (GTK_IS_CELL_AREA_CONTEXT (context));
1765 g_return_if_fail (GTK_IS_WIDGET (widget));
1766 g_return_if_fail (cr != NULL);
1767 g_return_if_fail (background_area != NULL);
1768 g_return_if_fail (cell_area != NULL);
1770 class = GTK_CELL_AREA_GET_CLASS (area);
1773 class->render (area, context, widget, cr, background_area, cell_area, flags, paint_focus);
1775 g_warning ("GtkCellAreaClass::render not implemented for `%s'",
1776 g_type_name (G_TYPE_FROM_INSTANCE (area)));
1780 * gtk_cell_area_set_style_detail:
1781 * @area: a #GtkCellArea
1782 * @detail: the #GtkStyle detail string to set
1784 * Sets the detail string used in any gtk_paint_*() functions
1790 gtk_cell_area_set_style_detail (GtkCellArea *area,
1791 const gchar *detail)
1793 GtkCellAreaPrivate *priv;
1795 g_return_if_fail (GTK_IS_CELL_AREA (area));
1799 if (g_strcmp0 (priv->style_detail, detail) != 0)
1801 g_free (priv->style_detail);
1802 priv->style_detail = g_strdup (detail);
1807 * gtk_cell_area_get_style_detail:
1808 * @area: a #GtkCellArea
1810 * Gets the detail string used in any gtk_paint_*() functions
1813 * Return value: the detail string, the string belongs to the area and should not be freed.
1817 G_CONST_RETURN gchar *
1818 gtk_cell_area_get_style_detail (GtkCellArea *area)
1820 GtkCellAreaPrivate *priv;
1822 g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
1826 return priv->style_detail;
1830 get_cell_allocation (GtkCellRenderer *renderer,
1831 const GdkRectangle *cell_area,
1832 const GdkRectangle *cell_background,
1833 RendererAllocationData *data)
1835 if (data->renderer == renderer)
1836 data->allocation = *cell_area;
1838 return (data->renderer == renderer);
1842 * gtk_cell_area_get_cell_allocation:
1843 * @area: a #GtkCellArea
1844 * @context: the #GtkCellAreaContext used to hold sizes for @area.
1845 * @widget: the #GtkWidget that @area is rendering on
1846 * @renderer: the #GtkCellRenderer to get the allocation for
1847 * @cell_area: the whole allocated area for @area in @widget
1849 * @allocation: (out): where to store the allocation for @renderer
1851 * Derives the allocation of @renderer inside @area if @area
1852 * were to be renderered in @cell_area.
1857 gtk_cell_area_get_cell_allocation (GtkCellArea *area,
1858 GtkCellAreaContext *context,
1860 GtkCellRenderer *renderer,
1861 const GdkRectangle *cell_area,
1862 GdkRectangle *allocation)
1864 RendererAllocationData data = { renderer, { 0, } };
1866 g_return_if_fail (GTK_IS_CELL_AREA (area));
1867 g_return_if_fail (GTK_IS_CELL_AREA_CONTEXT (context));
1868 g_return_if_fail (GTK_IS_WIDGET (widget));
1869 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
1870 g_return_if_fail (cell_area != NULL);
1871 g_return_if_fail (allocation != NULL);
1873 gtk_cell_area_foreach_alloc (area, context, widget, cell_area, cell_area,
1874 (GtkCellAllocCallback)get_cell_allocation, &data);
1876 *allocation = data.allocation;
1880 get_cell_by_position (GtkCellRenderer *renderer,
1881 const GdkRectangle *cell_area,
1882 const GdkRectangle *cell_background,
1883 CellByPositionData *data)
1885 if (data->x >= cell_area->x && data->x < cell_area->x + cell_area->width &&
1886 data->y >= cell_area->y && data->y < cell_area->y + cell_area->height)
1888 data->renderer = renderer;
1889 data->cell_area = *cell_area;
1892 return (data->renderer != NULL);
1896 * gtk_cell_area_get_cell_at_position:
1897 * @area: a #GtkCellArea
1898 * @context: the #GtkCellAreaContext used to hold sizes for @area.
1899 * @widget: the #GtkWidget that @area is rendering on
1900 * @cell_area: the whole allocated area for @area in @widget
1902 * @x: the x position
1903 * @y: the y position
1904 * @alloc_area: (out) (allow-none): where to store the inner allocated area of the
1905 * returned cell renderer, or %NULL.
1907 * Gets the #GtkCellRenderer at @x and @y coordinates inside @area and optionally
1908 * returns the full cell allocation for it inside @cell_area.
1910 * Return value: (transfer none): the #GtkCellRenderer at @x and @y.
1915 gtk_cell_area_get_cell_at_position (GtkCellArea *area,
1916 GtkCellAreaContext *context,
1918 const GdkRectangle *cell_area,
1921 GdkRectangle *alloc_area)
1923 CellByPositionData data = { x, y, NULL, { 0, } };
1925 g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
1926 g_return_val_if_fail (GTK_IS_CELL_AREA_CONTEXT (context), NULL);
1927 g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
1928 g_return_val_if_fail (cell_area != NULL, NULL);
1929 g_return_val_if_fail (x >= cell_area->x && x <= cell_area->x + cell_area->width, NULL);
1930 g_return_val_if_fail (y >= cell_area->y && y <= cell_area->y + cell_area->height, NULL);
1932 gtk_cell_area_foreach_alloc (area, context, widget, cell_area, cell_area,
1933 (GtkCellAllocCallback)get_cell_by_position, &data);
1936 *alloc_area = data.cell_area;
1938 return data.renderer;
1941 /*************************************************************
1943 *************************************************************/
1945 * gtk_cell_area_create_context:
1946 * @area: a #GtkCellArea
1948 * Creates a #GtkCellAreaContext to be used with @area for
1949 * all purposes. #GtkCellAreaContext stores geometry information
1950 * for rows for which it was operated on, it is important to use
1951 * the same context for the same row of data at all times (i.e.
1952 * one should render and handle events with the same #GtkCellAreaContext
1953 * which was used to request the size of those rows of data).
1955 * Return value: (transfer full): a newly created #GtkCellAreaContext which can be used with @area.
1959 GtkCellAreaContext *
1960 gtk_cell_area_create_context (GtkCellArea *area)
1962 GtkCellAreaClass *class;
1964 g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
1966 class = GTK_CELL_AREA_GET_CLASS (area);
1968 if (class->create_context)
1969 return class->create_context (area);
1971 g_warning ("GtkCellAreaClass::create_context not implemented for `%s'",
1972 g_type_name (G_TYPE_FROM_INSTANCE (area)));
1978 * gtk_cell_area_copy_context:
1979 * @area: a #GtkCellArea
1980 * @context: the #GtkCellAreaContext to copy
1982 * This is sometimes needed for cases where rows need to share
1983 * alignments in one orientation but may be separately grouped
1984 * in the opposing orientation.
1986 * For instance, #GtkIconView creates all icons (rows) to have
1987 * the same width and the cells theirin to have the same
1988 * horizontal alignments. However each row of icons may have
1989 * a separate collective height. #GtkIconView uses this to
1990 * request the heights of each row based on a context which
1991 * was already used to request all the row widths that are
1994 * Return value: (transfer full): a newly created #GtkCellAreaContext copy of @context.
1998 GtkCellAreaContext *
1999 gtk_cell_area_copy_context (GtkCellArea *area,
2000 GtkCellAreaContext *context)
2002 GtkCellAreaClass *class;
2004 g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
2005 g_return_val_if_fail (GTK_IS_CELL_AREA_CONTEXT (context), NULL);
2007 class = GTK_CELL_AREA_GET_CLASS (area);
2009 if (class->copy_context)
2010 return class->copy_context (area, context);
2012 g_warning ("GtkCellAreaClass::copy_context not implemented for `%s'",
2013 g_type_name (G_TYPE_FROM_INSTANCE (area)));
2019 * gtk_cell_area_get_request_mode:
2020 * @area: a #GtkCellArea
2022 * Gets whether the area prefers a height-for-width layout
2023 * or a width-for-height layout.
2025 * Return value: The #GtkSizeRequestMode preferred by @area.
2030 gtk_cell_area_get_request_mode (GtkCellArea *area)
2032 GtkCellAreaClass *class;
2034 g_return_val_if_fail (GTK_IS_CELL_AREA (area),
2035 GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH);
2037 class = GTK_CELL_AREA_GET_CLASS (area);
2039 if (class->get_request_mode)
2040 return class->get_request_mode (area);
2042 g_warning ("GtkCellAreaClass::get_request_mode not implemented for `%s'",
2043 g_type_name (G_TYPE_FROM_INSTANCE (area)));
2045 return GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH;
2049 * gtk_cell_area_get_preferred_width:
2050 * @area: a #GtkCellArea
2051 * @context: the #GtkCellAreaContext to perform this request with
2052 * @widget: the #GtkWidget where @area will be rendering
2053 * @minimum_width: (out) (allow-none): location to store the minimum width, or %NULL
2054 * @natural_width: (out) (allow-none): location to store the natural width, or %NULL
2056 * Retrieves a cell area's initial minimum and natural width.
2058 * @area will store some geometrical information in @context along the way,
2059 * when requesting sizes over an arbitrary number of rows, its not important
2060 * to check the @minimum_width and @natural_width of this call but rather to
2061 * consult gtk_cell_area_context_get_preferred_width() after a series of
2067 gtk_cell_area_get_preferred_width (GtkCellArea *area,
2068 GtkCellAreaContext *context,
2070 gint *minimum_width,
2071 gint *natural_width)
2073 GtkCellAreaClass *class;
2075 g_return_if_fail (GTK_IS_CELL_AREA (area));
2076 g_return_if_fail (GTK_IS_WIDGET (widget));
2078 class = GTK_CELL_AREA_GET_CLASS (area);
2080 if (class->get_preferred_width)
2081 class->get_preferred_width (area, context, widget, minimum_width, natural_width);
2083 g_warning ("GtkCellAreaClass::get_preferred_width not implemented for `%s'",
2084 g_type_name (G_TYPE_FROM_INSTANCE (area)));
2088 * gtk_cell_area_get_preferred_height_for_width:
2089 * @area: a #GtkCellArea
2090 * @context: the #GtkCellAreaContext which has already been requested for widths.
2091 * @widget: the #GtkWidget where @area will be rendering
2092 * @width: the width for which to check the height of this area
2093 * @minimum_height: (out) (allow-none): location to store the minimum height, or %NULL
2094 * @natural_height: (out) (allow-none): location to store the natural height, or %NULL
2096 * Retrieves a cell area's minimum and natural height if it would be given
2097 * the specified @width.
2099 * @area stores some geometrical information in @context along the way
2100 * while calling gtk_cell_area_get_preferred_width(), it's important to
2101 * perform a series of gtk_cell_area_get_preferred_width() requests with
2102 * @context first and then call gtk_cell_area_get_preferred_height_for_width()
2103 * on each cell area individually to get the height for width of each
2104 * fully requested row.
2106 * If at some point, the width of a single row changes, it should be
2107 * requested with gtk_cell_area_get_preferred_width() again and then
2108 * the full width of the requested rows checked again with
2109 * gtk_cell_area_context_get_preferred_width().
2114 gtk_cell_area_get_preferred_height_for_width (GtkCellArea *area,
2115 GtkCellAreaContext *context,
2118 gint *minimum_height,
2119 gint *natural_height)
2121 GtkCellAreaClass *class;
2123 g_return_if_fail (GTK_IS_CELL_AREA (area));
2124 g_return_if_fail (GTK_IS_WIDGET (widget));
2126 class = GTK_CELL_AREA_GET_CLASS (area);
2127 class->get_preferred_height_for_width (area, context, widget, width, minimum_height, natural_height);
2132 * gtk_cell_area_get_preferred_height:
2133 * @area: a #GtkCellArea
2134 * @context: the #GtkCellAreaContext to perform this request with
2135 * @widget: the #GtkWidget where @area will be rendering
2136 * @minimum_height: (out) (allow-none): location to store the minimum height, or %NULL
2137 * @natural_height: (out) (allow-none): location to store the natural height, or %NULL
2139 * Retrieves a cell area's initial minimum and natural height.
2141 * @area will store some geometrical information in @context along the way,
2142 * when requesting sizes over an arbitrary number of rows, its not important
2143 * to check the @minimum_height and @natural_height of this call but rather to
2144 * consult gtk_cell_area_context_get_preferred_height() after a series of
2150 gtk_cell_area_get_preferred_height (GtkCellArea *area,
2151 GtkCellAreaContext *context,
2153 gint *minimum_height,
2154 gint *natural_height)
2156 GtkCellAreaClass *class;
2158 g_return_if_fail (GTK_IS_CELL_AREA (area));
2159 g_return_if_fail (GTK_IS_WIDGET (widget));
2161 class = GTK_CELL_AREA_GET_CLASS (area);
2163 if (class->get_preferred_height)
2164 class->get_preferred_height (area, context, widget, minimum_height, natural_height);
2166 g_warning ("GtkCellAreaClass::get_preferred_height not implemented for `%s'",
2167 g_type_name (G_TYPE_FROM_INSTANCE (area)));
2171 * gtk_cell_area_get_preferred_width_for_height:
2172 * @area: a #GtkCellArea
2173 * @context: the #GtkCellAreaContext which has already been requested for widths.
2174 * @widget: the #GtkWidget where @area will be rendering
2175 * @height: the height for which to check the width of this area
2176 * @minimum_width: (out) (allow-none): location to store the minimum width, or %NULL
2177 * @natural_width: (out) (allow-none): location to store the natural width, or %NULL
2179 * Retrieves a cell area's minimum and natural width if it would be given
2180 * the specified @height.
2182 * @area stores some geometrical information in @context along the way
2183 * while calling gtk_cell_area_get_preferred_height(), it's important to
2184 * perform a series of gtk_cell_area_get_preferred_height() requests with
2185 * @context first and then call gtk_cell_area_get_preferred_width_for_height()
2186 * on each cell area individually to get the height for width of each
2187 * fully requested row.
2189 * If at some point, the height of a single row changes, it should be
2190 * requested with gtk_cell_area_get_preferred_height() again and then
2191 * the full height of the requested rows checked again with
2192 * gtk_cell_area_context_get_preferred_height().
2197 gtk_cell_area_get_preferred_width_for_height (GtkCellArea *area,
2198 GtkCellAreaContext *context,
2201 gint *minimum_width,
2202 gint *natural_width)
2204 GtkCellAreaClass *class;
2206 g_return_if_fail (GTK_IS_CELL_AREA (area));
2207 g_return_if_fail (GTK_IS_WIDGET (widget));
2209 class = GTK_CELL_AREA_GET_CLASS (area);
2210 class->get_preferred_width_for_height (area, context, widget, height, minimum_width, natural_width);
2213 /*************************************************************
2215 *************************************************************/
2218 * gtk_cell_area_attribute_connect:
2219 * @area: a #GtkCellArea
2220 * @renderer: the #GtkCellRenderer to connect an attribute for
2221 * @attribute: the attribute name
2222 * @column: the #GtkTreeModel column to fetch attribute values from
2224 * Connects an @attribute to apply values from @column for the
2225 * #GtkTreeModel in use.
2230 gtk_cell_area_attribute_connect (GtkCellArea *area,
2231 GtkCellRenderer *renderer,
2232 const gchar *attribute,
2235 GtkCellAreaPrivate *priv;
2237 CellAttribute *cell_attribute;
2239 g_return_if_fail (GTK_IS_CELL_AREA (area));
2240 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
2241 g_return_if_fail (attribute != NULL);
2242 g_return_if_fail (gtk_cell_area_has_renderer (area, renderer));
2245 info = g_hash_table_lookup (priv->cell_info, renderer);
2249 info = cell_info_new (NULL, NULL, NULL);
2251 g_hash_table_insert (priv->cell_info, renderer, info);
2257 /* Check we are not adding the same attribute twice */
2258 if ((node = g_slist_find_custom (info->attributes, attribute,
2259 (GCompareFunc)cell_attribute_find)) != NULL)
2261 cell_attribute = node->data;
2263 g_warning ("Cannot connect attribute `%s' for cell renderer class `%s' "
2264 "since `%s' is already attributed to column %d",
2266 g_type_name (G_TYPE_FROM_INSTANCE (area)),
2267 attribute, cell_attribute->column);
2272 cell_attribute = cell_attribute_new (renderer, attribute, column);
2274 if (!cell_attribute)
2276 g_warning ("Cannot connect attribute `%s' for cell renderer class `%s' "
2277 "since attribute does not exist",
2279 g_type_name (G_TYPE_FROM_INSTANCE (area)));
2283 info->attributes = g_slist_prepend (info->attributes, cell_attribute);
2287 * gtk_cell_area_attribute_disconnect:
2288 * @area: a #GtkCellArea
2289 * @renderer: the #GtkCellRenderer to disconnect an attribute for
2290 * @attribute: the attribute name
2292 * Disconnects @attribute for the @renderer in @area so that
2293 * attribute will no longer be updated with values from the
2299 gtk_cell_area_attribute_disconnect (GtkCellArea *area,
2300 GtkCellRenderer *renderer,
2301 const gchar *attribute)
2303 GtkCellAreaPrivate *priv;
2305 CellAttribute *cell_attribute;
2308 g_return_if_fail (GTK_IS_CELL_AREA (area));
2309 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
2310 g_return_if_fail (attribute != NULL);
2311 g_return_if_fail (gtk_cell_area_has_renderer (area, renderer));
2314 info = g_hash_table_lookup (priv->cell_info, renderer);
2318 node = g_slist_find_custom (info->attributes, attribute,
2319 (GCompareFunc)cell_attribute_find);
2322 cell_attribute = node->data;
2324 cell_attribute_free (cell_attribute);
2326 info->attributes = g_slist_delete_link (info->attributes, node);
2332 * gtk_cell_area_apply_attributes
2333 * @area: a #GtkCellArea
2334 * @tree_model: the #GtkTreeModel to pull values from
2335 * @iter: the #GtkTreeIter in @tree_model to apply values for
2336 * @is_expander: whether @iter has children
2337 * @is_expanded: whether @iter is expanded in the view and
2338 * children are visible
2340 * Applies any connected attributes to the renderers in
2341 * @area by pulling the values from @tree_model.
2346 gtk_cell_area_apply_attributes (GtkCellArea *area,
2347 GtkTreeModel *tree_model,
2349 gboolean is_expander,
2350 gboolean is_expanded)
2352 g_return_if_fail (GTK_IS_CELL_AREA (area));
2353 g_return_if_fail (GTK_IS_TREE_MODEL (tree_model));
2354 g_return_if_fail (iter != NULL);
2356 g_signal_emit (area, cell_area_signals[SIGNAL_APPLY_ATTRIBUTES], 0,
2357 tree_model, iter, is_expander, is_expanded);
2361 * gtk_cell_area_get_current_path_string:
2362 * @area: a #GtkCellArea
2364 * Gets the current #GtkTreePath string for the currently
2365 * applied #GtkTreeIter, this is implicitly updated when
2366 * gtk_cell_area_apply_attributes() is called and can be
2367 * used to interact with renderers from #GtkCellArea
2370 * Return value: The current #GtkTreePath string for the current
2371 * attributes applied to @area. This string belongs to the area and
2372 * should not be freed.
2376 G_CONST_RETURN gchar *
2377 gtk_cell_area_get_current_path_string (GtkCellArea *area)
2379 GtkCellAreaPrivate *priv;
2381 g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
2385 return priv->current_path;
2389 /*************************************************************
2390 * API: Cell Properties *
2391 *************************************************************/
2393 * gtk_cell_area_class_install_cell_property:
2394 * @aclass: a #GtkCellAreaClass
2395 * @property_id: the id for the property
2396 * @pspec: the #GParamSpec for the property
2398 * Installs a cell property on a cell area class.
2403 gtk_cell_area_class_install_cell_property (GtkCellAreaClass *aclass,
2407 g_return_if_fail (GTK_IS_CELL_AREA_CLASS (aclass));
2408 g_return_if_fail (G_IS_PARAM_SPEC (pspec));
2409 if (pspec->flags & G_PARAM_WRITABLE)
2410 g_return_if_fail (aclass->set_cell_property != NULL);
2411 if (pspec->flags & G_PARAM_READABLE)
2412 g_return_if_fail (aclass->get_cell_property != NULL);
2413 g_return_if_fail (property_id > 0);
2414 g_return_if_fail (PARAM_SPEC_PARAM_ID (pspec) == 0); /* paranoid */
2415 g_return_if_fail ((pspec->flags & (G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT_ONLY)) == 0);
2417 if (g_param_spec_pool_lookup (cell_property_pool, pspec->name, G_OBJECT_CLASS_TYPE (aclass), TRUE))
2419 g_warning (G_STRLOC ": class `%s' already contains a cell property named `%s'",
2420 G_OBJECT_CLASS_NAME (aclass), pspec->name);
2423 g_param_spec_ref (pspec);
2424 g_param_spec_sink (pspec);
2425 PARAM_SPEC_SET_PARAM_ID (pspec, property_id);
2426 g_param_spec_pool_insert (cell_property_pool, pspec, G_OBJECT_CLASS_TYPE (aclass));
2430 * gtk_cell_area_class_find_cell_property:
2431 * @aclass: a #GtkCellAreaClass
2432 * @property_name: the name of the child property to find
2434 * Finds a cell property of a cell area class by name.
2436 * Return value: (transfer none): the #GParamSpec of the child property
2437 * or %NULL if @aclass has no child property with that name.
2442 gtk_cell_area_class_find_cell_property (GtkCellAreaClass *aclass,
2443 const gchar *property_name)
2445 g_return_val_if_fail (GTK_IS_CELL_AREA_CLASS (aclass), NULL);
2446 g_return_val_if_fail (property_name != NULL, NULL);
2448 return g_param_spec_pool_lookup (cell_property_pool,
2450 G_OBJECT_CLASS_TYPE (aclass),
2455 * gtk_cell_area_class_list_cell_properties:
2456 * @aclass: a #GtkCellAreaClass
2457 * @n_properties: location to return the number of cell properties found
2459 * Returns all cell properties of a cell area class.
2461 * Return value: (array length=n_properties) (transfer container): a newly
2462 * allocated %NULL-terminated array of #GParamSpec*. The array
2463 * must be freed with g_free().
2468 gtk_cell_area_class_list_cell_properties (GtkCellAreaClass *aclass,
2469 guint *n_properties)
2471 GParamSpec **pspecs;
2474 g_return_val_if_fail (GTK_IS_CELL_AREA_CLASS (aclass), NULL);
2476 pspecs = g_param_spec_pool_list (cell_property_pool,
2477 G_OBJECT_CLASS_TYPE (aclass),
2486 * gtk_cell_area_add_with_properties:
2487 * @area: a #GtkCellArea
2488 * @renderer: a #GtkCellRenderer to be placed inside @area
2489 * @first_prop_name: the name of the first cell property to set
2490 * @Varargs: a %NULL-terminated list of property names and values, starting
2491 * with @first_prop_name
2493 * Adds @renderer to @area, setting cell properties at the same time.
2494 * See gtk_cell_area_add() and gtk_cell_area_cell_set() for more details.
2499 gtk_cell_area_add_with_properties (GtkCellArea *area,
2500 GtkCellRenderer *renderer,
2501 const gchar *first_prop_name,
2504 GtkCellAreaClass *class;
2506 g_return_if_fail (GTK_IS_CELL_AREA (area));
2507 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
2509 class = GTK_CELL_AREA_GET_CLASS (area);
2515 class->add (area, renderer);
2517 va_start (var_args, first_prop_name);
2518 gtk_cell_area_cell_set_valist (area, renderer, first_prop_name, var_args);
2522 g_warning ("GtkCellAreaClass::add not implemented for `%s'",
2523 g_type_name (G_TYPE_FROM_INSTANCE (area)));
2527 * gtk_cell_area_cell_set:
2528 * @area: a #GtkCellArea
2529 * @renderer: a #GtkCellRenderer which is a cell inside @area
2530 * @first_prop_name: the name of the first cell property to set
2531 * @Varargs: a %NULL-terminated list of property names and values, starting
2532 * with @first_prop_name
2534 * Sets one or more cell properties for @cell in @area.
2539 gtk_cell_area_cell_set (GtkCellArea *area,
2540 GtkCellRenderer *renderer,
2541 const gchar *first_prop_name,
2546 g_return_if_fail (GTK_IS_CELL_AREA (area));
2547 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
2549 va_start (var_args, first_prop_name);
2550 gtk_cell_area_cell_set_valist (area, renderer, first_prop_name, var_args);
2555 * gtk_cell_area_cell_get:
2556 * @area: a #GtkCellArea
2557 * @renderer: a #GtkCellRenderer which is inside @area
2558 * @first_prop_name: the name of the first cell property to get
2559 * @Varargs: return location for the first cell property, followed
2560 * optionally by more name/return location pairs, followed by %NULL
2562 * Gets the values of one or more cell properties for @renderer in @area.
2567 gtk_cell_area_cell_get (GtkCellArea *area,
2568 GtkCellRenderer *renderer,
2569 const gchar *first_prop_name,
2574 g_return_if_fail (GTK_IS_CELL_AREA (area));
2575 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
2577 va_start (var_args, first_prop_name);
2578 gtk_cell_area_cell_get_valist (area, renderer, first_prop_name, var_args);
2583 area_get_cell_property (GtkCellArea *area,
2584 GtkCellRenderer *renderer,
2588 GtkCellAreaClass *class = g_type_class_peek (pspec->owner_type);
2590 class->get_cell_property (area, renderer, PARAM_SPEC_PARAM_ID (pspec), value, pspec);
2594 area_set_cell_property (GtkCellArea *area,
2595 GtkCellRenderer *renderer,
2597 const GValue *value)
2599 GValue tmp_value = { 0, };
2600 GtkCellAreaClass *class = g_type_class_peek (pspec->owner_type);
2602 /* provide a copy to work from, convert (if necessary) and validate */
2603 g_value_init (&tmp_value, G_PARAM_SPEC_VALUE_TYPE (pspec));
2604 if (!g_value_transform (value, &tmp_value))
2605 g_warning ("unable to set cell property `%s' of type `%s' from value of type `%s'",
2607 g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),
2608 G_VALUE_TYPE_NAME (value));
2609 else if (g_param_value_validate (pspec, &tmp_value) && !(pspec->flags & G_PARAM_LAX_VALIDATION))
2611 gchar *contents = g_strdup_value_contents (value);
2613 g_warning ("value \"%s\" of type `%s' is invalid for property `%s' of type `%s'",
2615 G_VALUE_TYPE_NAME (value),
2617 g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)));
2622 class->set_cell_property (area, renderer, PARAM_SPEC_PARAM_ID (pspec), &tmp_value, pspec);
2624 g_value_unset (&tmp_value);
2628 * gtk_cell_area_cell_set_valist:
2629 * @area: a #GtkCellArea
2630 * @renderer: a #GtkCellRenderer which inside @area
2631 * @first_property_name: the name of the first cell property to set
2632 * @var_args: a %NULL-terminated list of property names and values, starting
2633 * with @first_prop_name
2635 * Sets one or more cell properties for @renderer in @area.
2640 gtk_cell_area_cell_set_valist (GtkCellArea *area,
2641 GtkCellRenderer *renderer,
2642 const gchar *first_property_name,
2647 g_return_if_fail (GTK_IS_CELL_AREA (area));
2648 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
2650 name = first_property_name;
2653 GValue value = { 0, };
2654 gchar *error = NULL;
2656 g_param_spec_pool_lookup (cell_property_pool, name,
2657 G_OBJECT_TYPE (area), TRUE);
2660 g_warning ("%s: cell area class `%s' has no cell property named `%s'",
2661 G_STRLOC, G_OBJECT_TYPE_NAME (area), name);
2664 if (!(pspec->flags & G_PARAM_WRITABLE))
2666 g_warning ("%s: cell property `%s' of cell area class `%s' is not writable",
2667 G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (area));
2671 g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
2672 G_VALUE_COLLECT (&value, var_args, 0, &error);
2675 g_warning ("%s: %s", G_STRLOC, error);
2678 /* we purposely leak the value here, it might not be
2679 * in a sane state if an error condition occoured
2683 area_set_cell_property (area, renderer, pspec, &value);
2684 g_value_unset (&value);
2685 name = va_arg (var_args, gchar*);
2690 * gtk_cell_area_cell_get_valist:
2691 * @area: a #GtkCellArea
2692 * @renderer: a #GtkCellRenderer inside @area
2693 * @first_property_name: the name of the first property to get
2694 * @var_args: return location for the first property, followed
2695 * optionally by more name/return location pairs, followed by %NULL
2697 * Gets the values of one or more cell properties for @renderer in @area.
2702 gtk_cell_area_cell_get_valist (GtkCellArea *area,
2703 GtkCellRenderer *renderer,
2704 const gchar *first_property_name,
2709 g_return_if_fail (GTK_IS_CELL_AREA (area));
2710 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
2712 name = first_property_name;
2715 GValue value = { 0, };
2719 pspec = g_param_spec_pool_lookup (cell_property_pool, name,
2720 G_OBJECT_TYPE (area), TRUE);
2723 g_warning ("%s: cell area class `%s' has no cell property named `%s'",
2724 G_STRLOC, G_OBJECT_TYPE_NAME (area), name);
2727 if (!(pspec->flags & G_PARAM_READABLE))
2729 g_warning ("%s: cell property `%s' of cell area class `%s' is not readable",
2730 G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (area));
2734 g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
2735 area_get_cell_property (area, renderer, pspec, &value);
2736 G_VALUE_LCOPY (&value, var_args, 0, &error);
2739 g_warning ("%s: %s", G_STRLOC, error);
2741 g_value_unset (&value);
2744 g_value_unset (&value);
2745 name = va_arg (var_args, gchar*);
2750 * gtk_cell_area_cell_set_property:
2751 * @area: a #GtkCellArea
2752 * @renderer: a #GtkCellRenderer inside @area
2753 * @property_name: the name of the cell property to set
2754 * @value: the value to set the cell property to
2756 * Sets a cell property for @renderer in @area.
2761 gtk_cell_area_cell_set_property (GtkCellArea *area,
2762 GtkCellRenderer *renderer,
2763 const gchar *property_name,
2764 const GValue *value)
2768 g_return_if_fail (GTK_IS_CELL_AREA (area));
2769 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
2770 g_return_if_fail (property_name != NULL);
2771 g_return_if_fail (G_IS_VALUE (value));
2773 pspec = g_param_spec_pool_lookup (cell_property_pool, property_name,
2774 G_OBJECT_TYPE (area), TRUE);
2776 g_warning ("%s: cell area class `%s' has no cell property named `%s'",
2777 G_STRLOC, G_OBJECT_TYPE_NAME (area), property_name);
2778 else if (!(pspec->flags & G_PARAM_WRITABLE))
2779 g_warning ("%s: cell property `%s' of cell area class `%s' is not writable",
2780 G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (area));
2783 area_set_cell_property (area, renderer, pspec, value);
2788 * gtk_cell_area_cell_get_property:
2789 * @area: a #GtkCellArea
2790 * @renderer: a #GtkCellRenderer inside @area
2791 * @property_name: the name of the property to get
2792 * @value: a location to return the value
2794 * Gets the value of a cell property for @renderer in @area.
2799 gtk_cell_area_cell_get_property (GtkCellArea *area,
2800 GtkCellRenderer *renderer,
2801 const gchar *property_name,
2806 g_return_if_fail (GTK_IS_CELL_AREA (area));
2807 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
2808 g_return_if_fail (property_name != NULL);
2809 g_return_if_fail (G_IS_VALUE (value));
2811 pspec = g_param_spec_pool_lookup (cell_property_pool, property_name,
2812 G_OBJECT_TYPE (area), TRUE);
2814 g_warning ("%s: cell area class `%s' has no cell property named `%s'",
2815 G_STRLOC, G_OBJECT_TYPE_NAME (area), property_name);
2816 else if (!(pspec->flags & G_PARAM_READABLE))
2817 g_warning ("%s: cell property `%s' of cell area class `%s' is not readable",
2818 G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (area));
2821 GValue *prop_value, tmp_value = { 0, };
2823 /* auto-conversion of the callers value type
2825 if (G_VALUE_TYPE (value) == G_PARAM_SPEC_VALUE_TYPE (pspec))
2827 g_value_reset (value);
2830 else if (!g_value_type_transformable (G_PARAM_SPEC_VALUE_TYPE (pspec), G_VALUE_TYPE (value)))
2832 g_warning ("can't retrieve cell property `%s' of type `%s' as value of type `%s'",
2834 g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)),
2835 G_VALUE_TYPE_NAME (value));
2840 g_value_init (&tmp_value, G_PARAM_SPEC_VALUE_TYPE (pspec));
2841 prop_value = &tmp_value;
2844 area_get_cell_property (area, renderer, pspec, prop_value);
2846 if (prop_value != value)
2848 g_value_transform (prop_value, value);
2849 g_value_unset (&tmp_value);
2854 /*************************************************************
2856 *************************************************************/
2859 * gtk_cell_area_is_activatable:
2860 * @area: a #GtkCellArea
2862 * Returns whether the area can do anything when activated,
2863 * after applying new attributes to @area.
2865 * Return value: whether @area can do anything when activated.
2870 gtk_cell_area_is_activatable (GtkCellArea *area)
2872 g_return_val_if_fail (GTK_IS_CELL_AREA (area), FALSE);
2874 return GTK_CELL_AREA_GET_CLASS (area)->is_activatable (area);
2878 * gtk_cell_area_focus:
2879 * @area: a #GtkCellArea
2880 * @direction: the #GtkDirectionType
2882 * This should be called by the @area's owning layout widget
2883 * when focus is to be passed to @area, or moved within @area
2884 * for a given @direction and row data.
2886 * Implementing #GtkCellArea classes should implement this
2887 * method to receive and navigate focus in it's own way particular
2888 * to how it lays out cells.
2890 * Return value: %TRUE if focus remains inside @area as a result of this call.
2895 gtk_cell_area_focus (GtkCellArea *area,
2896 GtkDirectionType direction)
2898 GtkCellAreaClass *class;
2900 g_return_val_if_fail (GTK_IS_CELL_AREA (area), FALSE);
2902 class = GTK_CELL_AREA_GET_CLASS (area);
2905 return class->focus (area, direction);
2907 g_warning ("GtkCellAreaClass::focus not implemented for `%s'",
2908 g_type_name (G_TYPE_FROM_INSTANCE (area)));
2914 * gtk_cell_area_activate:
2915 * @area: a #GtkCellArea
2916 * @context: the #GtkCellAreaContext in context with the current row data
2917 * @widget: the #GtkWidget that @area is rendering on
2918 * @cell_area: the size and location of @area relative to @widget's allocation
2919 * @flags: the #GtkCellRendererState flags for @area for this row of data.
2920 * @edit_only: if %TRUE then only cell renderers that are %GTK_CELL_RENDERER_MODE_EDITABLE
2921 * will be activated.
2923 * Activates @area, usually by activating the currently focused
2924 * cell, however some subclasses which embed widgets in the area
2925 * can also activate a widget if it currently has the focus.
2927 * Return value: Whether @area was successfully activated.
2932 gtk_cell_area_activate (GtkCellArea *area,
2933 GtkCellAreaContext *context,
2935 const GdkRectangle *cell_area,
2936 GtkCellRendererState flags,
2939 g_return_val_if_fail (GTK_IS_CELL_AREA (area), FALSE);
2941 return GTK_CELL_AREA_GET_CLASS (area)->activate (area, context, widget, cell_area, flags, edit_only);
2946 * gtk_cell_area_set_focus_cell:
2947 * @area: a #GtkCellArea
2948 * @renderer: the #GtkCellRenderer to give focus to
2950 * Explicitly sets the currently focused cell to @renderer.
2952 * This is generally called by implementations of
2953 * #GtkCellAreaClass.focus() or #GtkCellAreaClass.event(),
2954 * however it can also be used to implement functions such
2955 * as gtk_tree_view_set_cursor_on_cell().
2960 gtk_cell_area_set_focus_cell (GtkCellArea *area,
2961 GtkCellRenderer *renderer)
2963 GtkCellAreaPrivate *priv;
2965 g_return_if_fail (GTK_IS_CELL_AREA (area));
2966 g_return_if_fail (renderer == NULL || GTK_IS_CELL_RENDERER (renderer));
2970 if (priv->focus_cell != renderer)
2972 if (priv->focus_cell)
2973 g_object_unref (priv->focus_cell);
2975 priv->focus_cell = renderer;
2977 if (priv->focus_cell)
2978 g_object_ref (priv->focus_cell);
2980 g_object_notify (G_OBJECT (area), "focus-cell");
2983 /* Signal that the current focus renderer for this path changed
2984 * (it may be that the focus cell did not change, but the row
2985 * may have changed so we need to signal it) */
2986 g_signal_emit (area, cell_area_signals[SIGNAL_FOCUS_CHANGED], 0,
2987 priv->focus_cell, priv->current_path);
2992 * gtk_cell_area_get_focus_cell:
2993 * @area: a #GtkCellArea
2995 * Retrieves the currently focused cell for @area
2997 * Return value: (transfer none): the currently focused cell in @area.
3002 gtk_cell_area_get_focus_cell (GtkCellArea *area)
3004 GtkCellAreaPrivate *priv;
3006 g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
3010 return priv->focus_cell;
3014 /*************************************************************
3015 * API: Focus Siblings *
3016 *************************************************************/
3019 * gtk_cell_area_add_focus_sibling:
3020 * @area: a #GtkCellArea
3021 * @renderer: the #GtkCellRenderer expected to have focus
3022 * @sibling: the #GtkCellRenderer to add to @renderer's focus area
3024 * Adds @sibling to @renderer's focusable area, focus will be drawn
3025 * around @renderer and all of it's siblings if @renderer can
3026 * focus for a given row.
3028 * Events handled by focus siblings can also activate the given
3029 * focusable @renderer.
3034 gtk_cell_area_add_focus_sibling (GtkCellArea *area,
3035 GtkCellRenderer *renderer,
3036 GtkCellRenderer *sibling)
3038 GtkCellAreaPrivate *priv;
3041 g_return_if_fail (GTK_IS_CELL_AREA (area));
3042 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
3043 g_return_if_fail (GTK_IS_CELL_RENDERER (sibling));
3044 g_return_if_fail (renderer != sibling);
3045 g_return_if_fail (gtk_cell_area_has_renderer (area, renderer));
3046 g_return_if_fail (gtk_cell_area_has_renderer (area, sibling));
3047 g_return_if_fail (!gtk_cell_area_is_focus_sibling (area, renderer, sibling));
3049 /* XXX We should also check that sibling is not in any other renderer's sibling
3050 * list already, a renderer can be sibling of only one focusable renderer
3056 siblings = g_hash_table_lookup (priv->focus_siblings, renderer);
3059 siblings = g_list_append (siblings, sibling);
3062 siblings = g_list_append (siblings, sibling);
3063 g_hash_table_insert (priv->focus_siblings, renderer, siblings);
3068 * gtk_cell_area_remove_focus_sibling:
3069 * @area: a #GtkCellArea
3070 * @renderer: the #GtkCellRenderer expected to have focus
3071 * @sibling: the #GtkCellRenderer to remove from @renderer's focus area
3073 * Removes @sibling from @renderer's focus sibling list
3074 * (see gtk_cell_area_add_focus_sibling()).
3079 gtk_cell_area_remove_focus_sibling (GtkCellArea *area,
3080 GtkCellRenderer *renderer,
3081 GtkCellRenderer *sibling)
3083 GtkCellAreaPrivate *priv;
3086 g_return_if_fail (GTK_IS_CELL_AREA (area));
3087 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
3088 g_return_if_fail (GTK_IS_CELL_RENDERER (sibling));
3089 g_return_if_fail (gtk_cell_area_is_focus_sibling (area, renderer, sibling));
3093 siblings = g_hash_table_lookup (priv->focus_siblings, renderer);
3095 siblings = g_list_copy (siblings);
3096 siblings = g_list_remove (siblings, sibling);
3099 g_hash_table_remove (priv->focus_siblings, renderer);
3101 g_hash_table_insert (priv->focus_siblings, renderer, siblings);
3105 * gtk_cell_area_is_focus_sibling:
3106 * @area: a #GtkCellArea
3107 * @renderer: the #GtkCellRenderer expected to have focus
3108 * @sibling: the #GtkCellRenderer to check against @renderer's sibling list
3110 * Returns %TRUE if @sibling is one of @renderer's focus siblings
3111 * (see gtk_cell_area_add_focus_sibling()).
3116 gtk_cell_area_is_focus_sibling (GtkCellArea *area,
3117 GtkCellRenderer *renderer,
3118 GtkCellRenderer *sibling)
3120 GtkCellAreaPrivate *priv;
3121 GList *siblings, *l;
3123 g_return_val_if_fail (GTK_IS_CELL_AREA (area), FALSE);
3124 g_return_val_if_fail (GTK_IS_CELL_RENDERER (renderer), FALSE);
3125 g_return_val_if_fail (GTK_IS_CELL_RENDERER (sibling), FALSE);
3129 siblings = g_hash_table_lookup (priv->focus_siblings, renderer);
3131 for (l = siblings; l; l = l->next)
3133 GtkCellRenderer *a_sibling = l->data;
3135 if (a_sibling == sibling)
3143 * gtk_cell_area_get_focus_siblings:
3144 * @area: a #GtkCellArea
3145 * @renderer: the #GtkCellRenderer expected to have focus
3147 * Gets the focus sibling cell renderers for @renderer.
3149 * Return value: (element-type GtkCellRenderer) (transfer none): A #GList of #GtkCellRenderers.
3150 * The returned list is internal and should not be freed.
3155 gtk_cell_area_get_focus_siblings (GtkCellArea *area,
3156 GtkCellRenderer *renderer)
3158 GtkCellAreaPrivate *priv;
3160 g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
3161 g_return_val_if_fail (GTK_IS_CELL_RENDERER (renderer), NULL);
3165 return g_hash_table_lookup (priv->focus_siblings, renderer);
3169 * gtk_cell_area_get_focus_from_sibling:
3170 * @area: a #GtkCellArea
3171 * @renderer: the #GtkCellRenderer
3173 * Gets the #GtkCellRenderer which is expected to be focusable
3174 * for which @renderer is, or may be a sibling.
3176 * This is handy for #GtkCellArea subclasses when handling events,
3177 * after determining the renderer at the event location it can
3178 * then chose to activate the focus cell for which the event
3179 * cell may have been a sibling.
3181 * Return value: (transfer none): the #GtkCellRenderer for which @renderer
3182 * is a sibling, or %NULL.
3187 gtk_cell_area_get_focus_from_sibling (GtkCellArea *area,
3188 GtkCellRenderer *renderer)
3190 GtkCellRenderer *ret_renderer = NULL;
3191 GList *renderers, *l;
3193 g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
3194 g_return_val_if_fail (GTK_IS_CELL_RENDERER (renderer), NULL);
3196 renderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (area));
3198 for (l = renderers; l; l = l->next)
3200 GtkCellRenderer *a_renderer = l->data;
3203 for (list = gtk_cell_area_get_focus_siblings (area, a_renderer);
3204 list; list = list->next)
3206 GtkCellRenderer *sibling_renderer = list->data;
3208 if (sibling_renderer == renderer)
3210 ret_renderer = a_renderer;
3215 g_list_free (renderers);
3217 return ret_renderer;
3220 /*************************************************************
3221 * API: Cell Activation/Editing *
3222 *************************************************************/
3224 gtk_cell_area_add_editable (GtkCellArea *area,
3225 GtkCellRenderer *renderer,
3226 GtkCellEditable *editable,
3227 const GdkRectangle *cell_area)
3229 g_signal_emit (area, cell_area_signals[SIGNAL_ADD_EDITABLE], 0,
3230 renderer, editable, cell_area, area->priv->current_path);
3234 gtk_cell_area_remove_editable (GtkCellArea *area,
3235 GtkCellRenderer *renderer,
3236 GtkCellEditable *editable)
3238 g_signal_emit (area, cell_area_signals[SIGNAL_REMOVE_EDITABLE], 0, renderer, editable);
3242 cell_area_remove_widget_cb (GtkCellEditable *editable,
3245 GtkCellAreaPrivate *priv = area->priv;
3247 g_assert (priv->edit_widget == editable);
3248 g_assert (priv->edited_cell != NULL);
3250 gtk_cell_area_remove_editable (area, priv->edited_cell, priv->edit_widget);
3252 /* Now that we're done with editing the widget and it can be removed,
3253 * remove our references to the widget and disconnect handlers */
3254 gtk_cell_area_set_edited_cell (area, NULL);
3255 gtk_cell_area_set_edit_widget (area, NULL);
3259 gtk_cell_area_set_edited_cell (GtkCellArea *area,
3260 GtkCellRenderer *renderer)
3262 GtkCellAreaPrivate *priv;
3264 g_return_if_fail (GTK_IS_CELL_AREA (area));
3265 g_return_if_fail (renderer == NULL || GTK_IS_CELL_RENDERER (renderer));
3269 if (priv->edited_cell != renderer)
3271 if (priv->edited_cell)
3272 g_object_unref (priv->edited_cell);
3274 priv->edited_cell = renderer;
3276 if (priv->edited_cell)
3277 g_object_ref (priv->edited_cell);
3279 g_object_notify (G_OBJECT (area), "edited-cell");
3284 gtk_cell_area_set_edit_widget (GtkCellArea *area,
3285 GtkCellEditable *editable)
3287 GtkCellAreaPrivate *priv;
3289 g_return_if_fail (GTK_IS_CELL_AREA (area));
3290 g_return_if_fail (editable == NULL || GTK_IS_CELL_EDITABLE (editable));
3294 if (priv->edit_widget != editable)
3296 if (priv->edit_widget)
3298 g_signal_handler_disconnect (priv->edit_widget, priv->remove_widget_id);
3300 g_object_unref (priv->edit_widget);
3303 priv->edit_widget = editable;
3305 if (priv->edit_widget)
3307 priv->remove_widget_id =
3308 g_signal_connect (priv->edit_widget, "remove-widget",
3309 G_CALLBACK (cell_area_remove_widget_cb), area);
3311 g_object_ref (priv->edit_widget);
3314 g_object_notify (G_OBJECT (area), "edit-widget");
3319 * gtk_cell_area_get_edited_cell:
3320 * @area: a #GtkCellArea
3322 * Gets the #GtkCellRenderer in @area that is currently
3325 * Return value: (transfer none): The currently edited #GtkCellRenderer
3330 gtk_cell_area_get_edited_cell (GtkCellArea *area)
3332 GtkCellAreaPrivate *priv;
3334 g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
3338 return priv->edited_cell;
3342 * gtk_cell_area_get_edit_widget:
3343 * @area: a #GtkCellArea
3345 * Gets the #GtkCellEditable widget currently used
3346 * to edit the currently edited cell.
3348 * Return value: (transfer none): The currently active #GtkCellEditable widget
3353 gtk_cell_area_get_edit_widget (GtkCellArea *area)
3355 GtkCellAreaPrivate *priv;
3357 g_return_val_if_fail (GTK_IS_CELL_AREA (area), NULL);
3361 return priv->edit_widget;
3365 * gtk_cell_area_activate_cell:
3366 * @area: a #GtkCellArea
3367 * @widget: the #GtkWidget that @area is rendering onto
3368 * @renderer: the #GtkCellRenderer in @area to activate
3369 * @event: the #GdkEvent for which cell activation should occur
3370 * @cell_area: the #GdkRectangle in @widget relative coordinates
3371 * of @renderer for the current row.
3372 * @flags: the #GtkCellRendererState for @renderer
3374 * This is used by #GtkCellArea subclasses when handling events
3375 * to activate cells, the base #GtkCellArea class activates cells
3376 * for keyboard events for free in it's own GtkCellArea->activate()
3379 * Return value: whether cell activation was successful
3384 gtk_cell_area_activate_cell (GtkCellArea *area,
3386 GtkCellRenderer *renderer,
3388 const GdkRectangle *cell_area,
3389 GtkCellRendererState flags)
3391 GtkCellRendererMode mode;
3392 GtkCellAreaPrivate *priv;
3394 g_return_val_if_fail (GTK_IS_CELL_AREA (area), FALSE);
3395 g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
3396 g_return_val_if_fail (GTK_IS_CELL_RENDERER (renderer), FALSE);
3397 g_return_val_if_fail (cell_area != NULL, FALSE);
3401 if (!gtk_cell_renderer_get_sensitive (renderer))
3404 g_object_get (renderer, "mode", &mode, NULL);
3406 if (mode == GTK_CELL_RENDERER_MODE_ACTIVATABLE)
3408 if (gtk_cell_renderer_activate (renderer,
3416 else if (mode == GTK_CELL_RENDERER_MODE_EDITABLE)
3418 GtkCellEditable *editable_widget;
3419 GdkRectangle inner_area;
3421 gtk_cell_area_inner_cell_area (area, widget, cell_area, &inner_area);
3424 gtk_cell_renderer_start_editing (renderer,
3431 if (editable_widget != NULL)
3433 g_return_val_if_fail (GTK_IS_CELL_EDITABLE (editable_widget), FALSE);
3435 gtk_cell_area_set_edited_cell (area, renderer);
3436 gtk_cell_area_set_edit_widget (area, editable_widget);
3438 /* Signal that editing started so that callers can get
3439 * a handle on the editable_widget */
3440 gtk_cell_area_add_editable (area, priv->focus_cell, editable_widget, cell_area);
3442 /* If the signal was successfully handled start the editing */
3443 if (gtk_widget_get_parent (GTK_WIDGET (editable_widget)))
3445 gtk_cell_editable_start_editing (editable_widget, NULL);
3446 gtk_widget_grab_focus (GTK_WIDGET (editable_widget));
3450 /* Otherwise clear the editing state and fire a warning */
3451 gtk_cell_area_set_edited_cell (area, NULL);
3452 gtk_cell_area_set_edit_widget (area, NULL);
3454 g_warning ("GtkCellArea::add-editable fired in the dark, no cell editing was started.");
3465 * gtk_cell_area_stop_editing:
3466 * @area: a #GtkCellArea
3467 * @canceled: whether editing was canceled.
3469 * Explicitly stops the editing of the currently
3470 * edited cell (see gtk_cell_area_get_edited_cell()).
3472 * If @canceled is %TRUE, the cell renderer will emit
3473 * the ::editing-canceled signal.
3478 gtk_cell_area_stop_editing (GtkCellArea *area,
3481 GtkCellAreaPrivate *priv;
3483 g_return_if_fail (GTK_IS_CELL_AREA (area));
3487 if (priv->edited_cell)
3489 GtkCellEditable *edit_widget = g_object_ref (priv->edit_widget);
3490 GtkCellRenderer *edit_cell = g_object_ref (priv->edited_cell);
3492 /* Stop editing of the cell renderer */
3493 gtk_cell_renderer_stop_editing (priv->edited_cell, canceled);
3495 /* Remove any references to the editable widget */
3496 gtk_cell_area_set_edited_cell (area, NULL);
3497 gtk_cell_area_set_edit_widget (area, NULL);
3499 /* Send the remove-widget signal explicitly (this is done after setting
3500 * the edit cell/widget NULL to avoid feedback)
3502 gtk_cell_area_remove_editable (area, edit_cell, edit_widget);
3503 g_object_unref (edit_cell);
3504 g_object_unref (edit_widget);
3508 /*************************************************************
3509 * API: Convenience for area implementations *
3510 *************************************************************/
3513 * gtk_cell_area_inner_cell_area:
3514 * @area: a #GtkCellArea
3515 * @widget: the #GtkWidget that @area is rendering onto
3516 * @cell_area: the @widget relative coordinates where one of @area's cells
3518 * @inner_area: (out): the return location for the inner cell area
3520 * This is a convenience function for #GtkCellArea implementations
3521 * to get the inner area where a given #GtkCellRenderer will be
3522 * rendered. It removes any padding previously added by gtk_cell_area_request_renderer().
3527 gtk_cell_area_inner_cell_area (GtkCellArea *area,
3529 const GdkRectangle *cell_area,
3530 GdkRectangle *inner_area)
3532 gint focus_line_width;
3534 g_return_if_fail (GTK_IS_CELL_AREA (area));
3535 g_return_if_fail (GTK_IS_WIDGET (widget));
3536 g_return_if_fail (cell_area != NULL);
3537 g_return_if_fail (inner_area != NULL);
3539 gtk_widget_style_get (widget, "focus-line-width", &focus_line_width, NULL);
3541 *inner_area = *cell_area;
3543 inner_area->x += focus_line_width;
3544 inner_area->width -= focus_line_width * 2;
3545 inner_area->y += focus_line_width;
3546 inner_area->height -= focus_line_width * 2;
3550 * gtk_cell_area_request_renderer:
3551 * @area: a #GtkCellArea
3552 * @renderer: the #GtkCellRenderer to request size for
3553 * @orientation: the #GtkOrientation in which to request size
3554 * @widget: the #GtkWidget that @area is rendering onto
3555 * @for_size: the allocation contextual size to request for, or -1 if
3556 * the base request for the orientation is to be returned.
3557 * @minimum_size: (out) (allow-none): location to store the minimum size, or %NULL
3558 * @natural_size: (out) (allow-none): location to store the natural size, or %NULL
3560 * This is a convenience function for #GtkCellArea implementations
3561 * to request size for cell renderers. It's important to use this
3562 * function to request size and then use gtk_cell_area_inner_cell_area()
3563 * at render and event time since this function will add padding
3564 * around the cell for focus painting.
3569 gtk_cell_area_request_renderer (GtkCellArea *area,
3570 GtkCellRenderer *renderer,
3571 GtkOrientation orientation,
3577 gint focus_line_width;
3579 g_return_if_fail (GTK_IS_CELL_AREA (area));
3580 g_return_if_fail (GTK_IS_CELL_RENDERER (renderer));
3581 g_return_if_fail (GTK_IS_WIDGET (widget));
3582 g_return_if_fail (minimum_size != NULL);
3583 g_return_if_fail (natural_size != NULL);
3585 gtk_widget_style_get (widget, "focus-line-width", &focus_line_width, NULL);
3587 focus_line_width *= 2;
3589 if (orientation == GTK_ORIENTATION_HORIZONTAL)
3592 gtk_cell_renderer_get_preferred_width (renderer, widget, minimum_size, natural_size);
3595 for_size = MAX (0, for_size - focus_line_width);
3597 gtk_cell_renderer_get_preferred_width_for_height (renderer, widget, for_size,
3598 minimum_size, natural_size);
3601 else /* GTK_ORIENTATION_VERTICAL */
3604 gtk_cell_renderer_get_preferred_height (renderer, widget, minimum_size, natural_size);
3607 for_size = MAX (0, for_size - focus_line_width);
3609 gtk_cell_renderer_get_preferred_height_for_width (renderer, widget, for_size,
3610 minimum_size, natural_size);
3614 *minimum_size += focus_line_width;
3615 *natural_size += focus_line_width;
3619 _gtk_cell_area_set_cell_data_func_with_proxy (GtkCellArea *area,
3620 GtkCellRenderer *cell,
3623 GDestroyNotify destroy,
3626 GtkCellAreaPrivate *priv;
3629 g_return_if_fail (GTK_IS_CELL_AREA (area));
3630 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
3634 info = g_hash_table_lookup (priv->cell_info, cell);
3636 /* Note we do not take a reference to the proxy, the proxy is a GtkCellLayout
3637 * that is forwarding it's implementation to a delegate GtkCellArea therefore
3638 * it's life-cycle is longer than the area's life cycle.
3642 if (info->destroy && info->data)
3643 info->destroy (info->data);
3647 info->func = (GtkCellLayoutDataFunc)func;
3648 info->data = func_data;
3649 info->destroy = destroy;
3650 info->proxy = proxy;
3656 info->destroy = NULL;
3662 info = cell_info_new ((GtkCellLayoutDataFunc)func, func_data, destroy);
3663 info->proxy = proxy;
3665 g_hash_table_insert (priv->cell_info, cell, info);