* 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 "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 on a GdkDrawable
+ * @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 #GdkDrawable. These objects are used primarily by
+ * 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 #GdkDrawable. Typically, one cell renderer is used to
+ * 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 #GObject<!-- -->s property system. Then, the
+ * 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 formost, it's important that a certain set
+ * #GtkCellRenderer. First and foremost, its 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.
* 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.
*/
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 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
GdkRGBA cell_background;
};
+struct _GtkCellRendererClassPrivate
+{
+ GType accessible_type;
+};
enum {
PROP_0,
static guint cell_renderer_signals[LAST_SIGNAL] = { 0 };
-G_DEFINE_ABSTRACT_TYPE(GtkCellRenderer, gtk_cell_renderer, G_TYPE_INITIALLY_UNOWNED)
-
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));
+ GTK_PARAM_READWRITE | G_PARAM_DEPRECATED));
/**
* GtkCellRenderer:cell-background-rgba:
*
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
* @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
{
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);
cairo_fill (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,
cr,
widget,
background_area,
cell_area,
flags);
-
+ gtk_style_context_restore (context);
cairo_restore (cr);
}
*
* Passes an activate event to the cell renderer for possible processing.
*
- * Return value: (transfer full): 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 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_real_get_preferred_width (GtkCellRenderer *cell,
GtkWidget *widget,
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).
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;
+ 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: location to store the minimum size, or %NULL
- * @natural_size: location to store the natural size, or %NULL
+ * @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.
*
* 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
+ * @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.
*
* @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
+ * @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.
* @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
+ * @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.
* 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_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;
+}
+