* 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 "gtktypebuiltins.h"
#include "gtkprivate.h"
#include "gtktreeprivate.h"
+#include "a11y/gtkrenderercellaccessible.h"
/**
* 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, 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.
* 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,
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;
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
(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,
}
}
+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,
/* 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,
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);
}
/**
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;
+}
+
projects / ~andy / gtk / blobdiff