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"
22 #include "gtkcellsizerequest.h"
24 #include "gtkmarshalers.h"
25 #include "gtkprivate.h"
26 #include "gtktreeprivate.h"
29 static void gtk_cell_renderer_init (GtkCellRenderer *cell);
30 static void gtk_cell_renderer_class_init (GtkCellRendererClass *class);
31 static void gtk_cell_renderer_get_property (GObject *object,
35 static void gtk_cell_renderer_set_property (GObject *object,
39 static void set_cell_bg_color (GtkCellRenderer *cell,
42 /* Fallback GtkCellSizeRequest implementation to use remaining ->get_size() implementations */
43 static void gtk_cell_renderer_cell_size_request_init (GtkCellSizeRequestIface *iface);
44 static void gtk_cell_renderer_get_width (GtkCellSizeRequest *cell,
48 static void gtk_cell_renderer_get_height (GtkCellSizeRequest *cell,
52 static void gtk_cell_renderer_get_height_for_width (GtkCellSizeRequest *cell,
56 gint *natural_height);
57 static void gtk_cell_renderer_get_width_for_height (GtkCellSizeRequest *cell,
65 struct _GtkCellRendererPrivate
78 guint is_expander : 1;
79 guint is_expanded : 1;
80 guint cell_background_set : 1;
84 GdkColor cell_background;
101 PROP_CELL_BACKGROUND,
102 PROP_CELL_BACKGROUND_GDK,
103 PROP_CELL_BACKGROUND_SET,
114 static guint cell_renderer_signals[LAST_SIGNAL] = { 0 };
117 /* Do a manual _get_type() here to avoid a deadlock implementing
118 * the interface which we are a prerequisite of.
121 gtk_cell_renderer_get_type (void)
123 static GType cell_renderer_type = 0;
125 if (G_UNLIKELY (cell_renderer_type == 0))
127 const GTypeInfo cell_renderer_info =
129 sizeof (GtkCellRendererClass),
130 NULL, /* base_init */
131 NULL, /* base_finalize */
132 (GClassInitFunc) gtk_cell_renderer_class_init,
133 NULL, /* class_finalize */
134 NULL, /* class_init */
135 sizeof (GtkCellRenderer),
137 (GInstanceInitFunc) gtk_cell_renderer_init,
138 NULL, /* value_table */
141 const GInterfaceInfo cell_size_request_info =
143 (GInterfaceInitFunc) gtk_cell_renderer_cell_size_request_init,
144 (GInterfaceFinalizeFunc) NULL,
145 NULL /* interface data */
148 cell_renderer_type = g_type_register_static (GTK_TYPE_OBJECT, "GtkCellRenderer",
149 &cell_renderer_info, G_TYPE_FLAG_ABSTRACT);
151 g_type_add_interface_static (cell_renderer_type, GTK_TYPE_CELL_SIZE_REQUEST,
152 &cell_size_request_info) ;
155 return cell_renderer_type;
160 gtk_cell_renderer_init (GtkCellRenderer *cell)
162 GtkCellRendererPrivate *priv;
164 cell->priv = G_TYPE_INSTANCE_GET_PRIVATE (cell,
165 GTK_TYPE_CELL_RENDERER,
166 GtkCellRendererPrivate);
169 priv->mode = GTK_CELL_RENDERER_MODE_INERT;
170 priv->visible = TRUE;
177 priv->sensitive = TRUE;
178 priv->is_expander = FALSE;
179 priv->is_expanded = FALSE;
180 priv->editing = FALSE;
184 gtk_cell_renderer_class_init (GtkCellRendererClass *class)
186 GObjectClass *object_class = G_OBJECT_CLASS (class);
188 object_class->get_property = gtk_cell_renderer_get_property;
189 object_class->set_property = gtk_cell_renderer_set_property;
191 class->render = NULL;
192 class->get_size = NULL;
195 * GtkCellRenderer::editing-canceled:
196 * @renderer: the object which received the signal
198 * This signal gets emitted when the user cancels the process of editing a
199 * cell. For example, an editable cell renderer could be written to cancel
200 * editing when the user presses Escape.
202 * See also: gtk_cell_renderer_stop_editing().
206 cell_renderer_signals[EDITING_CANCELED] =
207 g_signal_new (I_("editing-canceled"),
208 G_OBJECT_CLASS_TYPE (object_class),
210 G_STRUCT_OFFSET (GtkCellRendererClass, editing_canceled),
212 _gtk_marshal_VOID__VOID,
216 * GtkCellRenderer::editing-started:
217 * @renderer: the object which received the signal
218 * @editable: the #GtkCellEditable
219 * @path: the path identifying the edited cell
221 * This signal gets emitted when a cell starts to be edited.
222 * The intended use of this signal is to do special setup
223 * on @editable, e.g. adding a #GtkEntryCompletion or setting
224 * up additional columns in a #GtkComboBox.
226 * Note that GTK+ doesn't guarantee that cell renderers will
227 * continue to use the same kind of widget for editing in future
228 * releases, therefore you should check the type of @editable
229 * before doing any specific setup, as in the following example:
232 * text_editing_started (GtkCellRenderer *cell,
233 * GtkCellEditable *editable,
237 * if (GTK_IS_ENTRY (editable))
239 * GtkEntry *entry = GTK_ENTRY (editable);
241 * /* ... create a GtkEntryCompletion */
243 * gtk_entry_set_completion (entry, completion);
250 cell_renderer_signals[EDITING_STARTED] =
251 g_signal_new (I_("editing-started"),
252 G_OBJECT_CLASS_TYPE (object_class),
254 G_STRUCT_OFFSET (GtkCellRendererClass, editing_started),
256 _gtk_marshal_VOID__OBJECT_STRING,
258 GTK_TYPE_CELL_EDITABLE,
261 g_object_class_install_property (object_class,
263 g_param_spec_enum ("mode",
265 P_("Editable mode of the CellRenderer"),
266 GTK_TYPE_CELL_RENDERER_MODE,
267 GTK_CELL_RENDERER_MODE_INERT,
268 GTK_PARAM_READWRITE));
270 g_object_class_install_property (object_class,
272 g_param_spec_boolean ("visible",
274 P_("Display the cell"),
276 GTK_PARAM_READWRITE));
277 g_object_class_install_property (object_class,
279 g_param_spec_boolean ("sensitive",
281 P_("Display the cell sensitive"),
283 GTK_PARAM_READWRITE));
285 g_object_class_install_property (object_class,
287 g_param_spec_float ("xalign",
293 GTK_PARAM_READWRITE));
295 g_object_class_install_property (object_class,
297 g_param_spec_float ("yalign",
303 GTK_PARAM_READWRITE));
305 g_object_class_install_property (object_class,
307 g_param_spec_uint ("xpad",
313 GTK_PARAM_READWRITE));
315 g_object_class_install_property (object_class,
317 g_param_spec_uint ("ypad",
323 GTK_PARAM_READWRITE));
325 g_object_class_install_property (object_class,
327 g_param_spec_int ("width",
329 P_("The fixed width"),
333 GTK_PARAM_READWRITE));
335 g_object_class_install_property (object_class,
337 g_param_spec_int ("height",
339 P_("The fixed height"),
343 GTK_PARAM_READWRITE));
345 g_object_class_install_property (object_class,
347 g_param_spec_boolean ("is-expander",
349 P_("Row has children"),
351 GTK_PARAM_READWRITE));
354 g_object_class_install_property (object_class,
356 g_param_spec_boolean ("is-expanded",
358 P_("Row is an expander row, and is expanded"),
360 GTK_PARAM_READWRITE));
362 g_object_class_install_property (object_class,
363 PROP_CELL_BACKGROUND,
364 g_param_spec_string ("cell-background",
365 P_("Cell background color name"),
366 P_("Cell background color as a string"),
368 GTK_PARAM_WRITABLE));
370 g_object_class_install_property (object_class,
371 PROP_CELL_BACKGROUND_GDK,
372 g_param_spec_boxed ("cell-background-gdk",
373 P_("Cell background color"),
374 P_("Cell background color as a GdkColor"),
376 GTK_PARAM_READWRITE));
378 g_object_class_install_property (object_class,
380 g_param_spec_boolean ("editing",
382 P_("Whether the cell renderer is currently in editing mode"),
384 GTK_PARAM_READABLE));
387 #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))
389 ADD_SET_PROP ("cell-background-set", PROP_CELL_BACKGROUND_SET,
390 P_("Cell background set"),
391 P_("Whether this tag affects the cell background color"));
393 g_type_class_add_private (class, sizeof (GtkCellRendererPrivate));
397 gtk_cell_renderer_get_property (GObject *object,
402 GtkCellRenderer *cell = GTK_CELL_RENDERER (object);
403 GtkCellRendererPrivate *priv = cell->priv;
408 g_value_set_enum (value, priv->mode);
411 g_value_set_boolean (value, priv->visible);
414 g_value_set_boolean (value, priv->sensitive);
417 g_value_set_boolean (value, priv->editing);
420 g_value_set_float (value, priv->xalign);
423 g_value_set_float (value, priv->yalign);
426 g_value_set_uint (value, priv->xpad);
429 g_value_set_uint (value, priv->ypad);
432 g_value_set_int (value, priv->width);
435 g_value_set_int (value, priv->height);
437 case PROP_IS_EXPANDER:
438 g_value_set_boolean (value, priv->is_expander);
440 case PROP_IS_EXPANDED:
441 g_value_set_boolean (value, priv->is_expanded);
443 case PROP_CELL_BACKGROUND_GDK:
447 color.red = priv->cell_background.red;
448 color.green = priv->cell_background.green;
449 color.blue = priv->cell_background.blue;
451 g_value_set_boxed (value, &color);
454 case PROP_CELL_BACKGROUND_SET:
455 g_value_set_boolean (value, priv->cell_background_set);
457 case PROP_CELL_BACKGROUND:
459 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
466 gtk_cell_renderer_set_property (GObject *object,
471 GtkCellRenderer *cell = GTK_CELL_RENDERER (object);
472 GtkCellRendererPrivate *priv = cell->priv;
477 priv->mode = g_value_get_enum (value);
480 priv->visible = g_value_get_boolean (value);
483 priv->sensitive = g_value_get_boolean (value);
486 priv->editing = g_value_get_boolean (value);
489 priv->xalign = g_value_get_float (value);
492 priv->yalign = g_value_get_float (value);
495 priv->xpad = g_value_get_uint (value);
498 priv->ypad = g_value_get_uint (value);
501 priv->width = g_value_get_int (value);
504 priv->height = g_value_get_int (value);
506 case PROP_IS_EXPANDER:
507 priv->is_expander = g_value_get_boolean (value);
509 case PROP_IS_EXPANDED:
510 priv->is_expanded = g_value_get_boolean (value);
512 case PROP_CELL_BACKGROUND:
516 if (!g_value_get_string (value))
517 set_cell_bg_color (cell, NULL);
518 else if (gdk_color_parse (g_value_get_string (value), &color))
519 set_cell_bg_color (cell, &color);
521 g_warning ("Don't know color `%s'", g_value_get_string (value));
523 g_object_notify (object, "cell-background-gdk");
526 case PROP_CELL_BACKGROUND_GDK:
527 set_cell_bg_color (cell, g_value_get_boxed (value));
529 case PROP_CELL_BACKGROUND_SET:
530 priv->cell_background_set = g_value_get_boolean (value);
533 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
539 set_cell_bg_color (GtkCellRenderer *cell,
542 GtkCellRendererPrivate *priv = cell->priv;
546 if (!priv->cell_background_set)
548 priv->cell_background_set = TRUE;
549 g_object_notify (G_OBJECT (cell), "cell-background-set");
552 priv->cell_background.red = color->red;
553 priv->cell_background.green = color->green;
554 priv->cell_background.blue = color->blue;
558 if (priv->cell_background_set)
560 priv->cell_background_set = FALSE;
561 g_object_notify (G_OBJECT (cell), "cell-background-set");
567 * gtk_cell_renderer_get_size:
568 * @cell: a #GtkCellRenderer
569 * @widget: the widget the renderer is rendering to
570 * @cell_area: (allow-none): The area a cell will be allocated, or %NULL
571 * @x_offset: (allow-none): location to return x offset of cell relative to @cell_area, or %NULL
572 * @y_offset: (allow-none): location to return y offset of cell relative to @cell_area, or %NULL
573 * @width: (allow-none): location to return width needed to render a cell, or %NULL
574 * @height: (allow-none): location to return height needed to render a cell, or %NULL
576 * Obtains the width and height needed to render the cell. Used by view
577 * widgets to determine the appropriate size for the cell_area passed to
578 * gtk_cell_renderer_render(). If @cell_area is not %NULL, fills in the
579 * x and y offsets (if set) of the cell relative to this location.
581 * Please note that the values set in @width and @height, as well as those
582 * in @x_offset and @y_offset are inclusive of the xpad and ypad properties.
585 * Deprecated: 3.0: Use gtk_cell_size_request_get_size() instead.
588 gtk_cell_renderer_get_size (GtkCellRenderer *cell,
590 const GdkRectangle *cell_area,
596 GtkRequisition request;
598 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
600 gtk_cell_size_request_get_size (GTK_CELL_SIZE_REQUEST (cell),
601 widget, &request, NULL);
604 *width = request.width;
607 *height = request.height;
610 _gtk_cell_renderer_calc_offset (cell, cell_area, gtk_widget_get_direction (widget),
611 request.width, request.height, x_offset, y_offset);
615 * gtk_cell_renderer_render:
616 * @cell: a #GtkCellRenderer
617 * @cr: a cairo context to draw to
618 * @widget: the widget owning @window
619 * @background_area: entire cell area (including tree expanders and maybe
620 * padding on the sides)
621 * @cell_area: area normally rendered by a cell renderer
622 * @flags: flags that affect rendering
624 * Invokes the virtual render function of the #GtkCellRenderer. The three
625 * passed-in rectangles are areas in @cr. Most renderers will draw within
626 * @cell_area; the xalign, yalign, xpad, and ypad fields of the #GtkCellRenderer
627 * should be honored with respect to @cell_area. @background_area includes the
628 * blank space around the cell, and also the area containing the tree expander;
629 * so the @background_area rectangles for all cells tile to cover the entire
633 gtk_cell_renderer_render (GtkCellRenderer *cell,
636 const GdkRectangle *background_area,
637 const GdkRectangle *cell_area,
638 GtkCellRendererState flags)
640 gboolean selected = FALSE;
641 GtkCellRendererPrivate *priv = cell->priv;
643 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
644 g_return_if_fail (GTK_CELL_RENDERER_GET_CLASS (cell)->render != NULL);
645 g_return_if_fail (cr != NULL);
647 selected = (flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED;
651 if (priv->cell_background_set && !selected)
653 gdk_cairo_rectangle (cr, background_area);
654 gdk_cairo_set_source_color (cr, &priv->cell_background);
658 GTK_CELL_RENDERER_GET_CLASS (cell)->render (cell,
669 * gtk_cell_renderer_activate:
670 * @cell: a #GtkCellRenderer
671 * @event: a #GdkEvent
672 * @widget: widget that received the event
673 * @path: widget-dependent string representation of the event location;
674 * e.g. for #GtkTreeView, a string representation of #GtkTreePath
675 * @background_area: background area as passed to gtk_cell_renderer_render()
676 * @cell_area: cell area as passed to gtk_cell_renderer_render()
677 * @flags: render flags
679 * Passes an activate event to the cell renderer for possible processing.
680 * Some cell renderers may use events; for example, #GtkCellRendererToggle
681 * toggles when it gets a mouse click.
683 * Return value: %TRUE if the event was consumed/handled
686 gtk_cell_renderer_activate (GtkCellRenderer *cell,
690 const GdkRectangle *background_area,
691 const GdkRectangle *cell_area,
692 GtkCellRendererState flags)
694 GtkCellRendererPrivate *priv;
696 g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);
700 if (priv->mode != GTK_CELL_RENDERER_MODE_ACTIVATABLE)
703 if (GTK_CELL_RENDERER_GET_CLASS (cell)->activate == NULL)
706 return GTK_CELL_RENDERER_GET_CLASS (cell)->activate (cell,
710 (GdkRectangle *) background_area,
711 (GdkRectangle *) cell_area,
716 * gtk_cell_renderer_start_editing:
717 * @cell: a #GtkCellRenderer
718 * @event: a #GdkEvent
719 * @widget: widget that received the event
720 * @path: widget-dependent string representation of the event location;
721 * e.g. for #GtkTreeView, a string representation of #GtkTreePath
722 * @background_area: background area as passed to gtk_cell_renderer_render()
723 * @cell_area: cell area as passed to gtk_cell_renderer_render()
724 * @flags: render flags
726 * Passes an activate event to the cell renderer for possible processing.
728 * Return value: (transfer full): A new #GtkCellEditable, or %NULL
731 gtk_cell_renderer_start_editing (GtkCellRenderer *cell,
735 const GdkRectangle *background_area,
736 const GdkRectangle *cell_area,
737 GtkCellRendererState flags)
740 GtkCellRendererPrivate *priv;
741 GtkCellEditable *editable;
743 g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), NULL);
747 if (priv->mode != GTK_CELL_RENDERER_MODE_EDITABLE)
750 if (GTK_CELL_RENDERER_GET_CLASS (cell)->start_editing == NULL)
753 editable = GTK_CELL_RENDERER_GET_CLASS (cell)->start_editing (cell,
757 (GdkRectangle *) background_area,
758 (GdkRectangle *) cell_area,
762 cell_renderer_signals[EDITING_STARTED], 0,
765 priv->editing = TRUE;
771 * gtk_cell_renderer_set_fixed_size:
772 * @cell: A #GtkCellRenderer
773 * @width: the width of the cell renderer, or -1
774 * @height: the height of the cell renderer, or -1
776 * Sets the renderer size to be explicit, independent of the properties set.
779 gtk_cell_renderer_set_fixed_size (GtkCellRenderer *cell,
783 GtkCellRendererPrivate *priv;
785 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
786 g_return_if_fail (width >= -1 && height >= -1);
790 if ((width != priv->width) || (height != priv->height))
792 g_object_freeze_notify (G_OBJECT (cell));
794 if (width != priv->width)
797 g_object_notify (G_OBJECT (cell), "width");
800 if (height != priv->height)
802 priv->height = height;
803 g_object_notify (G_OBJECT (cell), "height");
806 g_object_thaw_notify (G_OBJECT (cell));
811 * gtk_cell_renderer_get_fixed_size:
812 * @cell: A #GtkCellRenderer
813 * @width: (allow-none): location to fill in with the fixed width of the cell, or %NULL
814 * @height: (allow-none): location to fill in with the fixed height of the cell, or %NULL
816 * Fills in @width and @height with the appropriate size of @cell.
819 gtk_cell_renderer_get_fixed_size (GtkCellRenderer *cell,
823 GtkCellRendererPrivate *priv;
825 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
830 *width = priv->width;
832 *height = priv->height;
836 * gtk_cell_renderer_set_alignment:
837 * @cell: A #GtkCellRenderer
838 * @xalign: the x alignment of the cell renderer
839 * @yalign: the y alignment of the cell renderer
841 * Sets the renderer's alignment within its available space.
846 gtk_cell_renderer_set_alignment (GtkCellRenderer *cell,
850 GtkCellRendererPrivate *priv;
852 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
853 g_return_if_fail (xalign >= 0.0 && xalign <= 1.0);
854 g_return_if_fail (yalign >= 0.0 && yalign <= 1.0);
858 if ((xalign != priv->xalign) || (yalign != priv->yalign))
860 g_object_freeze_notify (G_OBJECT (cell));
862 if (xalign != priv->xalign)
864 priv->xalign = xalign;
865 g_object_notify (G_OBJECT (cell), "xalign");
868 if (yalign != priv->yalign)
870 priv->yalign = yalign;
871 g_object_notify (G_OBJECT (cell), "yalign");
874 g_object_thaw_notify (G_OBJECT (cell));
879 * gtk_cell_renderer_get_alignment:
880 * @cell: A #GtkCellRenderer
881 * @xalign: (allow-none): location to fill in with the x alignment of the cell, or %NULL
882 * @yalign: (allow-none): location to fill in with the y alignment of the cell, or %NULL
884 * Fills in @xalign and @yalign with the appropriate values of @cell.
889 gtk_cell_renderer_get_alignment (GtkCellRenderer *cell,
893 GtkCellRendererPrivate *priv;
895 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
900 *xalign = priv->xalign;
902 *yalign = priv->yalign;
906 * gtk_cell_renderer_set_padding:
907 * @cell: A #GtkCellRenderer
908 * @xpad: the x padding of the cell renderer
909 * @ypad: the y padding of the cell renderer
911 * Sets the renderer's padding.
916 gtk_cell_renderer_set_padding (GtkCellRenderer *cell,
920 GtkCellRendererPrivate *priv;
922 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
923 g_return_if_fail (xpad >= 0 && xpad >= 0);
927 if ((xpad != priv->xpad) || (ypad != priv->ypad))
929 g_object_freeze_notify (G_OBJECT (cell));
931 if (xpad != priv->xpad)
934 g_object_notify (G_OBJECT (cell), "xpad");
937 if (ypad != priv->ypad)
940 g_object_notify (G_OBJECT (cell), "ypad");
943 g_object_thaw_notify (G_OBJECT (cell));
948 * gtk_cell_renderer_get_padding:
949 * @cell: A #GtkCellRenderer
950 * @xpad: (allow-none): location to fill in with the x padding of the cell, or %NULL
951 * @ypad: (allow-none): location to fill in with the y padding of the cell, or %NULL
953 * Fills in @xpad and @ypad with the appropriate values of @cell.
958 gtk_cell_renderer_get_padding (GtkCellRenderer *cell,
962 GtkCellRendererPrivate *priv;
964 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
975 * gtk_cell_renderer_set_visible:
976 * @cell: A #GtkCellRenderer
977 * @visible: the visibility of the cell
979 * Sets the cell renderer's visibility.
984 gtk_cell_renderer_set_visible (GtkCellRenderer *cell,
987 GtkCellRendererPrivate *priv;
989 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
993 if (priv->visible != visible)
995 priv->visible = visible ? TRUE : FALSE;
996 g_object_notify (G_OBJECT (cell), "visible");
1001 * gtk_cell_renderer_get_visible:
1002 * @cell: A #GtkCellRenderer
1004 * Returns the cell renderer's visibility.
1006 * Returns: %TRUE if the cell renderer is visible
1011 gtk_cell_renderer_get_visible (GtkCellRenderer *cell)
1013 g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);
1015 return cell->priv->visible;
1019 * gtk_cell_renderer_set_sensitive:
1020 * @cell: A #GtkCellRenderer
1021 * @sensitive: the sensitivity of the cell
1023 * Sets the cell renderer's sensitivity.
1028 gtk_cell_renderer_set_sensitive (GtkCellRenderer *cell,
1031 GtkCellRendererPrivate *priv;
1033 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1037 if (priv->sensitive != sensitive)
1039 priv->sensitive = sensitive ? TRUE : FALSE;
1040 g_object_notify (G_OBJECT (cell), "sensitive");
1045 * gtk_cell_renderer_get_sensitive:
1046 * @cell: A #GtkCellRenderer
1048 * Returns the cell renderer's sensitivity.
1050 * Returns: %TRUE if the cell renderer is sensitive
1055 gtk_cell_renderer_get_sensitive (GtkCellRenderer *cell)
1057 g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);
1059 return cell->priv->sensitive;
1063 * gtk_cell_renderer_stop_editing:
1064 * @cell: A #GtkCellRenderer
1065 * @canceled: %TRUE if the editing has been canceled
1067 * Informs the cell renderer that the editing is stopped.
1068 * If @canceled is %TRUE, the cell renderer will emit the
1069 * #GtkCellRenderer::editing-canceled signal.
1071 * This function should be called by cell renderer implementations
1072 * in response to the #GtkCellEditable::editing-done signal of
1078 gtk_cell_renderer_stop_editing (GtkCellRenderer *cell,
1081 GtkCellRendererPrivate *priv;
1083 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1089 priv->editing = FALSE;
1091 g_signal_emit (cell, cell_renderer_signals[EDITING_CANCELED], 0);
1096 gtk_cell_renderer_cell_size_request_init (GtkCellSizeRequestIface *iface)
1098 iface->get_width = gtk_cell_renderer_get_width;
1099 iface->get_height = gtk_cell_renderer_get_height;
1101 iface->get_width_for_height = gtk_cell_renderer_get_width_for_height;
1102 iface->get_height_for_width = gtk_cell_renderer_get_height_for_width;
1106 gtk_cell_renderer_get_desired_size (GtkCellSizeRequest *cell,
1108 GtkOrientation orientation,
1112 GtkRequisition min_req;
1114 /* Fallback on the old API to get the size. */
1115 if (GTK_CELL_RENDERER_GET_CLASS (cell)->get_size)
1116 GTK_CELL_RENDERER_GET_CLASS (cell)->get_size (GTK_CELL_RENDERER (cell), widget, NULL, NULL, NULL,
1117 &min_req.width, &min_req.height);
1124 if (orientation == GTK_ORIENTATION_HORIZONTAL)
1127 *minimum_size = min_req.width;
1130 *natural_size = min_req.width;
1135 *minimum_size = min_req.height;
1138 *natural_size = min_req.height;
1143 gtk_cell_renderer_get_width (GtkCellSizeRequest *cell,
1148 gtk_cell_renderer_get_desired_size (cell, widget, GTK_ORIENTATION_HORIZONTAL,
1149 minimum_size, natural_size);
1153 gtk_cell_renderer_get_height (GtkCellSizeRequest *cell,
1158 gtk_cell_renderer_get_desired_size (cell, widget, GTK_ORIENTATION_VERTICAL,
1159 minimum_size, natural_size);
1164 gtk_cell_renderer_get_height_for_width (GtkCellSizeRequest *cell,
1167 gint *minimum_height,
1168 gint *natural_height)
1170 /* Fall back on the height reported from ->get_size() */
1171 gtk_cell_size_request_get_height (cell, widget, minimum_height, natural_height);
1175 gtk_cell_renderer_get_width_for_height (GtkCellSizeRequest *cell,
1178 gint *minimum_width,
1179 gint *natural_width)
1181 /* Fall back on the width reported from ->get_size() */
1182 gtk_cell_size_request_get_width (cell, widget, minimum_width, natural_width);
1185 /* An internal convenience function for some containers to peek at the
1186 * cell alignment in a target allocation (used to draw focus and align
1187 * cells in the icon view).
1189 * Note this is only a trivial 'align * (allocation - request)' operation.
1192 _gtk_cell_renderer_calc_offset (GtkCellRenderer *cell,
1193 const GdkRectangle *cell_area,
1194 GtkTextDirection direction,
1200 GtkCellRendererPrivate *priv;
1202 g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
1203 g_return_if_fail (cell_area != NULL);
1204 g_return_if_fail (x_offset || y_offset);
1210 *x_offset = (((direction == GTK_TEXT_DIR_RTL) ?
1211 (1.0 - priv->xalign) : priv->xalign) *
1212 (cell_area->width - width));
1213 *x_offset = MAX (*x_offset, 0);
1217 *y_offset = (priv->yalign *
1218 (cell_area->height - height));
1219 *y_offset = MAX (*y_offset, 0);