X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkcellrenderer.c;h=9f4b4e203f9ef49bb833a479c069991284b5acdd;hb=f2d6def72eb9951d0c04bfc6fb6add0439c6f74f;hp=b2ef07b4a5e759646549c391c4fbc1be911b1d88;hpb=9a80100e9ab2430ecc4375ba6bd2f66784ce34a9;p=~andy%2Fgtk diff --git a/gtk/gtkcellrenderer.c b/gtk/gtkcellrenderer.c index b2ef07b4a..9f4b4e203 100644 --- a/gtk/gtkcellrenderer.c +++ b/gtk/gtkcellrenderer.c @@ -12,9 +12,7 @@ * 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 . */ #include "config.h" @@ -24,6 +22,7 @@ #include "gtktypebuiltins.h" #include "gtkprivate.h" #include "gtktreeprivate.h" +#include "a11y/gtkrenderercellaccessible.h" /** @@ -42,12 +41,12 @@ * 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 + * 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, 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. @@ -61,6 +60,11 @@ * 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. */ @@ -80,6 +84,7 @@ static void set_cell_bg_color (GtkCellRenderer *cell, 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, @@ -127,6 +132,10 @@ struct _GtkCellRendererPrivate GdkRGBA cell_background; }; +struct _GtkCellRendererClassPrivate +{ + GType accessible_type; +}; enum { PROP_0, @@ -157,8 +166,6 @@ enum { 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) { @@ -193,6 +200,7 @@ gtk_cell_renderer_class_init (GtkCellRendererClass *class) 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; @@ -375,13 +383,20 @@ gtk_cell_renderer_class_init (GtkCellRendererClass *class) 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: * @@ -410,9 +425,48 @@ gtk_cell_renderer_class_init (GtkCellRendererClass *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 @@ -613,10 +667,10 @@ set_cell_bg_color (GtkCellRenderer *cell, * @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 @@ -683,6 +737,8 @@ gtk_cell_renderer_render (GtkCellRenderer *cell, { 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); @@ -702,13 +758,21 @@ gtk_cell_renderer_render (GtkCellRenderer *cell, 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); } @@ -772,7 +836,7 @@ gtk_cell_renderer_activate (GtkCellRenderer *cell, * * 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, @@ -804,6 +868,8 @@ 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, @@ -857,8 +923,8 @@ gtk_cell_renderer_set_fixed_size (GtkCellRenderer *cell, /** * 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. **/ @@ -925,8 +991,8 @@ gtk_cell_renderer_set_alignment (GtkCellRenderer *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. * @@ -994,8 +1060,8 @@ gtk_cell_renderer_set_padding (GtkCellRenderer *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. * @@ -1113,7 +1179,7 @@ gtk_cell_renderer_get_sensitive (GtkCellRenderer *cell) * * Checks whether the cell renderer can do something when activated. * - * Returns: %TRUE if the cell renderer can do anything when activated. + * Returns: %TRUE if the cell renderer can do anything when activated * * Since: 3.0 */ @@ -1126,9 +1192,9 @@ gtk_cell_renderer_is_activatable (GtkCellRenderer *cell) priv = cell->priv; - return (cell->priv->visible && - (cell->priv->mode == GTK_CELL_RENDERER_MODE_EDITABLE || - cell->priv->mode == GTK_CELL_RENDERER_MODE_ACTIVATABLE)); + return (priv->visible && + (priv->mode == GTK_CELL_RENDERER_MODE_EDITABLE || + priv->mode == GTK_CELL_RENDERER_MODE_ACTIVATABLE)); } @@ -1202,6 +1268,13 @@ gtk_cell_renderer_real_get_preferred_size (GtkCellRenderer *cell, } } +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, @@ -1247,7 +1320,7 @@ gtk_cell_renderer_real_get_preferred_width_for_height (GtkCellRenderer *cell, /* Default implementation assumes that a cell renderer will never use more - * space than it's natural size (this is fine for toggles and pixbufs etc + * 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, @@ -1358,24 +1431,17 @@ _gtk_cell_renderer_calc_offset (GtkCellRenderer *cell, 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. * @@ -1422,8 +1488,8 @@ gtk_cell_renderer_get_preferred_width (GtkCellRenderer *cell, * 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. * @@ -1471,8 +1537,8 @@ gtk_cell_renderer_get_preferred_height (GtkCellRenderer *cell, * @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. @@ -1521,8 +1587,8 @@ gtk_cell_renderer_get_preferred_width_for_height (GtkCellRenderer *cell, * @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. @@ -1633,8 +1699,8 @@ gtk_cell_renderer_get_preferred_size (GtkCellRenderer *cell, * @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: the return location for the space inside @cell_area that - * would acually be used to 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. @@ -1658,8 +1724,95 @@ gtk_cell_renderer_get_aligned_area (GtkCellRenderer *cell, 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->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; +} +