X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkcellrenderer.c;h=3656599483bab473de70fd969037961e48994d0c;hb=abcfd2d5ef4caaf2c903624a3c7e61d61f30411a;hp=8b1396622678f441067c380f4b14a5a653f43637;hpb=a504db9e83bb022aaaa6d265481fc2bb376e87df;p=~andy%2Fgtk diff --git a/gtk/gtkcellrenderer.c b/gtk/gtkcellrenderer.c index 8b1396622..365659948 100644 --- a/gtk/gtkcellrenderer.c +++ b/gtk/gtkcellrenderer.c @@ -17,11 +17,17 @@ * Boston, MA 02111-1307, USA. */ +#include "config.h" #include "gtkcellrenderer.h" #include "gtkintl.h" +#include "gtkmarshalers.h" +#include "gtkprivate.h" +#include "gtktreeprivate.h" -static void gtk_cell_renderer_init (GtkCellRenderer *cell); -static void gtk_cell_renderer_class_init (GtkCellRendererClass *class); +#define DEBUG_CELL_SIZE_REQUEST 0 + +static void gtk_cell_renderer_init (GtkCellRenderer *cell); +static void gtk_cell_renderer_class_init (GtkCellRendererClass *class); static void gtk_cell_renderer_get_property (GObject *object, guint param_id, GValue *value, @@ -30,12 +36,59 @@ static void gtk_cell_renderer_set_property (GObject *object, guint param_id, const GValue *value, GParamSpec *pspec); +static void set_cell_bg_color (GtkCellRenderer *cell, + GdkRGBA *rgba); + +/* Fallback GtkCellRenderer implementation to use remaining ->get_size() implementations */ +static void gtk_cell_renderer_real_get_preferred_width (GtkCellRenderer *cell, + GtkWidget *widget, + gint *minimum_size, + gint *natural_size); +static void gtk_cell_renderer_real_get_preferred_height (GtkCellRenderer *cell, + GtkWidget *widget, + gint *minimum_size, + gint *natural_size); +static void gtk_cell_renderer_real_get_preferred_height_for_width(GtkCellRenderer *cell, + GtkWidget *widget, + gint width, + gint *minimum_height, + gint *natural_height); +static void gtk_cell_renderer_real_get_preferred_width_for_height(GtkCellRenderer *cell, + GtkWidget *widget, + gint height, + gint *minimum_width, + gint *natural_width); + + + +struct _GtkCellRendererPrivate +{ + gfloat xalign; + gfloat yalign; + + gint width; + gint height; + + guint16 xpad; + guint16 ypad; + + guint mode : 2; + guint visible : 1; + guint is_expander : 1; + guint is_expanded : 1; + guint cell_background_set : 1; + guint sensitive : 1; + guint editing : 1; + + GdkRGBA cell_background; +}; enum { - PROP_ZERO, + PROP_0, PROP_MODE, PROP_VISIBLE, + PROP_SENSITIVE, PROP_XALIGN, PROP_YALIGN, PROP_XPAD, @@ -43,47 +96,47 @@ enum { PROP_WIDTH, PROP_HEIGHT, PROP_IS_EXPANDER, - PROP_IS_EXPANDED + PROP_IS_EXPANDED, + PROP_CELL_BACKGROUND, + PROP_CELL_BACKGROUND_GDK, + PROP_CELL_BACKGROUND_RGBA, + PROP_CELL_BACKGROUND_SET, + PROP_EDITING }; +/* Signal IDs */ +enum { + EDITING_CANCELED, + EDITING_STARTED, + LAST_SIGNAL +}; -GtkType -gtk_cell_renderer_get_type (void) -{ - static GtkType cell_type = 0; - - if (!cell_type) - { - static const GTypeInfo cell_info = - { - sizeof (GtkCellRendererClass), - NULL, /* base_init */ - NULL, /* base_finalize */ - (GClassInitFunc) gtk_cell_renderer_class_init, - NULL, /* class_finalize */ - NULL, /* class_data */ - sizeof (GtkCellRenderer), - 0, - (GInstanceInitFunc) gtk_cell_renderer_init, - }; - - cell_type = g_type_register_static (GTK_TYPE_OBJECT, "GtkCellRenderer", &cell_info, 0); - } +static guint cell_renderer_signals[LAST_SIGNAL] = { 0 }; - return cell_type; -} +G_DEFINE_ABSTRACT_TYPE(GtkCellRenderer, gtk_cell_renderer, G_TYPE_INITIALLY_UNOWNED) static void gtk_cell_renderer_init (GtkCellRenderer *cell) { - cell->mode = GTK_CELL_RENDERER_MODE_INERT; - cell->visible = TRUE; - cell->width = -1; - cell->height = -1; - cell->xalign = 0.5; - cell->yalign = 0.5; - cell->xpad = 0; - cell->ypad = 0; + GtkCellRendererPrivate *priv; + + cell->priv = G_TYPE_INSTANCE_GET_PRIVATE (cell, + GTK_TYPE_CELL_RENDERER, + GtkCellRendererPrivate); + priv = cell->priv; + + priv->mode = GTK_CELL_RENDERER_MODE_INERT; + priv->visible = TRUE; + priv->width = -1; + priv->height = -1; + priv->xalign = 0.5; + priv->yalign = 0.5; + priv->xpad = 0; + priv->ypad = 0; + priv->sensitive = TRUE; + priv->is_expander = FALSE; + priv->is_expanded = FALSE; + priv->editing = FALSE; } static void @@ -96,110 +149,225 @@ gtk_cell_renderer_class_init (GtkCellRendererClass *class) class->render = NULL; class->get_size = NULL; + class->get_preferred_width = gtk_cell_renderer_real_get_preferred_width; + class->get_preferred_height = gtk_cell_renderer_real_get_preferred_height; + class->get_preferred_width_for_height = gtk_cell_renderer_real_get_preferred_width_for_height; + class->get_preferred_height_for_width = gtk_cell_renderer_real_get_preferred_height_for_width; + + /** + * GtkCellRenderer::editing-canceled: + * @renderer: the object which received the signal + * + * This signal gets emitted when the user cancels the process of editing a + * cell. For example, an editable cell renderer could be written to cancel + * editing when the user presses Escape. + * + * See also: gtk_cell_renderer_stop_editing(). + * + * Since: 2.4 + */ + cell_renderer_signals[EDITING_CANCELED] = + g_signal_new (I_("editing-canceled"), + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET (GtkCellRendererClass, editing_canceled), + NULL, NULL, + _gtk_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + /** + * GtkCellRenderer::editing-started: + * @renderer: the object which received the signal + * @editable: the #GtkCellEditable + * @path: the path identifying the edited cell + * + * This signal gets emitted when a cell starts to be edited. + * The intended use of this signal is to do special setup + * on @editable, e.g. adding a #GtkEntryCompletion or setting + * up additional columns in a #GtkComboBox. + * + * Note that GTK+ doesn't guarantee that cell renderers will + * continue to use the same kind of widget for editing in future + * releases, therefore you should check the type of @editable + * before doing any specific setup, as in the following example: + * |[ + * static void + * text_editing_started (GtkCellRenderer *cell, + * GtkCellEditable *editable, + * const gchar *path, + * gpointer data) + * { + * if (GTK_IS_ENTRY (editable)) + * { + * GtkEntry *entry = GTK_ENTRY (editable); + * + * /* ... create a GtkEntryCompletion */ + * + * gtk_entry_set_completion (entry, completion); + * } + * } + * ]| + * + * Since: 2.6 + */ + cell_renderer_signals[EDITING_STARTED] = + g_signal_new (I_("editing-started"), + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET (GtkCellRendererClass, editing_started), + NULL, NULL, + _gtk_marshal_VOID__OBJECT_STRING, + G_TYPE_NONE, 2, + GTK_TYPE_CELL_EDITABLE, + G_TYPE_STRING); g_object_class_install_property (object_class, PROP_MODE, g_param_spec_enum ("mode", - _("mode"), - _("Editable mode of the CellRenderer"), + P_("mode"), + P_("Editable mode of the CellRenderer"), GTK_TYPE_CELL_RENDERER_MODE, GTK_CELL_RENDERER_MODE_INERT, - G_PARAM_READABLE | - G_PARAM_WRITABLE)); + GTK_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_VISIBLE, g_param_spec_boolean ("visible", - _("visible"), - _("Display the cell"), + P_("visible"), + P_("Display the cell"), TRUE, - G_PARAM_READABLE | - G_PARAM_WRITABLE)); + GTK_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_SENSITIVE, + g_param_spec_boolean ("sensitive", + P_("Sensitive"), + P_("Display the cell sensitive"), + TRUE, + GTK_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_XALIGN, g_param_spec_float ("xalign", - _("xalign"), - _("The x-align."), + P_("xalign"), + P_("The x-align"), 0.0, 1.0, - 0.0, - G_PARAM_READABLE | - G_PARAM_WRITABLE)); + 0.5, + GTK_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_YALIGN, g_param_spec_float ("yalign", - _("yalign"), - _("The y-align."), + P_("yalign"), + P_("The y-align"), 0.0, 1.0, 0.5, - G_PARAM_READABLE | - G_PARAM_WRITABLE)); + GTK_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_XPAD, g_param_spec_uint ("xpad", - _("xpad"), - _("The xpad."), + P_("xpad"), + P_("The xpad"), + 0, + G_MAXUINT, 0, - 100, - 2, - G_PARAM_READABLE | - G_PARAM_WRITABLE)); + GTK_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_YPAD, g_param_spec_uint ("ypad", - _("ypad"), - _("The ypad."), + P_("ypad"), + P_("The ypad"), 0, - 100, - 2, - G_PARAM_READABLE | - G_PARAM_WRITABLE)); + G_MAXUINT, + 0, + GTK_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_WIDTH, g_param_spec_int ("width", - _("width"), - _("The fixed width."), + P_("width"), + P_("The fixed width"), -1, - 100, + G_MAXINT, -1, - G_PARAM_READABLE | - G_PARAM_WRITABLE)); + GTK_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_HEIGHT, g_param_spec_int ("height", - _("height"), - _("The fixed height."), + P_("height"), + P_("The fixed height"), -1, - 100, + G_MAXINT, -1, - G_PARAM_READABLE | - G_PARAM_WRITABLE)); + GTK_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_IS_EXPANDER, - g_param_spec_boolean ("is_expander", - _("Is Expander"), - _("Row has children."), + g_param_spec_boolean ("is-expander", + P_("Is Expander"), + P_("Row has children"), FALSE, - G_PARAM_READABLE | - G_PARAM_WRITABLE)); + GTK_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_IS_EXPANDED, - g_param_spec_boolean ("is_expanded", - _("Is Expanded"), - _("Row is an expander row, and is expanded"), + g_param_spec_boolean ("is-expanded", + P_("Is Expanded"), + P_("Row is an expander row, and is expanded"), FALSE, - G_PARAM_READABLE | - G_PARAM_WRITABLE)); + GTK_PARAM_READWRITE)); + + g_object_class_install_property (object_class, + PROP_CELL_BACKGROUND, + g_param_spec_string ("cell-background", + P_("Cell background color name"), + P_("Cell background color as a string"), + NULL, + GTK_PARAM_WRITABLE)); + + g_object_class_install_property (object_class, + PROP_CELL_BACKGROUND_GDK, + g_param_spec_boxed ("cell-background-gdk", + P_("Cell background color"), + P_("Cell background color as a GdkColor"), + GDK_TYPE_COLOR, + GTK_PARAM_READWRITE)); + /** + * GtkCellRenderer:cell-background-rgba: + * + * Cell background as a #GdkRGBA + * + * Since: 3.0 + */ + g_object_class_install_property (object_class, + PROP_CELL_BACKGROUND_RGBA, + g_param_spec_boxed ("cell-background-rgba", + P_("Cell background RGBA color"), + P_("Cell background color as a GdkRGBA"), + GDK_TYPE_RGBA, + GTK_PARAM_READWRITE)); + + g_object_class_install_property (object_class, + PROP_EDITING, + g_param_spec_boolean ("editing", + P_("Editing"), + P_("Whether the cell renderer is currently in editing mode"), + FALSE, + GTK_PARAM_READABLE)); + + +#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)) + + ADD_SET_PROP ("cell-background-set", PROP_CELL_BACKGROUND_SET, + P_("Cell background set"), + P_("Whether this tag affects the cell background color")); + + g_type_class_add_private (class, sizeof (GtkCellRendererPrivate)); } static void @@ -209,39 +377,64 @@ gtk_cell_renderer_get_property (GObject *object, GParamSpec *pspec) { GtkCellRenderer *cell = GTK_CELL_RENDERER (object); + GtkCellRendererPrivate *priv = cell->priv; switch (param_id) { case PROP_MODE: - g_value_set_enum (value, cell->mode); + g_value_set_enum (value, priv->mode); break; case PROP_VISIBLE: - g_value_set_boolean (value, cell->visible); + g_value_set_boolean (value, priv->visible); + break; + case PROP_SENSITIVE: + g_value_set_boolean (value, priv->sensitive); + break; + case PROP_EDITING: + g_value_set_boolean (value, priv->editing); break; case PROP_XALIGN: - g_value_set_float (value, cell->xalign); + g_value_set_float (value, priv->xalign); break; case PROP_YALIGN: - g_value_set_float (value, cell->yalign); + g_value_set_float (value, priv->yalign); break; case PROP_XPAD: - g_value_set_uint (value, cell->xpad); + g_value_set_uint (value, priv->xpad); break; case PROP_YPAD: - g_value_set_uint (value, cell->ypad); + g_value_set_uint (value, priv->ypad); break; case PROP_WIDTH: - g_value_set_int (value, cell->width); + g_value_set_int (value, priv->width); break; case PROP_HEIGHT: - g_value_set_int (value, cell->height); + g_value_set_int (value, priv->height); break; case PROP_IS_EXPANDER: - g_value_set_int (value, cell->is_expander); + g_value_set_boolean (value, priv->is_expander); break; case PROP_IS_EXPANDED: - g_value_set_int (value, cell->is_expanded); + g_value_set_boolean (value, priv->is_expanded); + break; + case PROP_CELL_BACKGROUND_GDK: + { + GdkColor color; + + color.red = (guint16) (priv->cell_background.red * 65535); + color.green = (guint16) (priv->cell_background.green * 65535); + color.blue = (guint16) (priv->cell_background.blue * 65535); + + g_value_set_boxed (value, &color); + } + break; + case PROP_CELL_BACKGROUND_RGBA: + g_value_set_boxed (value, &priv->cell_background); break; + case PROP_CELL_BACKGROUND_SET: + g_value_set_boolean (value, priv->cell_background_set); + break; + case PROP_CELL_BACKGROUND: default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec); break; @@ -256,38 +449,87 @@ gtk_cell_renderer_set_property (GObject *object, GParamSpec *pspec) { GtkCellRenderer *cell = GTK_CELL_RENDERER (object); + GtkCellRendererPrivate *priv = cell->priv; switch (param_id) { case PROP_MODE: - cell->mode = g_value_get_enum (value); + priv->mode = g_value_get_enum (value); break; case PROP_VISIBLE: - cell->visible = g_value_get_boolean (value); + priv->visible = g_value_get_boolean (value); + break; + case PROP_SENSITIVE: + priv->sensitive = g_value_get_boolean (value); + break; + case PROP_EDITING: + priv->editing = g_value_get_boolean (value); break; case PROP_XALIGN: - cell->xalign = g_value_get_float (value); + priv->xalign = g_value_get_float (value); break; case PROP_YALIGN: - cell->yalign = g_value_get_float (value); + priv->yalign = g_value_get_float (value); break; case PROP_XPAD: - cell->xpad = g_value_get_uint (value); + priv->xpad = g_value_get_uint (value); break; case PROP_YPAD: - cell->ypad = g_value_get_uint (value); + priv->ypad = g_value_get_uint (value); break; case PROP_WIDTH: - cell->width = g_value_get_int (value); + priv->width = g_value_get_int (value); break; case PROP_HEIGHT: - cell->height = g_value_get_int (value); + priv->height = g_value_get_int (value); break; case PROP_IS_EXPANDER: - cell->is_expander = g_value_get_boolean (value); + priv->is_expander = g_value_get_boolean (value); break; case PROP_IS_EXPANDED: - cell->is_expanded = g_value_get_boolean (value); + priv->is_expanded = g_value_get_boolean (value); + break; + case PROP_CELL_BACKGROUND: + { + GdkRGBA rgba; + + if (!g_value_get_string (value)) + set_cell_bg_color (cell, NULL); + else if (gdk_rgba_parse (g_value_get_string (value), &rgba)) + set_cell_bg_color (cell, &rgba); + else + g_warning ("Don't know color `%s'", g_value_get_string (value)); + + g_object_notify (object, "cell-background-gdk"); + } + break; + case PROP_CELL_BACKGROUND_GDK: + { + GdkColor *color; + + color = g_value_get_boxed (value); + if (color) + { + GdkRGBA rgba; + + rgba.red = color->red / 65535.; + rgba.green = color->green / 65535.; + rgba.blue = color->blue / 65535.; + rgba.alpha = 1; + + set_cell_bg_color (cell, &rgba); + } + else + { + set_cell_bg_color (cell, NULL); + } + } + break; + case PROP_CELL_BACKGROUND_RGBA: + set_cell_bg_color (cell, g_value_get_boxed (value)); + break; + case PROP_CELL_BACKGROUND_SET: + priv->cell_background_set = g_value_get_boolean (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec); @@ -295,90 +537,131 @@ gtk_cell_renderer_set_property (GObject *object, } } +static void +set_cell_bg_color (GtkCellRenderer *cell, + GdkRGBA *rgba) +{ + GtkCellRendererPrivate *priv = cell->priv; + + if (rgba) + { + if (!priv->cell_background_set) + { + priv->cell_background_set = TRUE; + g_object_notify (G_OBJECT (cell), "cell-background-set"); + } + + priv->cell_background = *rgba; + } + else + { + if (priv->cell_background_set) + { + priv->cell_background_set = FALSE; + g_object_notify (G_OBJECT (cell), "cell-background-set"); + } + } +} + /** * gtk_cell_renderer_get_size: * @cell: a #GtkCellRenderer * @widget: the widget the renderer is rendering to - * @cell_area: The area a cell will be allocated, or %NULL - * @x_offset: location to return x offset of cell relative to @cell_area, or %NULL - * @y_offset: location to return y offset of cell relative to @cell_area, or %NULL - * @width: location to return width needed to render a cell, or %NULL - * @height: location to return height needed to render a cell, or %NULL - * - * Obtains the width and height needed to render the cell. Used by view widgets - * to determine the appropriate size for the cell_area passed to - * gtk_cell_renderer_render(). If @cell_area is not %NULL, fills in the x and y - * offsets (if set) of the cell relative to this location. Please note that the - * values set in @width and @height, as well as those in @x_offset and @y_offset - * are inclusive of the xpad and ypad properties. + * @cell_area: (allow-none): The area a cell will be allocated, or %NULL + * @x_offset: (allow-none): location to return x offset of cell relative to @cell_area, or %NULL + * @y_offset: (allow-none): location to return y offset of cell relative to @cell_area, or %NULL + * @width: (allow-none): location to return width needed to render a cell, or %NULL + * @height: (allow-none): location to return height needed to render a cell, or %NULL + * + * Obtains the width and height needed to render the cell. Used by view + * widgets to determine the appropriate size for the cell_area passed to + * gtk_cell_renderer_render(). If @cell_area is not %NULL, fills in the + * x and y offsets (if set) of the cell relative to this location. + * + * Please note that the values set in @width and @height, as well as those + * in @x_offset and @y_offset are inclusive of the xpad and ypad properties. + * + * + * Deprecated: 3.0: Use gtk_cell_renderer_get_preferred_size() instead. **/ void -gtk_cell_renderer_get_size (GtkCellRenderer *cell, - GtkWidget *widget, - GdkRectangle *cell_area, - gint *x_offset, - gint *y_offset, - gint *width, - gint *height) +gtk_cell_renderer_get_size (GtkCellRenderer *cell, + GtkWidget *widget, + const GdkRectangle *cell_area, + gint *x_offset, + gint *y_offset, + gint *width, + gint *height) { - gint *real_width = width; - gint *real_height = height; + GtkRequisition request; g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); - g_return_if_fail (GTK_CELL_RENDERER_GET_CLASS (cell)->get_size != NULL); - if (width && cell->width != -1) - { - real_width = NULL; - *width = cell->width; - } - if (height && cell->height != -1) - { - real_height = NULL; - *height = cell->height; - } + gtk_cell_renderer_get_preferred_size (cell, widget, &request, NULL); - GTK_CELL_RENDERER_GET_CLASS (cell)->get_size (cell, widget, cell_area, x_offset, y_offset, real_width, real_height); + if (width) + *width = request.width; + + if (height) + *height = request.height; + + if (cell_area) + _gtk_cell_renderer_calc_offset (cell, cell_area, gtk_widget_get_direction (widget), + request.width, request.height, x_offset, y_offset); } /** * gtk_cell_renderer_render: * @cell: a #GtkCellRenderer - * @window: a #GdkDrawable to draw to + * @cr: a cairo context to draw to * @widget: the widget owning @window - * @background_area: entire cell area (including tree expanders and maybe padding on the sides) + * @background_area: entire cell area (including tree expanders and maybe + * padding on the sides) * @cell_area: area normally rendered by a cell renderer - * @expose_area: area that actually needs updating * @flags: flags that affect rendering * * Invokes the virtual render function of the #GtkCellRenderer. The three - * passed-in rectangles are areas of @window. Most renderers will draw within + * passed-in rectangles are areas in @cr. Most renderers will draw within * @cell_area; the xalign, yalign, xpad, and ypad fields of the #GtkCellRenderer * should be honored with respect to @cell_area. @background_area includes the * blank space around the cell, and also the area containing the tree expander; * so the @background_area rectangles for all cells tile to cover the entire - * @window. @expose_area is a clip rectangle. - * + * @window. **/ void -gtk_cell_renderer_render (GtkCellRenderer *cell, - GdkWindow *window, - GtkWidget *widget, - GdkRectangle *background_area, - GdkRectangle *cell_area, - GdkRectangle *expose_area, - GtkCellRendererState flags) +gtk_cell_renderer_render (GtkCellRenderer *cell, + cairo_t *cr, + GtkWidget *widget, + const GdkRectangle *background_area, + const GdkRectangle *cell_area, + GtkCellRendererState flags) { + gboolean selected = FALSE; + GtkCellRendererPrivate *priv = cell->priv; + g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); g_return_if_fail (GTK_CELL_RENDERER_GET_CLASS (cell)->render != NULL); + g_return_if_fail (cr != NULL); + + selected = (flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED; + + cairo_save (cr); + + if (priv->cell_background_set && !selected) + { + gdk_cairo_rectangle (cr, background_area); + gdk_cairo_set_source_rgba (cr, &priv->cell_background); + cairo_fill (cr); + } GTK_CELL_RENDERER_GET_CLASS (cell)->render (cell, - window, + cr, widget, background_area, cell_area, - expose_area, flags); + + cairo_restore (cr); } /** @@ -386,14 +669,15 @@ gtk_cell_renderer_render (GtkCellRenderer *cell, * @cell: a #GtkCellRenderer * @event: a #GdkEvent * @widget: widget that received the event - * @path: widget-dependent string representation of the event location; e.g. for #GtkTreeView, a string representation of #GtkTreePath - * @background_area: background area as passed to @gtk_cell_renderer_render - * @cell_area: cell area as passed to @gtk_cell_renderer_render + * @path: widget-dependent string representation of the event location; + * e.g. for #GtkTreeView, a string representation of #GtkTreePath + * @background_area: background area as passed to gtk_cell_renderer_render() + * @cell_area: cell area as passed to gtk_cell_renderer_render() * @flags: render flags * - * Passes an activate event to the cell renderer for possible processing. Some - * cell renderers may use events; for example, #GtkCellRendererToggle toggles - * when it gets a mouse click. + * Passes an activate event to the cell renderer for possible processing. + * Some cell renderers may use events; for example, #GtkCellRendererToggle + * toggles when it gets a mouse click. * * Return value: %TRUE if the event was consumed/handled **/ @@ -402,13 +686,17 @@ gtk_cell_renderer_activate (GtkCellRenderer *cell, GdkEvent *event, GtkWidget *widget, const gchar *path, - GdkRectangle *background_area, - GdkRectangle *cell_area, + const GdkRectangle *background_area, + const GdkRectangle *cell_area, GtkCellRendererState flags) { + GtkCellRendererPrivate *priv; + g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE); - if (cell->mode != GTK_CELL_RENDERER_MODE_ACTIVATABLE) + priv = cell->priv; + + if (priv->mode != GTK_CELL_RENDERER_MODE_ACTIVATABLE) return FALSE; if (GTK_CELL_RENDERER_GET_CLASS (cell)->activate == NULL) @@ -418,8 +706,8 @@ gtk_cell_renderer_activate (GtkCellRenderer *cell, event, widget, path, - background_area, - cell_area, + (GdkRectangle *) background_area, + (GdkRectangle *) cell_area, flags); } @@ -428,41 +716,54 @@ gtk_cell_renderer_activate (GtkCellRenderer *cell, * @cell: a #GtkCellRenderer * @event: a #GdkEvent * @widget: widget that received the event - * @path: widget-dependent string representation of the event location; e.g. for #GtkTreeView, a string representation of #GtkTreePath - * @background_area: background area as passed to @gtk_cell_renderer_render - * @cell_area: cell area as passed to @gtk_cell_renderer_render + * @path: widget-dependent string representation of the event location; + * e.g. for #GtkTreeView, a string representation of #GtkTreePath + * @background_area: background area as passed to gtk_cell_renderer_render() + * @cell_area: cell area as passed to gtk_cell_renderer_render() * @flags: render flags - * + * * Passes an activate event to the cell renderer for possible processing. - * - * Return value: A new #GtkCellEditable, or %NULL + * + * Return value: (transfer full): A new #GtkCellEditable, or %NULL **/ GtkCellEditable * gtk_cell_renderer_start_editing (GtkCellRenderer *cell, GdkEvent *event, GtkWidget *widget, const gchar *path, - GdkRectangle *background_area, - GdkRectangle *cell_area, + const GdkRectangle *background_area, + const GdkRectangle *cell_area, GtkCellRendererState flags) { + GtkCellRendererPrivate *priv; + GtkCellEditable *editable; + g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), NULL); - if (cell->mode != GTK_CELL_RENDERER_MODE_EDITABLE) + priv = cell->priv; + + if (priv->mode != GTK_CELL_RENDERER_MODE_EDITABLE) return NULL; if (GTK_CELL_RENDERER_GET_CLASS (cell)->start_editing == NULL) return NULL; - - return GTK_CELL_RENDERER_GET_CLASS (cell)->start_editing (cell, - event, - widget, - path, - background_area, - cell_area, - flags); + editable = GTK_CELL_RENDERER_GET_CLASS (cell)->start_editing (cell, + event, + widget, + path, + (GdkRectangle *) background_area, + (GdkRectangle *) cell_area, + flags); + + g_signal_emit (cell, + cell_renderer_signals[EDITING_STARTED], 0, + editable, path); + + priv->editing = TRUE; + + return editable; } /** @@ -470,7 +771,7 @@ gtk_cell_renderer_start_editing (GtkCellRenderer *cell, * @cell: A #GtkCellRenderer * @width: the width of the cell renderer, or -1 * @height: the height of the cell renderer, or -1 - * + * * Sets the renderer size to be explicit, independent of the properties set. **/ void @@ -478,22 +779,26 @@ gtk_cell_renderer_set_fixed_size (GtkCellRenderer *cell, gint width, gint height) { + GtkCellRendererPrivate *priv; + g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); g_return_if_fail (width >= -1 && height >= -1); - if ((width != cell->width) || (height != cell->height)) + priv = cell->priv; + + if ((width != priv->width) || (height != priv->height)) { g_object_freeze_notify (G_OBJECT (cell)); - if (width != cell->width) + if (width != priv->width) { - cell->width = width; + priv->width = width; g_object_notify (G_OBJECT (cell), "width"); } - if (height != cell->height) + if (height != priv->height) { - cell->height = height; + priv->height = height; g_object_notify (G_OBJECT (cell), "height"); } @@ -504,9 +809,9 @@ gtk_cell_renderer_set_fixed_size (GtkCellRenderer *cell, /** * gtk_cell_renderer_get_fixed_size: * @cell: A #GtkCellRenderer - * @width: location to fill in with the fixed width of the widget, or %NULL - * @height: location to fill in with the fixed height of the widget, or %NULL - * + * @width: (allow-none): location to fill in with the fixed width of the cell, or %NULL + * @height: (allow-none): location to fill in with the fixed height of the cell, or %NULL + * * Fills in @width and @height with the appropriate size of @cell. **/ void @@ -514,10 +819,680 @@ gtk_cell_renderer_get_fixed_size (GtkCellRenderer *cell, gint *width, gint *height) { + GtkCellRendererPrivate *priv; + g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); + priv = cell->priv; + if (width) - (* width) = cell->width; + *width = priv->width; if (height) - (* height) = cell->height; + *height = priv->height; +} + +/** + * gtk_cell_renderer_set_alignment: + * @cell: A #GtkCellRenderer + * @xalign: the x alignment of the cell renderer + * @yalign: the y alignment of the cell renderer + * + * Sets the renderer's alignment within its available space. + * + * Since: 2.18 + **/ +void +gtk_cell_renderer_set_alignment (GtkCellRenderer *cell, + gfloat xalign, + gfloat yalign) +{ + GtkCellRendererPrivate *priv; + + g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); + g_return_if_fail (xalign >= 0.0 && xalign <= 1.0); + g_return_if_fail (yalign >= 0.0 && yalign <= 1.0); + + priv = cell->priv; + + if ((xalign != priv->xalign) || (yalign != priv->yalign)) + { + g_object_freeze_notify (G_OBJECT (cell)); + + if (xalign != priv->xalign) + { + priv->xalign = xalign; + g_object_notify (G_OBJECT (cell), "xalign"); + } + + if (yalign != priv->yalign) + { + priv->yalign = yalign; + g_object_notify (G_OBJECT (cell), "yalign"); + } + + g_object_thaw_notify (G_OBJECT (cell)); + } +} + +/** + * gtk_cell_renderer_get_alignment: + * @cell: A #GtkCellRenderer + * @xalign: (allow-none): location to fill in with the x alignment of the cell, or %NULL + * @yalign: (allow-none): location to fill in with the y alignment of the cell, or %NULL + * + * Fills in @xalign and @yalign with the appropriate values of @cell. + * + * Since: 2.18 + **/ +void +gtk_cell_renderer_get_alignment (GtkCellRenderer *cell, + gfloat *xalign, + gfloat *yalign) +{ + GtkCellRendererPrivate *priv; + + g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); + + priv = cell->priv; + + if (xalign) + *xalign = priv->xalign; + if (yalign) + *yalign = priv->yalign; +} + +/** + * gtk_cell_renderer_set_padding: + * @cell: A #GtkCellRenderer + * @xpad: the x padding of the cell renderer + * @ypad: the y padding of the cell renderer + * + * Sets the renderer's padding. + * + * Since: 2.18 + **/ +void +gtk_cell_renderer_set_padding (GtkCellRenderer *cell, + gint xpad, + gint ypad) +{ + GtkCellRendererPrivate *priv; + + g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); + g_return_if_fail (xpad >= 0 && xpad >= 0); + + priv = cell->priv; + + if ((xpad != priv->xpad) || (ypad != priv->ypad)) + { + g_object_freeze_notify (G_OBJECT (cell)); + + if (xpad != priv->xpad) + { + priv->xpad = xpad; + g_object_notify (G_OBJECT (cell), "xpad"); + } + + if (ypad != priv->ypad) + { + priv->ypad = ypad; + g_object_notify (G_OBJECT (cell), "ypad"); + } + + g_object_thaw_notify (G_OBJECT (cell)); + } +} + +/** + * gtk_cell_renderer_get_padding: + * @cell: A #GtkCellRenderer + * @xpad: (allow-none): location to fill in with the x padding of the cell, or %NULL + * @ypad: (allow-none): location to fill in with the y padding of the cell, or %NULL + * + * Fills in @xpad and @ypad with the appropriate values of @cell. + * + * Since: 2.18 + **/ +void +gtk_cell_renderer_get_padding (GtkCellRenderer *cell, + gint *xpad, + gint *ypad) +{ + GtkCellRendererPrivate *priv; + + g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); + + priv = cell->priv; + + if (xpad) + *xpad = priv->xpad; + if (ypad) + *ypad = priv->ypad; +} + +/** + * gtk_cell_renderer_set_visible: + * @cell: A #GtkCellRenderer + * @visible: the visibility of the cell + * + * Sets the cell renderer's visibility. + * + * Since: 2.18 + **/ +void +gtk_cell_renderer_set_visible (GtkCellRenderer *cell, + gboolean visible) +{ + GtkCellRendererPrivate *priv; + + g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); + + priv = cell->priv; + + if (priv->visible != visible) + { + priv->visible = visible ? TRUE : FALSE; + g_object_notify (G_OBJECT (cell), "visible"); + } +} + +/** + * gtk_cell_renderer_get_visible: + * @cell: A #GtkCellRenderer + * + * Returns the cell renderer's visibility. + * + * Returns: %TRUE if the cell renderer is visible + * + * Since: 2.18 + */ +gboolean +gtk_cell_renderer_get_visible (GtkCellRenderer *cell) +{ + g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE); + + return cell->priv->visible; +} + +/** + * gtk_cell_renderer_set_sensitive: + * @cell: A #GtkCellRenderer + * @sensitive: the sensitivity of the cell + * + * Sets the cell renderer's sensitivity. + * + * Since: 2.18 + **/ +void +gtk_cell_renderer_set_sensitive (GtkCellRenderer *cell, + gboolean sensitive) +{ + GtkCellRendererPrivate *priv; + + g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); + + priv = cell->priv; + + if (priv->sensitive != sensitive) + { + priv->sensitive = sensitive ? TRUE : FALSE; + g_object_notify (G_OBJECT (cell), "sensitive"); + } +} + +/** + * gtk_cell_renderer_get_sensitive: + * @cell: A #GtkCellRenderer + * + * Returns the cell renderer's sensitivity. + * + * Returns: %TRUE if the cell renderer is sensitive + * + * Since: 2.18 + */ +gboolean +gtk_cell_renderer_get_sensitive (GtkCellRenderer *cell) +{ + g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE); + + return cell->priv->sensitive; +} + +/** + * gtk_cell_renderer_stop_editing: + * @cell: A #GtkCellRenderer + * @canceled: %TRUE if the editing has been canceled + * + * Informs the cell renderer that the editing is stopped. + * If @canceled is %TRUE, the cell renderer will emit the + * #GtkCellRenderer::editing-canceled signal. + * + * This function should be called by cell renderer implementations + * in response to the #GtkCellEditable::editing-done signal of + * #GtkCellEditable. + * + * Since: 2.6 + **/ +void +gtk_cell_renderer_stop_editing (GtkCellRenderer *cell, + gboolean canceled) +{ + GtkCellRendererPrivate *priv; + + g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); + + priv = cell->priv; + + if (priv->editing) + { + priv->editing = FALSE; + if (canceled) + g_signal_emit (cell, cell_renderer_signals[EDITING_CANCELED], 0); + } +} + +static void +gtk_cell_renderer_real_get_preferred_size (GtkCellRenderer *cell, + GtkWidget *widget, + GtkOrientation orientation, + gint *minimum_size, + gint *natural_size) +{ + GtkRequisition min_req; + + /* Fallback on the old API to get the size. */ + if (GTK_CELL_RENDERER_GET_CLASS (cell)->get_size) + GTK_CELL_RENDERER_GET_CLASS (cell)->get_size (GTK_CELL_RENDERER (cell), widget, NULL, NULL, NULL, + &min_req.width, &min_req.height); + else + { + min_req.width = 0; + min_req.height = 0; + } + + if (orientation == GTK_ORIENTATION_HORIZONTAL) + { + if (minimum_size) + *minimum_size = min_req.width; + + if (natural_size) + *natural_size = min_req.width; + } + else + { + if (minimum_size) + *minimum_size = min_req.height; + + if (natural_size) + *natural_size = min_req.height; + } +} + +static void +gtk_cell_renderer_real_get_preferred_width (GtkCellRenderer *cell, + GtkWidget *widget, + gint *minimum_size, + gint *natural_size) +{ + gtk_cell_renderer_real_get_preferred_size (cell, widget, GTK_ORIENTATION_HORIZONTAL, + minimum_size, natural_size); +} + +static void +gtk_cell_renderer_real_get_preferred_height (GtkCellRenderer *cell, + GtkWidget *widget, + gint *minimum_size, + gint *natural_size) +{ + gtk_cell_renderer_real_get_preferred_size (cell, widget, GTK_ORIENTATION_VERTICAL, + minimum_size, natural_size); +} + + +static void +gtk_cell_renderer_real_get_preferred_height_for_width (GtkCellRenderer *cell, + GtkWidget *widget, + gint width, + gint *minimum_height, + gint *natural_height) +{ + /* Fall back on the height reported from ->get_size() */ + gtk_cell_renderer_get_preferred_height (cell, widget, minimum_height, natural_height); +} + +static void +gtk_cell_renderer_real_get_preferred_width_for_height (GtkCellRenderer *cell, + GtkWidget *widget, + gint height, + gint *minimum_width, + gint *natural_width) +{ + /* Fall back on the width reported from ->get_size() */ + gtk_cell_renderer_get_preferred_width (cell, widget, minimum_width, natural_width); +} + +/* An internal convenience function for some containers to peek at the + * cell alignment in a target allocation (used to draw focus and align + * cells in the icon view). + * + * Note this is only a trivial 'align * (allocation - request)' operation. + */ +void +_gtk_cell_renderer_calc_offset (GtkCellRenderer *cell, + const GdkRectangle *cell_area, + GtkTextDirection direction, + gint width, + gint height, + gint *x_offset, + gint *y_offset) +{ + GtkCellRendererPrivate *priv; + + g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); + g_return_if_fail (cell_area != NULL); + g_return_if_fail (x_offset || y_offset); + + priv = cell->priv; + + if (x_offset) + { + *x_offset = (((direction == GTK_TEXT_DIR_RTL) ? + (1.0 - priv->xalign) : priv->xalign) * + (cell_area->width - width)); + *x_offset = MAX (*x_offset, 0); + } + if (y_offset) + { + *y_offset = (priv->yalign * + (cell_area->height - height)); + *y_offset = MAX (*y_offset, 0); + } +} + +/** + * gtk_cell_renderer_get_request_mode: + * @cell: a #GtkCellRenderer instance + * + * Gets whether the cell renderer prefers a height-for-width layout + * or a width-for-height layout. + * + * Returns: The #GtkSizeRequestMode preferred by this renderer. + * + * Since: 3.0 + */ +GtkSizeRequestMode +gtk_cell_renderer_get_request_mode (GtkCellRenderer *cell) +{ + GtkCellRendererClass *klass; + + g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE); + + klass = GTK_CELL_RENDERER_GET_CLASS (cell); + if (klass->get_request_mode) + return klass->get_request_mode (cell); + + /* By default cell renderers are height-for-width. */ + return GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH; +} + +/** + * gtk_cell_renderer_get_preferred_width: + * @cell: a #GtkCellRenderer instance + * @widget: the #GtkWidget this cell will be rendering to + * @minimum_size: location to store the minimum size, or %NULL + * @natural_size: location to store the natural size, or %NULL + * + * Retreives a renderer's natural size when rendered to @widget. + * + * Since: 3.0 + */ +void +gtk_cell_renderer_get_preferred_width (GtkCellRenderer *cell, + GtkWidget *widget, + gint *minimum_size, + gint *natural_size) +{ + GtkCellRendererClass *klass; + gint width; + + g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); + g_return_if_fail (GTK_IS_WIDGET (widget)); + g_return_if_fail (NULL != minimum_size || NULL != natural_size); + + gtk_cell_renderer_get_fixed_size (GTK_CELL_RENDERER (cell), &width, NULL); + + if (width < 0) + { + klass = GTK_CELL_RENDERER_GET_CLASS (cell); + klass->get_preferred_width (cell, widget, minimum_size, natural_size); + } + else + { + if (minimum_size) + *minimum_size = width; + if (natural_size) + *natural_size = width; + } + +#if DEBUG_CELL_SIZE_REQUEST + g_message ("%s returning minimum width: %d and natural width: %d", + G_OBJECT_TYPE_NAME (cell), + minimum_size ? *minimum_size : 20000, + natural_size ? *natural_size : 20000); +#endif +} + + +/** + * gtk_cell_renderer_get_preferred_height: + * @cell: a #GtkCellRenderer instance + * @widget: the #GtkWidget this cell will be rendering to + * @minimum_size: location to store the minimum size, or %NULL + * @natural_size: location to store the natural size, or %NULL + * + * Retreives a renderer's natural size when rendered to @widget. + * + * Since: 3.0 + */ +void +gtk_cell_renderer_get_preferred_height (GtkCellRenderer *cell, + GtkWidget *widget, + gint *minimum_size, + gint *natural_size) +{ + GtkCellRendererClass *klass; + gint height; + + g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); + g_return_if_fail (GTK_IS_WIDGET (widget)); + g_return_if_fail (NULL != minimum_size || NULL != natural_size); + + gtk_cell_renderer_get_fixed_size (GTK_CELL_RENDERER (cell), NULL, &height); + + if (height < 0) + { + klass = GTK_CELL_RENDERER_GET_CLASS (cell); + klass->get_preferred_height (cell, widget, minimum_size, natural_size); + } + else + { + if (minimum_size) + *minimum_size = height; + if (natural_size) + *natural_size = height; + } + +#if DEBUG_CELL_SIZE_REQUEST + g_message ("%s returning minimum height: %d and natural height: %d", + G_OBJECT_TYPE_NAME (cell), + minimum_size ? *minimum_size : 20000, + natural_size ? *natural_size : 20000); +#endif +} + + +/** + * gtk_cell_renderer_get_preferred_width_for_height: + * @cell: a #GtkCellRenderer instance + * @widget: the #GtkWidget this cell will be rendering to + * @height: the size which is available for allocation + * @minimum_width: location for storing the minimum size, or %NULL + * @natural_width: location for storing the preferred size, or %NULL + * + * Retreives a cell renderers's minimum and natural width if it were rendered to + * @widget with the specified @height. + * + * Since: 3.0 + */ +void +gtk_cell_renderer_get_preferred_width_for_height (GtkCellRenderer *cell, + GtkWidget *widget, + gint height, + gint *minimum_width, + gint *natural_width) +{ + GtkCellRendererClass *klass; + gint width; + + g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); + g_return_if_fail (GTK_IS_WIDGET (widget)); + g_return_if_fail (NULL != minimum_width || NULL != natural_width); + + gtk_cell_renderer_get_fixed_size (GTK_CELL_RENDERER (cell), &width, NULL); + + if (width < 0) + { + klass = GTK_CELL_RENDERER_GET_CLASS (cell); + klass->get_preferred_width_for_height (cell, widget, height, minimum_width, natural_width); + } + else + { + if (minimum_width) + *minimum_width = width; + if (natural_width) + *natural_width = width; + } + +#if DEBUG_CELL_SIZE_REQUEST + g_message ("%s width for height: %d is minimum %d and natural: %d", + G_OBJECT_TYPE_NAME (cell), height, + minimum_width ? *minimum_width : 20000, + natural_width ? *natural_width : 20000); +#endif +} + +/** + * gtk_cell_renderer_get_preferred_height_for_width: + * @cell: a #GtkCellRenderer instance + * @widget: the #GtkWidget this cell will be rendering to + * @width: the size which is available for allocation + * @minimum_height: location for storing the minimum size, or %NULL + * @natural_height: location for storing the preferred size, or %NULL + * + * Retreives a cell renderers's minimum and natural height if it were rendered to + * @widget with the specified @width. + * + * Since: 3.0 + */ +void +gtk_cell_renderer_get_preferred_height_for_width (GtkCellRenderer *cell, + GtkWidget *widget, + gint width, + gint *minimum_height, + gint *natural_height) +{ + GtkCellRendererClass *klass; + gint height; + + g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); + g_return_if_fail (GTK_IS_WIDGET (widget)); + g_return_if_fail (NULL != minimum_height || NULL != natural_height); + + gtk_cell_renderer_get_fixed_size (GTK_CELL_RENDERER (cell), NULL, &height); + + if (height < 0) + { + klass = GTK_CELL_RENDERER_GET_CLASS (cell); + klass->get_preferred_height_for_width (cell, widget, width, minimum_height, natural_height); + } + else + { + if (minimum_height) + *minimum_height = height; + if (natural_height) + *natural_height = height; + } + +#if DEBUG_CELL_SIZE_REQUEST + g_message ("%s height for width: %d is minimum %d and natural: %d", + G_OBJECT_TYPE_NAME (cell), width, + minimum_height ? *minimum_height : 20000, + natural_height ? *natural_height : 20000); +#endif +} + +/** + * gtk_cell_renderer_get_preferred_size: + * @cell: a #GtkCellRenderer instance + * @widget: the #GtkWidget this cell will be rendering to + * @request_natural: Whether to base the contextual request off of the + * base natural or the base minimum + * @minimum_size: (out) (allow-none): location for storing the minimum size, or %NULL + * @natural_size: (out) (allow-none): location for storing the natural size, or %NULL + * + * Retrieves the minimum and natural size of a cell taking + * into account the widget's preference for height-for-width management. + * + * If request_natural is specified, the non-contextual natural value will + * be used to make the contextual request; otherwise the minimum will be used. + * + * Since: 3.0 + */ +void +gtk_cell_renderer_get_preferred_size (GtkCellRenderer *cell, + GtkWidget *widget, + GtkRequisition *minimum_size, + GtkRequisition *natural_size) +{ + gint min_width, nat_width; + gint min_height, nat_height; + + g_return_if_fail (GTK_IS_CELL_RENDERER (cell)); + + if (gtk_cell_renderer_get_request_mode (cell) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH) + { + gtk_cell_renderer_get_preferred_width (cell, widget, &min_width, &nat_width); + + if (minimum_size) + { + minimum_size->width = min_width; + gtk_cell_renderer_get_preferred_height_for_width (cell, widget, min_width, + &minimum_size->height, NULL); + } + + if (natural_size) + { + natural_size->width = nat_width; + gtk_cell_renderer_get_preferred_height_for_width (cell, widget, nat_width, + NULL, &natural_size->height); + } + } + else /* GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT */ + { + gtk_cell_renderer_get_preferred_height (cell, widget, &min_height, &nat_height); + + if (minimum_size) + { + minimum_size->height = min_height; + gtk_cell_renderer_get_preferred_width_for_height (cell, widget, min_height, + &minimum_size->width, NULL); + } + + if (natural_size) + { + natural_size->height = nat_height; + gtk_cell_renderer_get_preferred_width_for_height (cell, widget, nat_height, + NULL, &natural_size->width); + } + } }