X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkcellrenderer.c;h=9f4b4e203f9ef49bb833a479c069991284b5acdd;hb=ea043cab5718304d9b6170afa2d3f959fc99c718;hp=75270b960e767ad0a5904595401c20da2a0c01c2;hpb=3d57787d6e1ac9f8d9bbb98e61868355ec9f09a5;p=~andy%2Fgtk diff --git a/gtk/gtkcellrenderer.c b/gtk/gtkcellrenderer.c index 75270b960..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 @@ -814,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, @@ -1212,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, @@ -1257,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, @@ -1368,16 +1431,9 @@ _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); } /** @@ -1680,9 +1736,9 @@ gtk_cell_renderer_get_aligned_area (GtkCellRenderer *cell, * @widget: a #GtkWidget, or %NULL * @cell_state: cell renderer state * - * Translates the cell renderer state to a #GtkStateFlags, + * Translates the cell renderer state to #GtkStateFlags, * based on the cell renderer and widget sensitivity, and - * the given #GtkCellRendererState + * the given #GtkCellRendererState. * * Returns: the widget state flags applying to @cell * @@ -1698,23 +1754,65 @@ gtk_cell_renderer_get_state (GtkCellRenderer *cell, 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 && !gtk_widget_get_sensitive (widget)) || - (cell && !gtk_cell_renderer_get_sensitive (cell))) - state |= GTK_STATE_FLAG_INSENSITIVE; + 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 ((cell_state & GTK_CELL_RENDERER_SELECTED) != 0) - { - state |= GTK_STATE_FLAG_SELECTED; - - if ((widget && gtk_widget_has_focus (widget)) && - (cell_state & GTK_CELL_RENDERER_FOCUSED) != 0) - state |= GTK_STATE_FLAG_FOCUSED; - } + 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; +} +