2 * Copyright (C) 2000 Red Hat, Inc. Jonathan Blandford
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
21 #include "gtkcellrenderer.h"
23 #include "gtkmarshalers.h"
24 #include "gtktypebuiltins.h"
25 #include "gtkprivate.h"
26 #include "gtktreeprivate.h"
27 #include "a11y/gtkrenderercellaccessible.h"
31 * SECTION:gtkcellrenderer
32 * @Short_description: An object for rendering a single cell
33 * @Title: GtkCellRenderer
34 * @See_also: #GtkCellRendererText, #GtkCellRendererPixbuf, #GtkCellRendererToggle
36 * The #GtkCellRenderer is a base class of a set of objects used for
37 * rendering a cell to a #cairo_t. These objects are used primarily by
38 * the #GtkTreeView widget, though they aren't tied to them in any
39 * specific way. It is worth noting that #GtkCellRenderer is not a
40 * #GtkWidget and cannot be treated as such.
42 * The primary use of a #GtkCellRenderer is for drawing a certain graphical
43 * elements on a #cairo_t. Typically, one cell renderer is used to
44 * draw many cells on the screen. To this extent, it isn't expected that a
45 * CellRenderer keep any permanent state around. Instead, any state is set
46 * just prior to use using #GObject<!-- -->s property system. Then, the
47 * cell is measured using gtk_cell_renderer_get_size(). Finally, the cell
48 * is rendered in the correct location using gtk_cell_renderer_render().
50 * There are a number of rules that must be followed when writing a new
51 * #GtkCellRenderer. First and formost, its important that a certain set
52 * of properties will always yield a cell renderer of the same size,
53 * barring a #GtkStyle change. The #GtkCellRenderer also has a number of
54 * generic properties that are expected to be honored by all children.
56 * Beyond merely rendering a cell, cell renderers can optionally
57 * provide active user interface elements. A cell renderer can be
58 * <firstterm>activatable</firstterm> like #GtkCellRendererToggle,
59 * which toggles when it gets activated by a mouse click, or it can be
60 * <firstterm>editable</firstterm> like #GtkCellRendererText, which
61 * allows the user to edit the text using a #GtkEntry.
62 * To make a cell renderer activatable or editable, you have to
63 * implement the #GtkCellRendererClass.activate or
64 * #GtkCellRendererClass.start_editing virtual functions, respectively.
68 #define DEBUG_CELL_SIZE_REQUEST 0
70 static void gtk_cell_renderer_init (GtkCellRenderer *cell);
71 static void gtk_cell_renderer_class_init (GtkCellRendererClass *class);
72 static void gtk_cell_renderer_get_property (GObject *object,
76 static void gtk_cell_renderer_set_property (GObject *object,
80 static void set_cell_bg_color (GtkCellRenderer *cell,
83 /* Fallback GtkCellRenderer implementation to use remaining ->get_size() implementations */
84 static GtkSizeRequestMode gtk_cell_renderer_real_get_request_mode(GtkCellRenderer *cell);
85 static void gtk_cell_renderer_real_get_preferred_width (GtkCellRenderer *cell,
89 static void gtk_cell_renderer_real_get_preferred_height (GtkCellRenderer *cell,
93 static void gtk_cell_renderer_real_get_preferred_height_for_width(GtkCellRenderer *cell,
97 gint *natural_height);
98 static void gtk_cell_renderer_real_get_preferred_width_for_height(GtkCellRenderer *cell,
102 gint *natural_width);
103 static void gtk_cell_renderer_real_get_aligned_area (GtkCellRenderer *cell,
105 GtkCellRendererState flags,
106 const GdkRectangle *cell_area,
107 GdkRectangle *aligned_area);
110 struct _GtkCellRendererPrivate
123 guint is_expander : 1;
124 guint is_expanded : 1;
125 guint cell_background_set : 1;
129 GdkRGBA cell_background;
132 struct _GtkCellRendererClassPrivate
134 GType accessible_type;
150 PROP_CELL_BACKGROUND,
151 PROP_CELL_BACKGROUND_GDK,
152 PROP_CELL_BACKGROUND_RGBA,
153 PROP_CELL_BACKGROUND_SET,
164 static guint cell_renderer_signals[LAST_SIGNAL] = { 0 };
167 gtk_cell_renderer_init (GtkCellRenderer *cell)
169 GtkCellRendererPrivate *priv;
171 cell->priv = G_TYPE_INSTANCE_GET_PRIVATE (cell,
172 GTK_TYPE_CELL_RENDERER,
173 GtkCellRendererPrivate);
176 priv->mode = GTK_CELL_RENDERER_MODE_INERT;
177 priv->visible = TRUE;
184 priv->sensitive = TRUE;
185 priv->is_expander = FALSE;
186 priv->is_expanded = FALSE;
187 priv->editing = FALSE;
191 gtk_cell_renderer_class_init (GtkCellRendererClass *class)
193 GObjectClass *object_class = G_OBJECT_CLASS (class);
195 object_class->get_property = gtk_cell_renderer_get_property;
196 object_class->set_property = gtk_cell_renderer_set_property;
198 class->render = NULL;
199 class->get_size = NULL;
200 class->get_request_mode = gtk_cell_renderer_real_get_request_mode;
201 class->get_preferred_width = gtk_cell_renderer_real_get_preferred_width;
202 class->get_preferred_height = gtk_cell_renderer_real_get_preferred_height;
203 class->get_preferred_width_for_height = gtk_cell_renderer_real_get_preferred_width_for_height;
204 class->get_preferred_height_for_width = gtk_cell_renderer_real_get_preferred_height_for_width;
205 class->get_aligned_area = gtk_cell_renderer_real_get_aligned_area;
208 * GtkCellRenderer::editing-canceled:
209 * @renderer: the object which received the signal
211 * This signal gets emitted when the user cancels the process of editing a
212 * cell. For example, an editable cell renderer could be written to cancel
213 * editing when the user presses Escape.
215 * See also: gtk_cell_renderer_stop_editing().
219 cell_renderer_signals[EDITING_CANCELED] =
220 g_signal_new (I_("editing-canceled"),
221 G_OBJECT_CLASS_TYPE (object_class),
223 G_STRUCT_OFFSET (GtkCellRendererClass, editing_canceled),
225 _gtk_marshal_VOID__VOID,
229 * GtkCellRenderer::editing-started:
230 * @renderer: the object which received the signal
231 * @editable: the #GtkCellEditable
232 * @path: the path identifying the edited cell
234 * This signal gets emitted when a cell starts to be edited.
235 * The intended use of this signal is to do special setup
236 * on @editable, e.g. adding a #GtkEntryCompletion or setting
237 * up additional columns in a #GtkComboBox.
239 * Note that GTK+ doesn't guarantee that cell renderers will
240 * continue to use the same kind of widget for editing in future
241 * releases, therefore you should check the type of @editable
242 * before doing any specific setup, as in the following example:
245 * text_editing_started (GtkCellRenderer *cell,
246 * GtkCellEditable *editable,
250 * if (GTK_IS_ENTRY (editable))
252 * GtkEntry *entry = GTK_ENTRY (editable);
254 * /* ... create a GtkEntryCompletion */
256 * gtk_entry_set_completion (entry, completion);
263 cell_renderer_signals[EDITING_STARTED] =
264 g_signal_new (I_("editing-started"),
265 G_OBJECT_CLASS_TYPE (object_class),
267 G_STRUCT_OFFSET (GtkCellRendererClass, editing_started),
269 _gtk_marshal_VOID__OBJECT_STRING,
271 GTK_TYPE_CELL_EDITABLE,
274 g_object_class_install_property (object_class,
276 g_param_spec_enum ("mode",
278 P_("Editable mode of the CellRenderer"),
279 GTK_TYPE_CELL_RENDERER_MODE,
280 GTK_CELL_RENDERER_MODE_INERT,
281 GTK_PARAM_READWRITE));
283 g_object_class_install_property (object_class,
285 g_param_spec_boolean ("visible",
287 P_("Display the cell"),
289 GTK_PARAM_READWRITE));
290 g_object_class_install_property (object_class,
292 g_param_spec_boolean ("sensitive",
294 P_("Display the cell sensitive"),
296 GTK_PARAM_READWRITE));
298 g_object_class_install_property (object_class,
300 g_param_spec_float ("xalign",
306 GTK_PARAM_READWRITE));
308 g_object_class_install_property (object_class,
310 g_param_spec_float ("yalign",
316 GTK_PARAM_READWRITE));
318 g_object_class_install_property (object_class,
320 g_param_spec_uint ("xpad",
326 GTK_PARAM_READWRITE));
328 g_object_class_install_property (object_class,
330 g_param_spec_uint ("ypad",
336 GTK_PARAM_READWRITE));
338 g_object_class_install_property (object_class,
340 g_param_spec_int ("width",
342 P_("The fixed width"),
346 GTK_PARAM_READWRITE));
348 g_object_class_install_property (object_class,
350 g_param_spec_int ("height",
352 P_("The fixed height"),
356 GTK_PARAM_READWRITE));
358 g_object_class_install_property (object_class,
360 g_param_spec_boolean ("is-expander",
362 P_("Row has children"),
364 GTK_PARAM_READWRITE));
367 g_object_class_install_property (object_class,
369 g_param_spec_boolean ("is-expanded",
371 P_("Row is an expander row, and is expanded"),
373 GTK_PARAM_READWRITE));
375 g_object_class_install_property (object_class,
376 PROP_CELL_BACKGROUND,
377 g_param_spec_string ("cell-background",
378 P_("Cell background color name"),
379 P_("Cell background color as a string"),
381 GTK_PARAM_WRITABLE));
384 * GtkCellRenderer:cell-background-gdk:
386 * Cell background as a #GdkColor
388 * Deprecated: 3.4: Use #GtkCellRenderer:cell-background-rgba instead.
390 g_object_class_install_property (object_class,
391 PROP_CELL_BACKGROUND_GDK,
392 g_param_spec_boxed ("cell-background-gdk",
393 P_("Cell background color"),
394 P_("Cell background color as a GdkColor"),
396 GTK_PARAM_READWRITE | G_PARAM_DEPRECATED));
398 * GtkCellRenderer:cell-background-rgba:
400 * Cell background as a #GdkRGBA
404 g_object_class_install_property (object_class,
405 PROP_CELL_BACKGROUND_RGBA,
406 g_param_spec_boxed ("cell-background-rgba",
407 P_("Cell background RGBA color"),
408 P_("Cell background color as a GdkRGBA"),
410 GTK_PARAM_READWRITE));
412 g_object_class_install_property (object_class,
414 g_param_spec_boolean ("editing",
416 P_("Whether the cell renderer is currently in editing mode"),
418 GTK_PARAM_READABLE));
421 #define ADD_SET_PROP(propname, propval, nick, blurb) g_object_class_install_property (object_class, propval, g_param_spec_boolean (propname, nick, blurb, FALSE, GTK_PARAM_READWRITE))
423 ADD_SET_PROP ("cell-background-set", PROP_CELL_BACKGROUND_SET,
424 P_("Cell background set"),
425 P_("Whether this tag affects the cell background color"));
427 g_type_class_add_private (class, sizeof (GtkCellRendererPrivate));
429 _gtk_cell_renderer_class_set_accessible_type (class, GTK_TYPE_RENDERER_CELL_ACCESSIBLE);
433 gtk_cell_renderer_base_class_init (gpointer g_class)
435 GtkCellRendererClass *klass = g_class;
437 klass->priv = G_TYPE_CLASS_GET_PRIVATE (g_class, GTK_TYPE_CELL_RENDERER, GtkCellRendererClassPrivate);
441 gtk_cell_renderer_get_type (void)
443 static GType cell_renderer_type = 0;
445 if (G_UNLIKELY (cell_renderer_type == 0))
447 const GTypeInfo cell_renderer_info =
449 sizeof (GtkCellRendererClass),
450 gtk_cell_renderer_base_class_init,
452 (GClassInitFunc) gtk_cell_renderer_class_init,
453 NULL, /* class_finalize */
454 NULL, /* class_init */
457 (GInstanceInitFunc) gtk_cell_renderer_init,
458 NULL, /* value_table */
460 cell_renderer_type = g_type_register_static (G_TYPE_INITIALLY_UNOWNED, "GtkCellRenderer",
461 &cell_renderer_info, G_TYPE_FLAG_ABSTRACT);
463 g_type_add_class_private (cell_renderer_type, sizeof (GtkCellRendererClassPrivate));
466 return cell_renderer_type;
470 gtk_cell_renderer_get_property (GObject *object,
475 GtkCellRenderer *cell = GTK_CELL_RENDERER (object);
476 GtkCellRendererPrivate *priv = cell->priv;
481 g_value_set_enum (value, priv->mode);
484 g_value_set_boolean (value, priv->visible);
487 g_value_set_boolean (value, priv->sensitive);
490 g_value_set_boolean (value, priv->editing);
493 g_value_set_float (value, priv->xalign);
496 g_value_set_float (value, priv->yalign);
499 g_value_set_uint (value, priv->xpad);
502 g_value_set_uint (value, priv->ypad);
505 g_value_set_int (value, priv->width);
508 g_value_set_int (value, priv->height);
510 case PROP_IS_EXPANDER:
511 g_value_set_boolean (value, priv->is_expander);
513 case PROP_IS_EXPANDED:
514 g_value_set_boolean (value, priv->is_expanded);
516 case PROP_CELL_BACKGROUND_GDK:
520 color.red = (guint16) (priv->cell_background.red * 65535);
521 color.green = (guint16) (priv->cell_background.green * 65535);
522 color.blue = (guint16) (priv->cell_background.blue * 65535);
524 g_value_set_boxed (value, &color);
527 case PROP_CELL_BACKGROUND_RGBA:
528 g_value_set_boxed (value, &priv->cell_background);
530 case PROP_CELL_BACKGROUND_SET:
531 g_value_set_boolean (value, priv->cell_background_set);
533 case PROP_CELL_BACKGROUND:
535 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
542 gtk_cell_renderer_set_property (GObject *object,
547 GtkCellRenderer *cell = GTK_CELL_RENDERER (object);
548 GtkCellRendererPrivate *priv = cell->priv;
553 priv->mode = g_value_get_enum (value);
556 priv->visible = g_value_get_boolean (value);
559 priv->sensitive = g_value_get_boolean (value);
562 priv->editing = g_value_get_boolean (value);
565 priv->xalign = g_value_get_float (value);
568 priv->yalign = g_value_get_float (value);
571 priv->xpad = g_value_get_uint (value);
574 priv->ypad = g_value_get_uint (value);
577 priv->width = g_value_get_int (value);
580 priv->height = g_value_get_int (value);
582 case PROP_IS_EXPANDER:
583 priv->is_expander = g_value_get_boolean (value);
585 case PROP_IS_EXPANDED:
586 priv->is_expanded = g_value_get_boolean (value);
588 case PROP_CELL_BACKGROUND:
592 if (!g_value_get_string (value))
593 set_cell_bg_color (cell, NULL);
594 else if (gdk_rgba_parse (&rgba, g_value_get_string (value)))
595 set_cell_bg_color (cell, &rgba);
597 g_warning ("Don't know color `%s'", g_value_get_string (value));
599 g_object_notify (object, "cell-background-gdk");
602 case PROP_CELL_BACKGROUND_GDK:
606 color = g_value_get_boxed (value);
611 rgba.red = color->red / 65535.;
612 rgba.green = color->green / 65535.;
613 rgba.blue = color->blue / 65535.;
616 set_cell_bg_color (cell, &rgba);
620 set_cell_bg_color (cell, NULL);
624 case PROP_CELL_BACKGROUND_RGBA:
625 set_cell_bg_color (cell, g_value_get_boxed (value));
627 case PROP_CELL_BACKGROUND_SET:
628 priv->cell_background_set = g_value_get_boolean (value);
631 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
637 set_cell_bg_color (GtkCellRenderer *cell,
640 GtkCellRendererPrivate *priv = cell->priv;
644 if (!priv->cell_background_set)
646 priv->cell_background_set = TRUE;
647 g_object_notify (G_OBJECT (cell), "cell-background-set");
650 priv->cell_background = *rgba;
654 if (priv->cell_background_set)
656 priv->cell_background_set = FALSE;
657 g_object_notify (G_OBJECT (cell), "cell-background-set");
663 * gtk_cell_renderer_get_size:
664 * @cell: a #GtkCellRenderer
665 * @widget: the widget the renderer is rendering to
666 * @cell_area: (allow-none): The area a cell will be allocated, or %NULL
667 * @x_offset: (out) (allow-none): location to return x offset of cell relative to @cell_area, or %NULL
668 * @y_offset: (out) (allow-none): location to return y offset of cell relative to @cell_area, or %NULL
669 * @width: (out) (allow-none): location to return width needed to render a cell, or %NULL
670 * @height: (out) (allow-none): location to return height needed to render a cell, or %NULL
672 * Obtains the width and height needed to render the cell. Used by view
673 * widgets to determine the appropriate size for the cell_area passed to
674 * gtk_cell_renderer_render(). If @cell_area is not %NULL, fills in the
675 * x and y offsets (if set) of the cell relative to this location.
677 * Please note that the values set in @width and @height, as well as those
678 * in @x_offset and @y_offset are inclusive of the xpad and ypad properties.
681 * Deprecated: 3.0: Use gtk_cell_renderer_get_preferred_size() instead.
684 gtk_cell_renderer_get_size (GtkCellRenderer *cell,
686 const GdkRectangle *cell_area,
692 GtkRequisition request;
694 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
696 gtk_cell_renderer_get_preferred_size (cell, widget, &request, NULL);
699 *width = request.width;
702 *height = request.height;
705 _gtk_cell_renderer_calc_offset (cell, cell_area, gtk_widget_get_direction (widget),
706 request.width, request.height, x_offset, y_offset);
710 * gtk_cell_renderer_render:
711 * @cell: a #GtkCellRenderer
712 * @cr: a cairo context to draw to
713 * @widget: the widget owning @window
714 * @background_area: entire cell area (including tree expanders and maybe
715 * padding on the sides)
716 * @cell_area: area normally rendered by a cell renderer
717 * @flags: flags that affect rendering
719 * Invokes the virtual render function of the #GtkCellRenderer. The three
720 * passed-in rectangles are areas in @cr. Most renderers will draw within
721 * @cell_area; the xalign, yalign, xpad, and ypad fields of the #GtkCellRenderer
722 * should be honored with respect to @cell_area. @background_area includes the
723 * blank space around the cell, and also the area containing the tree expander;
724 * so the @background_area rectangles for all cells tile to cover the entire
728 gtk_cell_renderer_render (GtkCellRenderer *cell,
731 const GdkRectangle *background_area,
732 const GdkRectangle *cell_area,
733 GtkCellRendererState flags)
735 gboolean selected = FALSE;
736 GtkCellRendererPrivate *priv = cell->priv;
737 GtkStyleContext *context;
740 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
741 g_return_if_fail (GTK_CELL_RENDERER_GET_CLASS (cell)->render != NULL);
742 g_return_if_fail (cr != NULL);
744 selected = (flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED;
748 if (priv->cell_background_set && !selected)
750 gdk_cairo_rectangle (cr, background_area);
751 gdk_cairo_set_source_rgba (cr, &priv->cell_background);
755 gdk_cairo_rectangle (cr, background_area);
758 context = gtk_widget_get_style_context (widget);
760 gtk_style_context_save (context);
761 gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL);
763 state = gtk_cell_renderer_get_state (cell, widget, flags);
764 gtk_style_context_set_state (context, state);
766 GTK_CELL_RENDERER_GET_CLASS (cell)->render (cell,
772 gtk_style_context_restore (context);
777 * gtk_cell_renderer_activate:
778 * @cell: a #GtkCellRenderer
779 * @event: a #GdkEvent
780 * @widget: widget that received the event
781 * @path: widget-dependent string representation of the event location;
782 * e.g. for #GtkTreeView, a string representation of #GtkTreePath
783 * @background_area: background area as passed to gtk_cell_renderer_render()
784 * @cell_area: cell area as passed to gtk_cell_renderer_render()
785 * @flags: render flags
787 * Passes an activate event to the cell renderer for possible processing.
788 * Some cell renderers may use events; for example, #GtkCellRendererToggle
789 * toggles when it gets a mouse click.
791 * Return value: %TRUE if the event was consumed/handled
794 gtk_cell_renderer_activate (GtkCellRenderer *cell,
798 const GdkRectangle *background_area,
799 const GdkRectangle *cell_area,
800 GtkCellRendererState flags)
802 GtkCellRendererPrivate *priv;
804 g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);
808 if (priv->mode != GTK_CELL_RENDERER_MODE_ACTIVATABLE)
811 if (GTK_CELL_RENDERER_GET_CLASS (cell)->activate == NULL)
814 return GTK_CELL_RENDERER_GET_CLASS (cell)->activate (cell,
818 (GdkRectangle *) background_area,
819 (GdkRectangle *) cell_area,
824 * gtk_cell_renderer_start_editing:
825 * @cell: a #GtkCellRenderer
826 * @event: a #GdkEvent
827 * @widget: widget that received the event
828 * @path: widget-dependent string representation of the event location;
829 * e.g. for #GtkTreeView, a string representation of #GtkTreePath
830 * @background_area: background area as passed to gtk_cell_renderer_render()
831 * @cell_area: cell area as passed to gtk_cell_renderer_render()
832 * @flags: render flags
834 * Passes an activate event to the cell renderer for possible processing.
836 * Return value: (transfer none): A new #GtkCellEditable, or %NULL
839 gtk_cell_renderer_start_editing (GtkCellRenderer *cell,
843 const GdkRectangle *background_area,
844 const GdkRectangle *cell_area,
845 GtkCellRendererState flags)
848 GtkCellRendererPrivate *priv;
849 GtkCellEditable *editable;
851 g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), NULL);
855 if (priv->mode != GTK_CELL_RENDERER_MODE_EDITABLE)
858 if (GTK_CELL_RENDERER_GET_CLASS (cell)->start_editing == NULL)
861 editable = GTK_CELL_RENDERER_GET_CLASS (cell)->start_editing (cell,
865 (GdkRectangle *) background_area,
866 (GdkRectangle *) cell_area,
868 gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET (editable)),
869 GTK_STYLE_CLASS_CELL);
872 cell_renderer_signals[EDITING_STARTED], 0,
875 priv->editing = TRUE;
881 * gtk_cell_renderer_set_fixed_size:
882 * @cell: A #GtkCellRenderer
883 * @width: the width of the cell renderer, or -1
884 * @height: the height of the cell renderer, or -1
886 * Sets the renderer size to be explicit, independent of the properties set.
889 gtk_cell_renderer_set_fixed_size (GtkCellRenderer *cell,
893 GtkCellRendererPrivate *priv;
895 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
896 g_return_if_fail (width >= -1 && height >= -1);
900 if ((width != priv->width) || (height != priv->height))
902 g_object_freeze_notify (G_OBJECT (cell));
904 if (width != priv->width)
907 g_object_notify (G_OBJECT (cell), "width");
910 if (height != priv->height)
912 priv->height = height;
913 g_object_notify (G_OBJECT (cell), "height");
916 g_object_thaw_notify (G_OBJECT (cell));
921 * gtk_cell_renderer_get_fixed_size:
922 * @cell: A #GtkCellRenderer
923 * @width: (out) (allow-none): location to fill in with the fixed width of the cell, or %NULL
924 * @height: (out) (allow-none): location to fill in with the fixed height of the cell, or %NULL
926 * Fills in @width and @height with the appropriate size of @cell.
929 gtk_cell_renderer_get_fixed_size (GtkCellRenderer *cell,
933 GtkCellRendererPrivate *priv;
935 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
940 *width = priv->width;
942 *height = priv->height;
946 * gtk_cell_renderer_set_alignment:
947 * @cell: A #GtkCellRenderer
948 * @xalign: the x alignment of the cell renderer
949 * @yalign: the y alignment of the cell renderer
951 * Sets the renderer's alignment within its available space.
956 gtk_cell_renderer_set_alignment (GtkCellRenderer *cell,
960 GtkCellRendererPrivate *priv;
962 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
963 g_return_if_fail (xalign >= 0.0 && xalign <= 1.0);
964 g_return_if_fail (yalign >= 0.0 && yalign <= 1.0);
968 if ((xalign != priv->xalign) || (yalign != priv->yalign))
970 g_object_freeze_notify (G_OBJECT (cell));
972 if (xalign != priv->xalign)
974 priv->xalign = xalign;
975 g_object_notify (G_OBJECT (cell), "xalign");
978 if (yalign != priv->yalign)
980 priv->yalign = yalign;
981 g_object_notify (G_OBJECT (cell), "yalign");
984 g_object_thaw_notify (G_OBJECT (cell));
989 * gtk_cell_renderer_get_alignment:
990 * @cell: A #GtkCellRenderer
991 * @xalign: (out) (allow-none): location to fill in with the x alignment of the cell, or %NULL
992 * @yalign: (out) (allow-none): location to fill in with the y alignment of the cell, or %NULL
994 * Fills in @xalign and @yalign with the appropriate values of @cell.
999 gtk_cell_renderer_get_alignment (GtkCellRenderer *cell,
1003 GtkCellRendererPrivate *priv;
1005 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1010 *xalign = priv->xalign;
1012 *yalign = priv->yalign;
1016 * gtk_cell_renderer_set_padding:
1017 * @cell: A #GtkCellRenderer
1018 * @xpad: the x padding of the cell renderer
1019 * @ypad: the y padding of the cell renderer
1021 * Sets the renderer's padding.
1026 gtk_cell_renderer_set_padding (GtkCellRenderer *cell,
1030 GtkCellRendererPrivate *priv;
1032 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1033 g_return_if_fail (xpad >= 0 && xpad >= 0);
1037 if ((xpad != priv->xpad) || (ypad != priv->ypad))
1039 g_object_freeze_notify (G_OBJECT (cell));
1041 if (xpad != priv->xpad)
1044 g_object_notify (G_OBJECT (cell), "xpad");
1047 if (ypad != priv->ypad)
1050 g_object_notify (G_OBJECT (cell), "ypad");
1053 g_object_thaw_notify (G_OBJECT (cell));
1058 * gtk_cell_renderer_get_padding:
1059 * @cell: A #GtkCellRenderer
1060 * @xpad: (out) (allow-none): location to fill in with the x padding of the cell, or %NULL
1061 * @ypad: (out) (allow-none): location to fill in with the y padding of the cell, or %NULL
1063 * Fills in @xpad and @ypad with the appropriate values of @cell.
1068 gtk_cell_renderer_get_padding (GtkCellRenderer *cell,
1072 GtkCellRendererPrivate *priv;
1074 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1085 * gtk_cell_renderer_set_visible:
1086 * @cell: A #GtkCellRenderer
1087 * @visible: the visibility of the cell
1089 * Sets the cell renderer's visibility.
1094 gtk_cell_renderer_set_visible (GtkCellRenderer *cell,
1097 GtkCellRendererPrivate *priv;
1099 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1103 if (priv->visible != visible)
1105 priv->visible = visible ? TRUE : FALSE;
1106 g_object_notify (G_OBJECT (cell), "visible");
1111 * gtk_cell_renderer_get_visible:
1112 * @cell: A #GtkCellRenderer
1114 * Returns the cell renderer's visibility.
1116 * Returns: %TRUE if the cell renderer is visible
1121 gtk_cell_renderer_get_visible (GtkCellRenderer *cell)
1123 g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);
1125 return cell->priv->visible;
1129 * gtk_cell_renderer_set_sensitive:
1130 * @cell: A #GtkCellRenderer
1131 * @sensitive: the sensitivity of the cell
1133 * Sets the cell renderer's sensitivity.
1138 gtk_cell_renderer_set_sensitive (GtkCellRenderer *cell,
1141 GtkCellRendererPrivate *priv;
1143 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1147 if (priv->sensitive != sensitive)
1149 priv->sensitive = sensitive ? TRUE : FALSE;
1150 g_object_notify (G_OBJECT (cell), "sensitive");
1155 * gtk_cell_renderer_get_sensitive:
1156 * @cell: A #GtkCellRenderer
1158 * Returns the cell renderer's sensitivity.
1160 * Returns: %TRUE if the cell renderer is sensitive
1165 gtk_cell_renderer_get_sensitive (GtkCellRenderer *cell)
1167 g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);
1169 return cell->priv->sensitive;
1174 * gtk_cell_renderer_is_activatable:
1175 * @cell: A #GtkCellRenderer
1177 * Checks whether the cell renderer can do something when activated.
1179 * Returns: %TRUE if the cell renderer can do anything when activated
1184 gtk_cell_renderer_is_activatable (GtkCellRenderer *cell)
1186 GtkCellRendererPrivate *priv;
1188 g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);
1192 return (priv->visible &&
1193 (priv->mode == GTK_CELL_RENDERER_MODE_EDITABLE ||
1194 priv->mode == GTK_CELL_RENDERER_MODE_ACTIVATABLE));
1199 * gtk_cell_renderer_stop_editing:
1200 * @cell: A #GtkCellRenderer
1201 * @canceled: %TRUE if the editing has been canceled
1203 * Informs the cell renderer that the editing is stopped.
1204 * If @canceled is %TRUE, the cell renderer will emit the
1205 * #GtkCellRenderer::editing-canceled signal.
1207 * This function should be called by cell renderer implementations
1208 * in response to the #GtkCellEditable::editing-done signal of
1214 gtk_cell_renderer_stop_editing (GtkCellRenderer *cell,
1217 GtkCellRendererPrivate *priv;
1219 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1225 priv->editing = FALSE;
1227 g_signal_emit (cell, cell_renderer_signals[EDITING_CANCELED], 0);
1232 gtk_cell_renderer_real_get_preferred_size (GtkCellRenderer *cell,
1234 GtkOrientation orientation,
1238 GtkRequisition min_req;
1240 /* Fallback on the old API to get the size. */
1241 if (GTK_CELL_RENDERER_GET_CLASS (cell)->get_size)
1242 GTK_CELL_RENDERER_GET_CLASS (cell)->get_size (GTK_CELL_RENDERER (cell), widget, NULL, NULL, NULL,
1243 &min_req.width, &min_req.height);
1250 if (orientation == GTK_ORIENTATION_HORIZONTAL)
1253 *minimum_size = min_req.width;
1256 *natural_size = min_req.width;
1261 *minimum_size = min_req.height;
1264 *natural_size = min_req.height;
1268 static GtkSizeRequestMode
1269 gtk_cell_renderer_real_get_request_mode (GtkCellRenderer *cell)
1271 /* By default cell renderers are height-for-width. */
1272 return GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH;
1276 gtk_cell_renderer_real_get_preferred_width (GtkCellRenderer *cell,
1281 gtk_cell_renderer_real_get_preferred_size (cell, widget, GTK_ORIENTATION_HORIZONTAL,
1282 minimum_size, natural_size);
1286 gtk_cell_renderer_real_get_preferred_height (GtkCellRenderer *cell,
1291 gtk_cell_renderer_real_get_preferred_size (cell, widget, GTK_ORIENTATION_VERTICAL,
1292 minimum_size, natural_size);
1297 gtk_cell_renderer_real_get_preferred_height_for_width (GtkCellRenderer *cell,
1300 gint *minimum_height,
1301 gint *natural_height)
1303 /* Fall back on the height reported from ->get_size() */
1304 gtk_cell_renderer_get_preferred_height (cell, widget, minimum_height, natural_height);
1308 gtk_cell_renderer_real_get_preferred_width_for_height (GtkCellRenderer *cell,
1311 gint *minimum_width,
1312 gint *natural_width)
1314 /* Fall back on the width reported from ->get_size() */
1315 gtk_cell_renderer_get_preferred_width (cell, widget, minimum_width, natural_width);
1319 /* Default implementation assumes that a cell renderer will never use more
1320 * space than its natural size (this is fine for toggles and pixbufs etc
1321 * but needs to be overridden from wrapping/ellipsizing text renderers) */
1323 gtk_cell_renderer_real_get_aligned_area (GtkCellRenderer *cell,
1325 GtkCellRendererState flags,
1326 const GdkRectangle *cell_area,
1327 GdkRectangle *aligned_area)
1329 gint opposite_size, x_offset, y_offset;
1332 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1333 g_return_if_fail (GTK_IS_WIDGET (widget));
1334 g_return_if_fail (cell_area != NULL);
1335 g_return_if_fail (aligned_area != NULL);
1337 *aligned_area = *cell_area;
1339 /* Trim up the aligned size */
1340 if (gtk_cell_renderer_get_request_mode (cell) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH)
1342 gtk_cell_renderer_get_preferred_width (cell, widget,
1343 NULL, &natural_size);
1345 aligned_area->width = MIN (aligned_area->width, natural_size);
1347 gtk_cell_renderer_get_preferred_height_for_width (cell, widget,
1348 aligned_area->width,
1349 NULL, &opposite_size);
1351 aligned_area->height = MIN (opposite_size, aligned_area->height);
1355 gtk_cell_renderer_get_preferred_height (cell, widget,
1356 NULL, &natural_size);
1358 aligned_area->height = MIN (aligned_area->width, natural_size);
1360 gtk_cell_renderer_get_preferred_width_for_height (cell, widget,
1361 aligned_area->height,
1362 NULL, &opposite_size);
1364 aligned_area->width = MIN (opposite_size, aligned_area->width);
1367 /* offset the cell position */
1368 _gtk_cell_renderer_calc_offset (cell, cell_area,
1369 gtk_widget_get_direction (widget),
1370 aligned_area->width,
1371 aligned_area->height,
1372 &x_offset, &y_offset);
1374 aligned_area->x += x_offset;
1375 aligned_area->y += y_offset;
1379 /* An internal convenience function for some containers to peek at the
1380 * cell alignment in a target allocation (used to draw focus and align
1381 * cells in the icon view).
1383 * Note this is only a trivial 'align * (allocation - request)' operation.
1386 _gtk_cell_renderer_calc_offset (GtkCellRenderer *cell,
1387 const GdkRectangle *cell_area,
1388 GtkTextDirection direction,
1394 GtkCellRendererPrivate *priv;
1396 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1397 g_return_if_fail (cell_area != NULL);
1398 g_return_if_fail (x_offset || y_offset);
1404 *x_offset = (((direction == GTK_TEXT_DIR_RTL) ?
1405 (1.0 - priv->xalign) : priv->xalign) *
1406 (cell_area->width - width));
1407 *x_offset = MAX (*x_offset, 0);
1411 *y_offset = (priv->yalign *
1412 (cell_area->height - height));
1413 *y_offset = MAX (*y_offset, 0);
1418 * gtk_cell_renderer_get_request_mode:
1419 * @cell: a #GtkCellRenderer instance
1421 * Gets whether the cell renderer prefers a height-for-width layout
1422 * or a width-for-height layout.
1424 * Returns: The #GtkSizeRequestMode preferred by this renderer.
1429 gtk_cell_renderer_get_request_mode (GtkCellRenderer *cell)
1431 g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);
1433 return GTK_CELL_RENDERER_GET_CLASS (cell)->get_request_mode (cell);
1437 * gtk_cell_renderer_get_preferred_width:
1438 * @cell: a #GtkCellRenderer instance
1439 * @widget: the #GtkWidget this cell will be rendering to
1440 * @minimum_size: (out) (allow-none): location to store the minimum size, or %NULL
1441 * @natural_size: (out) (allow-none): location to store the natural size, or %NULL
1443 * Retreives a renderer's natural size when rendered to @widget.
1448 gtk_cell_renderer_get_preferred_width (GtkCellRenderer *cell,
1453 GtkCellRendererClass *klass;
1456 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1457 g_return_if_fail (GTK_IS_WIDGET (widget));
1458 g_return_if_fail (NULL != minimum_size || NULL != natural_size);
1460 gtk_cell_renderer_get_fixed_size (GTK_CELL_RENDERER (cell), &width, NULL);
1464 klass = GTK_CELL_RENDERER_GET_CLASS (cell);
1465 klass->get_preferred_width (cell, widget, minimum_size, natural_size);
1470 *minimum_size = width;
1472 *natural_size = width;
1475 #if DEBUG_CELL_SIZE_REQUEST
1476 g_message ("%s returning minimum width: %d and natural width: %d",
1477 G_OBJECT_TYPE_NAME (cell),
1478 minimum_size ? *minimum_size : 20000,
1479 natural_size ? *natural_size : 20000);
1485 * gtk_cell_renderer_get_preferred_height:
1486 * @cell: a #GtkCellRenderer instance
1487 * @widget: the #GtkWidget this cell will be rendering to
1488 * @minimum_size: (out) (allow-none): location to store the minimum size, or %NULL
1489 * @natural_size: (out) (allow-none): location to store the natural size, or %NULL
1491 * Retreives a renderer's natural size when rendered to @widget.
1496 gtk_cell_renderer_get_preferred_height (GtkCellRenderer *cell,
1501 GtkCellRendererClass *klass;
1504 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1505 g_return_if_fail (GTK_IS_WIDGET (widget));
1506 g_return_if_fail (NULL != minimum_size || NULL != natural_size);
1508 gtk_cell_renderer_get_fixed_size (GTK_CELL_RENDERER (cell), NULL, &height);
1512 klass = GTK_CELL_RENDERER_GET_CLASS (cell);
1513 klass->get_preferred_height (cell, widget, minimum_size, natural_size);
1518 *minimum_size = height;
1520 *natural_size = height;
1523 #if DEBUG_CELL_SIZE_REQUEST
1524 g_message ("%s returning minimum height: %d and natural height: %d",
1525 G_OBJECT_TYPE_NAME (cell),
1526 minimum_size ? *minimum_size : 20000,
1527 natural_size ? *natural_size : 20000);
1533 * gtk_cell_renderer_get_preferred_width_for_height:
1534 * @cell: a #GtkCellRenderer instance
1535 * @widget: the #GtkWidget this cell will be rendering to
1536 * @height: the size which is available for allocation
1537 * @minimum_width: (out) (allow-none): location for storing the minimum size, or %NULL
1538 * @natural_width: (out) (allow-none): location for storing the preferred size, or %NULL
1540 * Retreives a cell renderers's minimum and natural width if it were rendered to
1541 * @widget with the specified @height.
1546 gtk_cell_renderer_get_preferred_width_for_height (GtkCellRenderer *cell,
1549 gint *minimum_width,
1550 gint *natural_width)
1552 GtkCellRendererClass *klass;
1555 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1556 g_return_if_fail (GTK_IS_WIDGET (widget));
1557 g_return_if_fail (NULL != minimum_width || NULL != natural_width);
1559 gtk_cell_renderer_get_fixed_size (GTK_CELL_RENDERER (cell), &width, NULL);
1563 klass = GTK_CELL_RENDERER_GET_CLASS (cell);
1564 klass->get_preferred_width_for_height (cell, widget, height, minimum_width, natural_width);
1569 *minimum_width = width;
1571 *natural_width = width;
1574 #if DEBUG_CELL_SIZE_REQUEST
1575 g_message ("%s width for height: %d is minimum %d and natural: %d",
1576 G_OBJECT_TYPE_NAME (cell), height,
1577 minimum_width ? *minimum_width : 20000,
1578 natural_width ? *natural_width : 20000);
1583 * gtk_cell_renderer_get_preferred_height_for_width:
1584 * @cell: a #GtkCellRenderer instance
1585 * @widget: the #GtkWidget this cell will be rendering to
1586 * @width: the size which is available for allocation
1587 * @minimum_height: (out) (allow-none): location for storing the minimum size, or %NULL
1588 * @natural_height: (out) (allow-none): location for storing the preferred size, or %NULL
1590 * Retreives a cell renderers's minimum and natural height if it were rendered to
1591 * @widget with the specified @width.
1596 gtk_cell_renderer_get_preferred_height_for_width (GtkCellRenderer *cell,
1599 gint *minimum_height,
1600 gint *natural_height)
1602 GtkCellRendererClass *klass;
1605 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1606 g_return_if_fail (GTK_IS_WIDGET (widget));
1607 g_return_if_fail (NULL != minimum_height || NULL != natural_height);
1609 gtk_cell_renderer_get_fixed_size (GTK_CELL_RENDERER (cell), NULL, &height);
1613 klass = GTK_CELL_RENDERER_GET_CLASS (cell);
1614 klass->get_preferred_height_for_width (cell, widget, width, minimum_height, natural_height);
1619 *minimum_height = height;
1621 *natural_height = height;
1624 #if DEBUG_CELL_SIZE_REQUEST
1625 g_message ("%s height for width: %d is minimum %d and natural: %d",
1626 G_OBJECT_TYPE_NAME (cell), width,
1627 minimum_height ? *minimum_height : 20000,
1628 natural_height ? *natural_height : 20000);
1633 * gtk_cell_renderer_get_preferred_size:
1634 * @cell: a #GtkCellRenderer instance
1635 * @widget: the #GtkWidget this cell will be rendering to
1636 * @minimum_size: (out) (allow-none): location for storing the minimum size, or %NULL
1637 * @natural_size: (out) (allow-none): location for storing the natural size, or %NULL
1639 * Retrieves the minimum and natural size of a cell taking
1640 * into account the widget's preference for height-for-width management.
1645 gtk_cell_renderer_get_preferred_size (GtkCellRenderer *cell,
1647 GtkRequisition *minimum_size,
1648 GtkRequisition *natural_size)
1650 gint min_width, nat_width;
1651 gint min_height, nat_height;
1653 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1655 if (gtk_cell_renderer_get_request_mode (cell) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH)
1657 gtk_cell_renderer_get_preferred_width (cell, widget, &min_width, &nat_width);
1661 minimum_size->width = min_width;
1662 gtk_cell_renderer_get_preferred_height_for_width (cell, widget, min_width,
1663 &minimum_size->height, NULL);
1668 natural_size->width = nat_width;
1669 gtk_cell_renderer_get_preferred_height_for_width (cell, widget, nat_width,
1670 NULL, &natural_size->height);
1673 else /* GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT */
1675 gtk_cell_renderer_get_preferred_height (cell, widget, &min_height, &nat_height);
1679 minimum_size->height = min_height;
1680 gtk_cell_renderer_get_preferred_width_for_height (cell, widget, min_height,
1681 &minimum_size->width, NULL);
1686 natural_size->height = nat_height;
1687 gtk_cell_renderer_get_preferred_width_for_height (cell, widget, nat_height,
1688 NULL, &natural_size->width);
1694 * gtk_cell_renderer_get_aligned_area:
1695 * @cell: a #GtkCellRenderer instance
1696 * @widget: the #GtkWidget this cell will be rendering to
1697 * @flags: render flags
1698 * @cell_area: cell area which would be passed to gtk_cell_renderer_render()
1699 * @aligned_area: (out): the return location for the space inside @cell_area
1700 * that would acually be used to render.
1702 * Gets the aligned area used by @cell inside @cell_area. Used for finding
1703 * the appropriate edit and focus rectangle.
1708 gtk_cell_renderer_get_aligned_area (GtkCellRenderer *cell,
1710 GtkCellRendererState flags,
1711 const GdkRectangle *cell_area,
1712 GdkRectangle *aligned_area)
1714 GtkCellRendererClass *klass;
1716 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1717 g_return_if_fail (GTK_IS_WIDGET (widget));
1718 g_return_if_fail (cell_area != NULL);
1719 g_return_if_fail (aligned_area != NULL);
1721 klass = GTK_CELL_RENDERER_GET_CLASS (cell);
1722 klass->get_aligned_area (cell, widget, flags, cell_area, aligned_area);
1724 g_assert (aligned_area->x >= cell_area->x && aligned_area->x <= cell_area->x + cell_area->width);
1725 g_assert (aligned_area->y >= cell_area->y && aligned_area->y <= cell_area->y + cell_area->height);
1726 g_assert ((aligned_area->x - cell_area->x) + aligned_area->width <= cell_area->width);
1727 g_assert ((aligned_area->y - cell_area->y) + aligned_area->height <= cell_area->height);
1731 * gtk_cell_renderer_get_state:
1732 * @cell: a #GtkCellRenderer, or %NULL
1733 * @widget: a #GtkWidget, or %NULL
1734 * @cell_state: cell renderer state
1736 * Translates the cell renderer state to #GtkStateFlags,
1737 * based on the cell renderer and widget sensitivity, and
1738 * the given #GtkCellRendererState.
1740 * Returns: the widget state flags applying to @cell
1745 gtk_cell_renderer_get_state (GtkCellRenderer *cell,
1747 GtkCellRendererState cell_state)
1749 GtkStateFlags state = 0;
1751 g_return_val_if_fail (!cell || GTK_IS_CELL_RENDERER (cell), 0);
1752 g_return_val_if_fail (!widget || GTK_IS_WIDGET (widget), 0);
1755 state |= gtk_widget_get_state_flags (widget);
1757 state &= ~(GTK_STATE_FLAG_FOCUSED | GTK_STATE_FLAG_PRELIGHT | GTK_STATE_FLAG_SELECTED);
1759 if ((state & GTK_STATE_FLAG_INSENSITIVE) != 0 ||
1760 (cell && !gtk_cell_renderer_get_sensitive (cell)) ||
1761 (cell_state & GTK_CELL_RENDERER_INSENSITIVE) != 0)
1763 state |= GTK_STATE_FLAG_INSENSITIVE;
1767 if ((widget && gtk_widget_has_focus (widget)) &&
1768 (cell_state & GTK_CELL_RENDERER_FOCUSED) != 0)
1769 state |= GTK_STATE_FLAG_FOCUSED;
1771 if ((cell_state & GTK_CELL_RENDERER_PRELIT) != 0)
1772 state |= GTK_STATE_FLAG_PRELIGHT;
1775 if ((cell_state & GTK_CELL_RENDERER_SELECTED) != 0)
1776 state |= GTK_STATE_FLAG_SELECTED;
1782 * _gtk_cell_renderer_class_set_accessible_type:
1783 * @renderer_class: class to set the accessible type for
1784 * @type: The object type that implements the accessible for @widget_class.
1785 * The type must be a subtype of #GtkRendererCellAccessible
1787 * Sets the type to be used for creating accessibles for cells rendered by
1788 * cell renderers of @renderer_class. Note that multiple accessibles will
1791 * This function should only be called from class init functions of cell
1795 _gtk_cell_renderer_class_set_accessible_type (GtkCellRendererClass *renderer_class,
1798 GtkCellRendererClassPrivate *priv;
1800 g_return_if_fail (GTK_IS_CELL_RENDERER_CLASS (renderer_class));
1801 g_return_if_fail (g_type_is_a (type, GTK_TYPE_RENDERER_CELL_ACCESSIBLE));
1803 priv = renderer_class->priv;
1805 priv->accessible_type = type;
1809 _gtk_cell_renderer_get_accessible_type (GtkCellRenderer *renderer)
1811 g_return_val_if_fail (GTK_IS_CELL_RENDERER (renderer), GTK_TYPE_RENDERER_CELL_ACCESSIBLE);
1813 return GTK_CELL_RENDERER_GET_CLASS (renderer)->priv->accessible_type;