* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "gtkcellrenderer.h"
-#include "gtkcellsizerequest.h"
#include "gtkintl.h"
#include "gtkmarshalers.h"
+#include "gtktypebuiltins.h"
#include "gtkprivate.h"
#include "gtktreeprivate.h"
+#include "a11y/gtkrenderercellaccessible.h"
+/**
+ * SECTION:gtkcellrenderer
+ * @Short_description: An object for rendering a single cell
+ * @Title: GtkCellRenderer
+ * @See_also: #GtkCellRendererText, #GtkCellRendererPixbuf, #GtkCellRendererToggle
+ *
+ * The #GtkCellRenderer is a base class of a set of objects used for
+ * rendering a cell to a #cairo_t. These objects are used primarily by
+ * the #GtkTreeView widget, though they aren't tied to them in any
+ * specific way. It is worth noting that #GtkCellRenderer is not a
+ * #GtkWidget and cannot be treated as such.
+ *
+ * The primary use of a #GtkCellRenderer is for drawing a certain graphical
+ * elements on a #cairo_t. Typically, one cell renderer is used to
+ * draw many cells on the screen. To this extent, it isn't expected that a
+ * CellRenderer keep any permanent state around. Instead, any state is set
+ * just prior to use using #GObjects property system. Then, the
+ * cell is measured using gtk_cell_renderer_get_size(). Finally, the cell
+ * is rendered in the correct location using gtk_cell_renderer_render().
+ *
+ * There are a number of rules that must be followed when writing a new
+ * #GtkCellRenderer. First and foremost, it's important that a certain set
+ * of properties will always yield a cell renderer of the same size,
+ * barring a #GtkStyle change. The #GtkCellRenderer also has a number of
+ * generic properties that are expected to be honored by all children.
+ *
+ * Beyond merely rendering a cell, cell renderers can optionally
+ * provide active user interface elements. A cell renderer can be
+ * <firstterm>activatable</firstterm> like #GtkCellRendererToggle,
+ * which toggles when it gets activated by a mouse click, or it can be
+ * <firstterm>editable</firstterm> like #GtkCellRendererText, which
+ * allows the user to edit the text using a #GtkEntry.
+ * To make a cell renderer activatable or editable, you have to
+ * implement the #GtkCellRendererClass.activate or
+ * #GtkCellRendererClass.start_editing virtual functions, respectively.
+ *
+ * Many properties of #GtkCellRenderer and its subclasses have a
+ * corresponding "set" property, e.g. "cell-background-set" corresponds
+ * to "cell-background". These "set" properties reflect whether a property
+ * has been set or not. You should not set them independently.
+ */
+
+
+#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,
const GValue *value,
GParamSpec *pspec);
static void set_cell_bg_color (GtkCellRenderer *cell,
- GdkColor *color);
-
-/* Fallback GtkCellSizeRequest implementation to use remaining ->get_size() implementations */
-static void gtk_cell_renderer_cell_size_request_init (GtkCellSizeRequestIface *iface);
-static void gtk_cell_renderer_get_width (GtkCellSizeRequest *cell,
- GtkWidget *widget,
- gint *minimum_size,
- gint *natural_size);
-static void gtk_cell_renderer_get_height (GtkCellSizeRequest *cell,
- GtkWidget *widget,
- gint *minimum_size,
- gint *natural_size);
-static void gtk_cell_renderer_get_height_for_width (GtkCellSizeRequest *cell,
- GtkWidget *widget,
- gint width,
- gint *minimum_height,
- gint *natural_height);
-static void gtk_cell_renderer_get_width_for_height (GtkCellSizeRequest *cell,
- GtkWidget *widget,
- gint height,
- gint *minimum_width,
- gint *natural_width);
-
+ GdkRGBA *rgba);
+
+/* Fallback GtkCellRenderer implementation to use remaining ->get_size() implementations */
+static GtkSizeRequestMode gtk_cell_renderer_real_get_request_mode(GtkCellRenderer *cell);
+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);
+static void gtk_cell_renderer_real_get_aligned_area (GtkCellRenderer *cell,
+ GtkWidget *widget,
+ GtkCellRendererState flags,
+ const GdkRectangle *cell_area,
+ GdkRectangle *aligned_area);
struct _GtkCellRendererPrivate
guint sensitive : 1;
guint editing : 1;
- GdkColor cell_background;
+ GdkRGBA cell_background;
};
+struct _GtkCellRendererClassPrivate
+{
+ GType accessible_type;
+};
enum {
PROP_0,
PROP_IS_EXPANDED,
PROP_CELL_BACKGROUND,
PROP_CELL_BACKGROUND_GDK,
+ PROP_CELL_BACKGROUND_RGBA,
PROP_CELL_BACKGROUND_SET,
PROP_EDITING
};
static guint cell_renderer_signals[LAST_SIGNAL] = { 0 };
-
-/* Do a manual _get_type() here to avoid a deadlock implementing
- * the interface which we are a prerequisite of.
- */
-GType
-gtk_cell_renderer_get_type (void)
-{
- static GType cell_renderer_type = 0;
-
- if (G_UNLIKELY (cell_renderer_type == 0))
- {
- const GTypeInfo cell_renderer_info =
- {
- sizeof (GtkCellRendererClass),
- NULL, /* base_init */
- NULL, /* base_finalize */
- (GClassInitFunc) gtk_cell_renderer_class_init,
- NULL, /* class_finalize */
- NULL, /* class_init */
- sizeof (GtkCellRenderer),
- 0, /* n_preallocs */
- (GInstanceInitFunc) gtk_cell_renderer_init,
- NULL, /* value_table */
- };
-
- const GInterfaceInfo cell_size_request_info =
- {
- (GInterfaceInitFunc) gtk_cell_renderer_cell_size_request_init,
- (GInterfaceFinalizeFunc) NULL,
- NULL /* interface data */
- };
-
- cell_renderer_type = g_type_register_static (GTK_TYPE_OBJECT, "GtkCellRenderer",
- &cell_renderer_info, G_TYPE_FLAG_ABSTRACT);
-
- g_type_add_interface_static (cell_renderer_type, GTK_TYPE_CELL_SIZE_REQUEST,
- &cell_size_request_info) ;
- }
-
- return cell_renderer_type;
-}
-
-
static void
gtk_cell_renderer_init (GtkCellRenderer *cell)
{
class->render = NULL;
class->get_size = NULL;
+ class->get_request_mode = gtk_cell_renderer_real_get_request_mode;
+ 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;
+ class->get_aligned_area = gtk_cell_renderer_real_get_aligned_area;
/**
* GtkCellRenderer::editing-canceled:
NULL,
GTK_PARAM_WRITABLE));
+ /**
+ * GtkCellRenderer:cell-background-gdk:
+ *
+ * Cell background as a #GdkColor
+ *
+ * Deprecated: 3.4: Use #GtkCellRenderer:cell-background-rgba instead.
+ */
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 | G_PARAM_DEPRECATED));
+ /**
+ * 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,
ADD_SET_PROP ("cell-background-set", PROP_CELL_BACKGROUND_SET,
P_("Cell background set"),
- P_("Whether this tag affects the cell background color"));
+ P_("Whether the cell background color is set"));
g_type_class_add_private (class, sizeof (GtkCellRendererPrivate));
+
+ gtk_cell_renderer_class_set_accessible_type (class, GTK_TYPE_RENDERER_CELL_ACCESSIBLE);
+}
+
+static void
+gtk_cell_renderer_base_class_init (gpointer g_class)
+{
+ GtkCellRendererClass *klass = g_class;
+
+ klass->priv = G_TYPE_CLASS_GET_PRIVATE (g_class, GTK_TYPE_CELL_RENDERER, GtkCellRendererClassPrivate);
+}
+
+GType
+gtk_cell_renderer_get_type (void)
+{
+ static GType cell_renderer_type = 0;
+
+ if (G_UNLIKELY (cell_renderer_type == 0))
+ {
+ const GTypeInfo cell_renderer_info =
+ {
+ sizeof (GtkCellRendererClass),
+ gtk_cell_renderer_base_class_init,
+ NULL,
+ (GClassInitFunc) gtk_cell_renderer_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_init */
+ sizeof (GtkWidget),
+ 0, /* n_preallocs */
+ (GInstanceInitFunc) gtk_cell_renderer_init,
+ NULL, /* value_table */
+ };
+ cell_renderer_type = g_type_register_static (G_TYPE_INITIALLY_UNOWNED, "GtkCellRenderer",
+ &cell_renderer_info, G_TYPE_FLAG_ABSTRACT);
+
+ g_type_add_class_private (cell_renderer_type, sizeof (GtkCellRendererClassPrivate));
+ }
+
+ return cell_renderer_type;
}
static void
{
GdkColor color;
- color.red = priv->cell_background.red;
- color.green = priv->cell_background.green;
- color.blue = priv->cell_background.blue;
+ 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;
break;
case PROP_CELL_BACKGROUND:
{
- GdkColor color;
+ GdkRGBA rgba;
- if (!g_value_get_string (value))
- set_cell_bg_color (cell, NULL);
- else if (gdk_color_parse (g_value_get_string (value), &color))
- set_cell_bg_color (cell, &color);
- else
- g_warning ("Don't know color `%s'", g_value_get_string (value));
+ if (!g_value_get_string (value))
+ set_cell_bg_color (cell, NULL);
+ else if (gdk_rgba_parse (&rgba, g_value_get_string (value)))
+ 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");
+ 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:
static void
set_cell_bg_color (GtkCellRenderer *cell,
- GdkColor *color)
+ GdkRGBA *rgba)
{
GtkCellRendererPrivate *priv = cell->priv;
- if (color)
+ if (rgba)
{
if (!priv->cell_background_set)
{
- priv->cell_background_set = TRUE;
- g_object_notify (G_OBJECT (cell), "cell-background-set");
- }
+ priv->cell_background_set = TRUE;
+ g_object_notify (G_OBJECT (cell), "cell-background-set");
+ }
- priv->cell_background.red = color->red;
- priv->cell_background.green = color->green;
- priv->cell_background.blue = color->blue;
+ priv->cell_background = *rgba;
}
else
{
* @cell: a #GtkCellRenderer
* @widget: the widget the renderer is rendering to
* @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
+ * @x_offset: (out) (allow-none): location to return x offset of cell relative to @cell_area, or %NULL
+ * @y_offset: (out) (allow-none): location to return y offset of cell relative to @cell_area, or %NULL
+ * @width: (out) (allow-none): location to return width needed to render a cell, or %NULL
+ * @height: (out) (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
* in @x_offset and @y_offset are inclusive of the xpad and ypad properties.
*
*
- * Deprecated: 3.0: Use gtk_cell_size_request_get_size() instead.
+ * Deprecated: 3.0: Use gtk_cell_renderer_get_preferred_size() instead.
**/
void
gtk_cell_renderer_get_size (GtkCellRenderer *cell,
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
- gtk_cell_size_request_get_size (GTK_CELL_SIZE_REQUEST (cell),
- widget, &request, NULL);
+ gtk_cell_renderer_get_preferred_size (cell, widget, &request, NULL);
if (width)
*width = request.width;
if (cell_area)
_gtk_cell_renderer_calc_offset (cell, cell_area, gtk_widget_get_direction (widget),
- request.width, request.height, x_offset, y_offset);
+ 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)
* @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,
- const GdkRectangle *background_area,
- const GdkRectangle *cell_area,
- const GdkRectangle *expose_area,
- GtkCellRendererState flags)
+ cairo_t *cr,
+ GtkWidget *widget,
+ const GdkRectangle *background_area,
+ const GdkRectangle *cell_area,
+ GtkCellRendererState flags)
{
gboolean selected = FALSE;
GtkCellRendererPrivate *priv = cell->priv;
+ GtkStyleContext *context;
+ GtkStateFlags state;
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)
{
- cairo_t *cr = gdk_cairo_create (window);
-
gdk_cairo_rectangle (cr, background_area);
- gdk_cairo_set_source_color (cr, &priv->cell_background);
+ gdk_cairo_set_source_rgba (cr, &priv->cell_background);
cairo_fill (cr);
-
- cairo_destroy (cr);
}
+ gdk_cairo_rectangle (cr, background_area);
+ cairo_clip (cr);
+
+ context = gtk_widget_get_style_context (widget);
+
+ gtk_style_context_save (context);
+ gtk_style_context_add_class (context, GTK_STYLE_CLASS_CELL);
+
+ state = gtk_cell_renderer_get_state (cell, widget, flags);
+ gtk_style_context_set_state (context, state);
+
GTK_CELL_RENDERER_GET_CLASS (cell)->render (cell,
- window,
+ cr,
widget,
- (GdkRectangle *) background_area,
- (GdkRectangle *) cell_area,
- (GdkRectangle *) expose_area,
+ background_area,
+ cell_area,
flags);
+ gtk_style_context_restore (context);
+ cairo_restore (cr);
}
/**
* @cell: a #GtkCellRenderer
* @event: a #GdkEvent
* @widget: widget that received the event
- * @path: widget-dependent string representation of the event location;
+ * @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 none): A new #GtkCellEditable, or %NULL
**/
GtkCellEditable *
gtk_cell_renderer_start_editing (GtkCellRenderer *cell,
(GdkRectangle *) background_area,
(GdkRectangle *) cell_area,
flags);
+ gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET (editable)),
+ GTK_STYLE_CLASS_CELL);
g_signal_emit (cell,
cell_renderer_signals[EDITING_STARTED], 0,
/**
* gtk_cell_renderer_get_fixed_size:
* @cell: A #GtkCellRenderer
- * @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
+ * @width: (out) (allow-none): location to fill in with the fixed width of the cell, or %NULL
+ * @height: (out) (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.
**/
/**
* 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
+ * @xalign: (out) (allow-none): location to fill in with the x alignment of the cell, or %NULL
+ * @yalign: (out) (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.
*
/**
* 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
+ * @xpad: (out) (allow-none): location to fill in with the x padding of the cell, or %NULL
+ * @ypad: (out) (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.
*
return cell->priv->sensitive;
}
+
+/**
+ * gtk_cell_renderer_is_activatable:
+ * @cell: A #GtkCellRenderer
+ *
+ * Checks whether the cell renderer can do something when activated.
+ *
+ * Returns: %TRUE if the cell renderer can do anything when activated
+ *
+ * Since: 3.0
+ */
+gboolean
+gtk_cell_renderer_is_activatable (GtkCellRenderer *cell)
+{
+ GtkCellRendererPrivate *priv;
+
+ g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);
+
+ priv = cell->priv;
+
+ return (priv->visible &&
+ (priv->mode == GTK_CELL_RENDERER_MODE_EDITABLE ||
+ priv->mode == GTK_CELL_RENDERER_MODE_ACTIVATABLE));
+}
+
+
/**
* gtk_cell_renderer_stop_editing:
* @cell: A #GtkCellRenderer
}
static void
-gtk_cell_renderer_cell_size_request_init (GtkCellSizeRequestIface *iface)
-{
- iface->get_width = gtk_cell_renderer_get_width;
- iface->get_height = gtk_cell_renderer_get_height;
-
- iface->get_width_for_height = gtk_cell_renderer_get_width_for_height;
- iface->get_height_for_width = gtk_cell_renderer_get_height_for_width;
-}
-
-static void
-gtk_cell_renderer_get_desired_size (GtkCellSizeRequest *cell,
- GtkWidget *widget,
- GtkOrientation orientation,
- gint *minimum_size,
- gint *natural_size)
+gtk_cell_renderer_real_get_preferred_size (GtkCellRenderer *cell,
+ GtkWidget *widget,
+ GtkOrientation orientation,
+ gint *minimum_size,
+ gint *natural_size)
{
GtkRequisition min_req;
}
}
+static GtkSizeRequestMode
+gtk_cell_renderer_real_get_request_mode (GtkCellRenderer *cell)
+{
+ /* By default cell renderers are height-for-width. */
+ return GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH;
+}
+
static void
-gtk_cell_renderer_get_width (GtkCellSizeRequest *cell,
- GtkWidget *widget,
- gint *minimum_size,
- gint *natural_size)
+gtk_cell_renderer_real_get_preferred_width (GtkCellRenderer *cell,
+ GtkWidget *widget,
+ gint *minimum_size,
+ gint *natural_size)
{
- gtk_cell_renderer_get_desired_size (cell, widget, GTK_ORIENTATION_HORIZONTAL,
- minimum_size, natural_size);
+ gtk_cell_renderer_real_get_preferred_size (cell, widget, GTK_ORIENTATION_HORIZONTAL,
+ minimum_size, natural_size);
}
static void
-gtk_cell_renderer_get_height (GtkCellSizeRequest *cell,
- GtkWidget *widget,
- gint *minimum_size,
- gint *natural_size)
+gtk_cell_renderer_real_get_preferred_height (GtkCellRenderer *cell,
+ GtkWidget *widget,
+ gint *minimum_size,
+ gint *natural_size)
{
- gtk_cell_renderer_get_desired_size (cell, widget, GTK_ORIENTATION_VERTICAL,
- minimum_size, natural_size);
+ gtk_cell_renderer_real_get_preferred_size (cell, widget, GTK_ORIENTATION_VERTICAL,
+ minimum_size, natural_size);
}
static void
-gtk_cell_renderer_get_height_for_width (GtkCellSizeRequest *cell,
- GtkWidget *widget,
- gint width,
- gint *minimum_height,
- gint *natural_height)
+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_size_request_get_height (cell, widget, minimum_height, natural_height);
+ gtk_cell_renderer_get_preferred_height (cell, widget, minimum_height, natural_height);
}
static void
-gtk_cell_renderer_get_width_for_height (GtkCellSizeRequest *cell,
- GtkWidget *widget,
- gint height,
- gint *minimum_width,
- gint *natural_width)
+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_size_request_get_width (cell, widget, minimum_width, natural_width);
+ gtk_cell_renderer_get_preferred_width (cell, widget, minimum_width, natural_width);
+}
+
+
+/* Default implementation assumes that a cell renderer will never use more
+ * space than its natural size (this is fine for toggles and pixbufs etc
+ * but needs to be overridden from wrapping/ellipsizing text renderers) */
+static void
+gtk_cell_renderer_real_get_aligned_area (GtkCellRenderer *cell,
+ GtkWidget *widget,
+ GtkCellRendererState flags,
+ const GdkRectangle *cell_area,
+ GdkRectangle *aligned_area)
+{
+ gint opposite_size, x_offset, y_offset;
+ gint natural_size;
+
+ g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_if_fail (cell_area != NULL);
+ g_return_if_fail (aligned_area != NULL);
+
+ *aligned_area = *cell_area;
+
+ /* Trim up the aligned size */
+ if (gtk_cell_renderer_get_request_mode (cell) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH)
+ {
+ gtk_cell_renderer_get_preferred_width (cell, widget,
+ NULL, &natural_size);
+
+ aligned_area->width = MIN (aligned_area->width, natural_size);
+
+ gtk_cell_renderer_get_preferred_height_for_width (cell, widget,
+ aligned_area->width,
+ NULL, &opposite_size);
+
+ aligned_area->height = MIN (opposite_size, aligned_area->height);
+ }
+ else
+ {
+ gtk_cell_renderer_get_preferred_height (cell, widget,
+ NULL, &natural_size);
+
+ aligned_area->height = MIN (aligned_area->width, natural_size);
+
+ gtk_cell_renderer_get_preferred_width_for_height (cell, widget,
+ aligned_area->height,
+ NULL, &opposite_size);
+
+ aligned_area->width = MIN (opposite_size, aligned_area->width);
+ }
+
+ /* offset the cell position */
+ _gtk_cell_renderer_calc_offset (cell, cell_area,
+ gtk_widget_get_direction (widget),
+ aligned_area->width,
+ aligned_area->height,
+ &x_offset, &y_offset);
+
+ aligned_area->x += x_offset;
+ aligned_area->y += y_offset;
}
+
/* 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).
*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)
+{
+ g_return_val_if_fail (GTK_IS_CELL_RENDERER (cell), FALSE);
+
+ return GTK_CELL_RENDERER_GET_CLASS (cell)->get_request_mode (cell);
+}
+
+/**
+ * gtk_cell_renderer_get_preferred_width:
+ * @cell: a #GtkCellRenderer instance
+ * @widget: the #GtkWidget this cell will be rendering to
+ * @minimum_size: (out) (allow-none): location to store the minimum size, or %NULL
+ * @natural_size: (out) (allow-none): 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: (out) (allow-none): location to store the minimum size, or %NULL
+ * @natural_size: (out) (allow-none): 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: (out) (allow-none): location for storing the minimum size, or %NULL
+ * @natural_width: (out) (allow-none): 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: (out) (allow-none): location for storing the minimum size, or %NULL
+ * @natural_height: (out) (allow-none): 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
+ * @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.
+ *
+ * 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);
+ }
+ }
+}
+
+/**
+ * gtk_cell_renderer_get_aligned_area:
+ * @cell: a #GtkCellRenderer instance
+ * @widget: the #GtkWidget this cell will be rendering to
+ * @flags: render flags
+ * @cell_area: cell area which would be passed to gtk_cell_renderer_render()
+ * @aligned_area: (out): the return location for the space inside @cell_area
+ * that would acually be used to render.
+ *
+ * Gets the aligned area used by @cell inside @cell_area. Used for finding
+ * the appropriate edit and focus rectangle.
+ *
+ * Since: 3.0
+ */
+void
+gtk_cell_renderer_get_aligned_area (GtkCellRenderer *cell,
+ GtkWidget *widget,
+ GtkCellRendererState flags,
+ const GdkRectangle *cell_area,
+ GdkRectangle *aligned_area)
+{
+ GtkCellRendererClass *klass;
+
+ g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_if_fail (cell_area != NULL);
+ g_return_if_fail (aligned_area != NULL);
+
+ klass = GTK_CELL_RENDERER_GET_CLASS (cell);
+ klass->get_aligned_area (cell, widget, flags, cell_area, aligned_area);
+
+ g_assert (aligned_area->x >= cell_area->x && aligned_area->x <= cell_area->x + cell_area->width);
+ g_assert (aligned_area->y >= cell_area->y && aligned_area->y <= cell_area->y + cell_area->height);
+ g_assert ((aligned_area->x - cell_area->x) + aligned_area->width <= cell_area->width);
+ g_assert ((aligned_area->y - cell_area->y) + aligned_area->height <= cell_area->height);
+}
+
+/**
+ * gtk_cell_renderer_get_state:
+ * @cell: a #GtkCellRenderer, or %NULL
+ * @widget: a #GtkWidget, or %NULL
+ * @cell_state: cell renderer state
+ *
+ * Translates the cell renderer state to #GtkStateFlags,
+ * based on the cell renderer and widget sensitivity, and
+ * the given #GtkCellRendererState.
+ *
+ * Returns: the widget state flags applying to @cell
+ *
+ * Since: 3.0
+ **/
+GtkStateFlags
+gtk_cell_renderer_get_state (GtkCellRenderer *cell,
+ GtkWidget *widget,
+ GtkCellRendererState cell_state)
+{
+ GtkStateFlags state = 0;
+
+ g_return_val_if_fail (!cell || GTK_IS_CELL_RENDERER (cell), 0);
+ g_return_val_if_fail (!widget || GTK_IS_WIDGET (widget), 0);
+
+ if (widget)
+ state |= gtk_widget_get_state_flags (widget);
+
+ state &= ~(GTK_STATE_FLAG_FOCUSED | GTK_STATE_FLAG_PRELIGHT | GTK_STATE_FLAG_SELECTED);
+
+ if ((state & GTK_STATE_FLAG_INSENSITIVE) != 0 ||
+ (cell && !gtk_cell_renderer_get_sensitive (cell)) ||
+ (cell_state & GTK_CELL_RENDERER_INSENSITIVE) != 0)
+ {
+ state |= GTK_STATE_FLAG_INSENSITIVE;
+ }
+ else
+ {
+ if ((widget && gtk_widget_has_focus (widget)) &&
+ (cell_state & GTK_CELL_RENDERER_FOCUSED) != 0)
+ state |= GTK_STATE_FLAG_FOCUSED;
+
+ if ((cell_state & GTK_CELL_RENDERER_PRELIT) != 0)
+ state |= GTK_STATE_FLAG_PRELIGHT;
+ }
+
+ if ((cell_state & GTK_CELL_RENDERER_SELECTED) != 0)
+ state |= GTK_STATE_FLAG_SELECTED;
+
+ return state;
+}
+
+/**
+ * gtk_cell_renderer_class_set_accessible_type:
+ * @renderer_class: class to set the accessible type for
+ * @type: The object type that implements the accessible for @widget_class.
+ * The type must be a subtype of #GtkRendererCellAccessible
+ *
+ * Sets the type to be used for creating accessibles for cells rendered by
+ * cell renderers of @renderer_class. Note that multiple accessibles will
+ * be created.
+ *
+ * This function should only be called from class init functions of cell
+ * renderers.
+ **/
+void
+gtk_cell_renderer_class_set_accessible_type (GtkCellRendererClass *renderer_class,
+ GType type)
+{
+ GtkCellRendererClassPrivate *priv;
+
+ g_return_if_fail (GTK_IS_CELL_RENDERER_CLASS (renderer_class));
+ g_return_if_fail (g_type_is_a (type, GTK_TYPE_RENDERER_CELL_ACCESSIBLE));
+
+ priv = renderer_class->priv;
+
+ priv->accessible_type = type;
+}
+
+GType
+_gtk_cell_renderer_get_accessible_type (GtkCellRenderer *renderer)
+{
+ g_return_val_if_fail (GTK_IS_CELL_RENDERER (renderer), GTK_TYPE_RENDERER_CELL_ACCESSIBLE);
+
+ return GTK_CELL_RENDERER_GET_CLASS (renderer)->priv->accessible_type;
+}
+
projects / ~andy / gtk / blobdiff