forked from AuroraMiddleware/gtk
a28c11a27f
This fixes a GTK+ 3.0 regression. In GTK+ 2, the render method on GtkCellRenderer had a expose_area parameter, typically set to cell_area. This parameter was used for clipping cell content to be rendered to the cell area (and thus clipping to within the focus rectangle). During the rendering clean up this parameter was removed and no clipping put back into place. Since expose_area was usually equal to cell_area anyway, it does not make sense to reintroduce the expose_area parameter. Instead, we do clipping at two levels: - in gtk_cell_renderer_render() we clip to background_area. We cannot clip to cell_area here because we want to allow cell renderers to render in the background area (e.g. background color/effect). - cell renderers should clip to clip_area when rendering cell content individually (as they had to individually clip to expose_region before).
547 lines
15 KiB
C
547 lines
15 KiB
C
/* gtkcellrenderertoggle.c
|
|
* Copyright (C) 2000 Red Hat, Inc., Jonathan Blandford <jrb@redhat.com>
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* 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.
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include <stdlib.h>
|
|
#include "gtkcellrenderertoggle.h"
|
|
#include "gtkintl.h"
|
|
#include "gtkmarshalers.h"
|
|
#include "gtkprivate.h"
|
|
#include "gtktreeprivate.h"
|
|
|
|
|
|
static void gtk_cell_renderer_toggle_get_property (GObject *object,
|
|
guint param_id,
|
|
GValue *value,
|
|
GParamSpec *pspec);
|
|
static void gtk_cell_renderer_toggle_set_property (GObject *object,
|
|
guint param_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec);
|
|
static void gtk_cell_renderer_toggle_get_size (GtkCellRenderer *cell,
|
|
GtkWidget *widget,
|
|
const GdkRectangle *cell_area,
|
|
gint *x_offset,
|
|
gint *y_offset,
|
|
gint *width,
|
|
gint *height);
|
|
static void gtk_cell_renderer_toggle_render (GtkCellRenderer *cell,
|
|
cairo_t *cr,
|
|
GtkWidget *widget,
|
|
const GdkRectangle *background_area,
|
|
const GdkRectangle *cell_area,
|
|
GtkCellRendererState flags);
|
|
static gboolean gtk_cell_renderer_toggle_activate (GtkCellRenderer *cell,
|
|
GdkEvent *event,
|
|
GtkWidget *widget,
|
|
const gchar *path,
|
|
const GdkRectangle *background_area,
|
|
const GdkRectangle *cell_area,
|
|
GtkCellRendererState flags);
|
|
|
|
|
|
enum {
|
|
TOGGLED,
|
|
LAST_SIGNAL
|
|
};
|
|
|
|
enum {
|
|
PROP_0,
|
|
PROP_ACTIVATABLE,
|
|
PROP_ACTIVE,
|
|
PROP_RADIO,
|
|
PROP_INCONSISTENT,
|
|
PROP_INDICATOR_SIZE
|
|
};
|
|
|
|
#define TOGGLE_WIDTH 13
|
|
|
|
static guint toggle_cell_signals[LAST_SIGNAL] = { 0 };
|
|
|
|
struct _GtkCellRendererTogglePrivate
|
|
{
|
|
gint indicator_size;
|
|
|
|
guint active : 1;
|
|
guint activatable : 1;
|
|
guint inconsistent : 1;
|
|
guint radio : 1;
|
|
};
|
|
|
|
|
|
G_DEFINE_TYPE (GtkCellRendererToggle, gtk_cell_renderer_toggle, GTK_TYPE_CELL_RENDERER)
|
|
|
|
|
|
static void
|
|
gtk_cell_renderer_toggle_init (GtkCellRendererToggle *celltoggle)
|
|
{
|
|
GtkCellRendererTogglePrivate *priv;
|
|
|
|
celltoggle->priv = G_TYPE_INSTANCE_GET_PRIVATE (celltoggle,
|
|
GTK_TYPE_CELL_RENDERER_TOGGLE,
|
|
GtkCellRendererTogglePrivate);
|
|
priv = celltoggle->priv;
|
|
|
|
priv->activatable = TRUE;
|
|
priv->active = FALSE;
|
|
priv->radio = FALSE;
|
|
|
|
g_object_set (celltoggle, "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE, NULL);
|
|
gtk_cell_renderer_set_padding (GTK_CELL_RENDERER (celltoggle), 2, 2);
|
|
|
|
priv->indicator_size = TOGGLE_WIDTH;
|
|
priv->inconsistent = FALSE;
|
|
}
|
|
|
|
static void
|
|
gtk_cell_renderer_toggle_class_init (GtkCellRendererToggleClass *class)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (class);
|
|
GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (class);
|
|
|
|
object_class->get_property = gtk_cell_renderer_toggle_get_property;
|
|
object_class->set_property = gtk_cell_renderer_toggle_set_property;
|
|
|
|
cell_class->get_size = gtk_cell_renderer_toggle_get_size;
|
|
cell_class->render = gtk_cell_renderer_toggle_render;
|
|
cell_class->activate = gtk_cell_renderer_toggle_activate;
|
|
|
|
g_object_class_install_property (object_class,
|
|
PROP_ACTIVE,
|
|
g_param_spec_boolean ("active",
|
|
P_("Toggle state"),
|
|
P_("The toggle state of the button"),
|
|
FALSE,
|
|
GTK_PARAM_READWRITE));
|
|
|
|
g_object_class_install_property (object_class,
|
|
PROP_INCONSISTENT,
|
|
g_param_spec_boolean ("inconsistent",
|
|
P_("Inconsistent state"),
|
|
P_("The inconsistent state of the button"),
|
|
FALSE,
|
|
GTK_PARAM_READWRITE));
|
|
|
|
g_object_class_install_property (object_class,
|
|
PROP_ACTIVATABLE,
|
|
g_param_spec_boolean ("activatable",
|
|
P_("Activatable"),
|
|
P_("The toggle button can be activated"),
|
|
TRUE,
|
|
GTK_PARAM_READWRITE));
|
|
|
|
g_object_class_install_property (object_class,
|
|
PROP_RADIO,
|
|
g_param_spec_boolean ("radio",
|
|
P_("Radio state"),
|
|
P_("Draw the toggle button as a radio button"),
|
|
FALSE,
|
|
GTK_PARAM_READWRITE));
|
|
|
|
g_object_class_install_property (object_class,
|
|
PROP_INDICATOR_SIZE,
|
|
g_param_spec_int ("indicator-size",
|
|
P_("Indicator size"),
|
|
P_("Size of check or radio indicator"),
|
|
0,
|
|
G_MAXINT,
|
|
TOGGLE_WIDTH,
|
|
GTK_PARAM_READWRITE));
|
|
|
|
|
|
/**
|
|
* GtkCellRendererToggle::toggled:
|
|
* @cell_renderer: the object which received the signal
|
|
* @path: string representation of #GtkTreePath describing the
|
|
* event location
|
|
*
|
|
* The ::toggled signal is emitted when the cell is toggled.
|
|
**/
|
|
toggle_cell_signals[TOGGLED] =
|
|
g_signal_new (I_("toggled"),
|
|
G_OBJECT_CLASS_TYPE (object_class),
|
|
G_SIGNAL_RUN_LAST,
|
|
G_STRUCT_OFFSET (GtkCellRendererToggleClass, toggled),
|
|
NULL, NULL,
|
|
_gtk_marshal_VOID__STRING,
|
|
G_TYPE_NONE, 1,
|
|
G_TYPE_STRING);
|
|
|
|
g_type_class_add_private (object_class, sizeof (GtkCellRendererTogglePrivate));
|
|
}
|
|
|
|
static void
|
|
gtk_cell_renderer_toggle_get_property (GObject *object,
|
|
guint param_id,
|
|
GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
GtkCellRendererToggle *celltoggle = GTK_CELL_RENDERER_TOGGLE (object);
|
|
GtkCellRendererTogglePrivate *priv = celltoggle->priv;
|
|
|
|
switch (param_id)
|
|
{
|
|
case PROP_ACTIVE:
|
|
g_value_set_boolean (value, priv->active);
|
|
break;
|
|
case PROP_INCONSISTENT:
|
|
g_value_set_boolean (value, priv->inconsistent);
|
|
break;
|
|
case PROP_ACTIVATABLE:
|
|
g_value_set_boolean (value, priv->activatable);
|
|
break;
|
|
case PROP_RADIO:
|
|
g_value_set_boolean (value, priv->radio);
|
|
break;
|
|
case PROP_INDICATOR_SIZE:
|
|
g_value_set_int (value, priv->indicator_size);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
gtk_cell_renderer_toggle_set_property (GObject *object,
|
|
guint param_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
GtkCellRendererToggle *celltoggle = GTK_CELL_RENDERER_TOGGLE (object);
|
|
GtkCellRendererTogglePrivate *priv = celltoggle->priv;
|
|
|
|
switch (param_id)
|
|
{
|
|
case PROP_ACTIVE:
|
|
priv->active = g_value_get_boolean (value);
|
|
break;
|
|
case PROP_INCONSISTENT:
|
|
priv->inconsistent = g_value_get_boolean (value);
|
|
break;
|
|
case PROP_ACTIVATABLE:
|
|
priv->activatable = g_value_get_boolean (value);
|
|
break;
|
|
case PROP_RADIO:
|
|
priv->radio = g_value_get_boolean (value);
|
|
break;
|
|
case PROP_INDICATOR_SIZE:
|
|
priv->indicator_size = g_value_get_int (value);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gtk_cell_renderer_toggle_new:
|
|
*
|
|
* Creates a new #GtkCellRendererToggle. Adjust rendering
|
|
* parameters using object properties. Object properties can be set
|
|
* globally (with g_object_set()). Also, with #GtkTreeViewColumn, you
|
|
* can bind a property to a value in a #GtkTreeModel. For example, you
|
|
* can bind the "active" property on the cell renderer to a boolean value
|
|
* in the model, thus causing the check button to reflect the state of
|
|
* the model.
|
|
*
|
|
* Return value: the new cell renderer
|
|
**/
|
|
GtkCellRenderer *
|
|
gtk_cell_renderer_toggle_new (void)
|
|
{
|
|
return g_object_new (GTK_TYPE_CELL_RENDERER_TOGGLE, NULL);
|
|
}
|
|
|
|
static void
|
|
gtk_cell_renderer_toggle_get_size (GtkCellRenderer *cell,
|
|
GtkWidget *widget,
|
|
const GdkRectangle *cell_area,
|
|
gint *x_offset,
|
|
gint *y_offset,
|
|
gint *width,
|
|
gint *height)
|
|
{
|
|
GtkCellRendererTogglePrivate *priv;
|
|
gint calc_width;
|
|
gint calc_height;
|
|
gint xpad, ypad;
|
|
|
|
priv = GTK_CELL_RENDERER_TOGGLE (cell)->priv;
|
|
|
|
gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
|
|
calc_width = xpad * 2 + priv->indicator_size;
|
|
calc_height = ypad * 2 + priv->indicator_size;
|
|
|
|
if (width)
|
|
*width = calc_width;
|
|
|
|
if (height)
|
|
*height = calc_height;
|
|
|
|
if (cell_area)
|
|
{
|
|
gfloat xalign, yalign;
|
|
|
|
gtk_cell_renderer_get_alignment (cell, &xalign, &yalign);
|
|
|
|
if (x_offset)
|
|
{
|
|
*x_offset = ((gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) ?
|
|
(1.0 - xalign) : xalign) * (cell_area->width - calc_width);
|
|
*x_offset = MAX (*x_offset, 0);
|
|
}
|
|
if (y_offset)
|
|
{
|
|
*y_offset = yalign * (cell_area->height - calc_height);
|
|
*y_offset = MAX (*y_offset, 0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (x_offset) *x_offset = 0;
|
|
if (y_offset) *y_offset = 0;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_cell_renderer_toggle_render (GtkCellRenderer *cell,
|
|
cairo_t *cr,
|
|
GtkWidget *widget,
|
|
const GdkRectangle *background_area,
|
|
const GdkRectangle *cell_area,
|
|
GtkCellRendererState flags)
|
|
{
|
|
GtkCellRendererToggle *celltoggle = GTK_CELL_RENDERER_TOGGLE (cell);
|
|
GtkCellRendererTogglePrivate *priv = celltoggle->priv;
|
|
gint width, height;
|
|
gint x_offset, y_offset;
|
|
gint xpad, ypad;
|
|
GtkShadowType shadow;
|
|
GtkStateType state = 0;
|
|
|
|
gtk_cell_renderer_toggle_get_size (cell, widget, cell_area,
|
|
&x_offset, &y_offset,
|
|
&width, &height);
|
|
gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
|
|
width -= xpad * 2;
|
|
height -= ypad * 2;
|
|
|
|
if (width <= 0 || height <= 0)
|
|
return;
|
|
|
|
if (priv->inconsistent)
|
|
shadow = GTK_SHADOW_ETCHED_IN;
|
|
else
|
|
shadow = priv->active ? GTK_SHADOW_IN : GTK_SHADOW_OUT;
|
|
|
|
if (gtk_widget_get_state (widget) == GTK_STATE_INSENSITIVE ||
|
|
!gtk_cell_renderer_get_sensitive (cell))
|
|
{
|
|
state = GTK_STATE_INSENSITIVE;
|
|
}
|
|
else if ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED)
|
|
{
|
|
if (gtk_widget_has_focus (widget))
|
|
state = GTK_STATE_SELECTED;
|
|
else
|
|
state = GTK_STATE_ACTIVE;
|
|
}
|
|
else
|
|
{
|
|
if (priv->activatable)
|
|
state = GTK_STATE_NORMAL;
|
|
else
|
|
state = GTK_STATE_INSENSITIVE;
|
|
}
|
|
|
|
cairo_save (cr);
|
|
|
|
gdk_cairo_rectangle (cr, cell_area);
|
|
cairo_clip (cr);
|
|
|
|
if (priv->radio)
|
|
{
|
|
gtk_paint_option (gtk_widget_get_style (widget),
|
|
cr,
|
|
state, shadow,
|
|
widget, "cellradio",
|
|
cell_area->x + x_offset + xpad,
|
|
cell_area->y + y_offset + ypad,
|
|
width, height);
|
|
}
|
|
else
|
|
{
|
|
gtk_paint_check (gtk_widget_get_style (widget),
|
|
cr,
|
|
state, shadow,
|
|
widget, "cellcheck",
|
|
cell_area->x + x_offset + xpad,
|
|
cell_area->y + y_offset + ypad,
|
|
width, height);
|
|
}
|
|
|
|
cairo_restore (cr);
|
|
}
|
|
|
|
static gint
|
|
gtk_cell_renderer_toggle_activate (GtkCellRenderer *cell,
|
|
GdkEvent *event,
|
|
GtkWidget *widget,
|
|
const gchar *path,
|
|
const GdkRectangle *background_area,
|
|
const GdkRectangle *cell_area,
|
|
GtkCellRendererState flags)
|
|
{
|
|
GtkCellRendererTogglePrivate *priv;
|
|
GtkCellRendererToggle *celltoggle;
|
|
|
|
celltoggle = GTK_CELL_RENDERER_TOGGLE (cell);
|
|
priv = celltoggle->priv;
|
|
|
|
if (priv->activatable)
|
|
{
|
|
g_signal_emit (cell, toggle_cell_signals[TOGGLED], 0, path);
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* gtk_cell_renderer_toggle_set_radio:
|
|
* @toggle: a #GtkCellRendererToggle
|
|
* @radio: %TRUE to make the toggle look like a radio button
|
|
*
|
|
* If @radio is %TRUE, the cell renderer renders a radio toggle
|
|
* (i.e. a toggle in a group of mutually-exclusive toggles).
|
|
* If %FALSE, it renders a check toggle (a standalone boolean option).
|
|
* This can be set globally for the cell renderer, or changed just
|
|
* before rendering each cell in the model (for #GtkTreeView, you set
|
|
* up a per-row setting using #GtkTreeViewColumn to associate model
|
|
* columns with cell renderer properties).
|
|
**/
|
|
void
|
|
gtk_cell_renderer_toggle_set_radio (GtkCellRendererToggle *toggle,
|
|
gboolean radio)
|
|
{
|
|
GtkCellRendererTogglePrivate *priv;
|
|
|
|
g_return_if_fail (GTK_IS_CELL_RENDERER_TOGGLE (toggle));
|
|
|
|
priv = toggle->priv;
|
|
|
|
priv->radio = radio;
|
|
}
|
|
|
|
/**
|
|
* gtk_cell_renderer_toggle_get_radio:
|
|
* @toggle: a #GtkCellRendererToggle
|
|
*
|
|
* Returns whether we're rendering radio toggles rather than checkboxes.
|
|
*
|
|
* Return value: %TRUE if we're rendering radio toggles rather than checkboxes
|
|
**/
|
|
gboolean
|
|
gtk_cell_renderer_toggle_get_radio (GtkCellRendererToggle *toggle)
|
|
{
|
|
g_return_val_if_fail (GTK_IS_CELL_RENDERER_TOGGLE (toggle), FALSE);
|
|
|
|
return toggle->priv->radio;
|
|
}
|
|
|
|
/**
|
|
* gtk_cell_renderer_toggle_get_active:
|
|
* @toggle: a #GtkCellRendererToggle
|
|
*
|
|
* Returns whether the cell renderer is active. See
|
|
* gtk_cell_renderer_toggle_set_active().
|
|
*
|
|
* Return value: %TRUE if the cell renderer is active.
|
|
**/
|
|
gboolean
|
|
gtk_cell_renderer_toggle_get_active (GtkCellRendererToggle *toggle)
|
|
{
|
|
g_return_val_if_fail (GTK_IS_CELL_RENDERER_TOGGLE (toggle), FALSE);
|
|
|
|
return toggle->priv->active;
|
|
}
|
|
|
|
/**
|
|
* gtk_cell_renderer_toggle_set_active:
|
|
* @toggle: a #GtkCellRendererToggle.
|
|
* @setting: the value to set.
|
|
*
|
|
* Activates or deactivates a cell renderer.
|
|
**/
|
|
void
|
|
gtk_cell_renderer_toggle_set_active (GtkCellRendererToggle *toggle,
|
|
gboolean setting)
|
|
{
|
|
g_return_if_fail (GTK_IS_CELL_RENDERER_TOGGLE (toggle));
|
|
|
|
g_object_set (toggle, "active", setting ? TRUE : FALSE, NULL);
|
|
}
|
|
|
|
/**
|
|
* gtk_cell_renderer_toggle_get_activatable:
|
|
* @toggle: a #GtkCellRendererToggle
|
|
*
|
|
* Returns whether the cell renderer is activatable. See
|
|
* gtk_cell_renderer_toggle_set_activatable().
|
|
*
|
|
* Return value: %TRUE if the cell renderer is activatable.
|
|
*
|
|
* Since: 2.18
|
|
**/
|
|
gboolean
|
|
gtk_cell_renderer_toggle_get_activatable (GtkCellRendererToggle *toggle)
|
|
{
|
|
g_return_val_if_fail (GTK_IS_CELL_RENDERER_TOGGLE (toggle), FALSE);
|
|
|
|
return toggle->priv->activatable;
|
|
}
|
|
|
|
/**
|
|
* gtk_cell_renderer_toggle_set_activatable:
|
|
* @toggle: a #GtkCellRendererToggle.
|
|
* @setting: the value to set.
|
|
*
|
|
* Makes the cell renderer activatable.
|
|
*
|
|
* Since: 2.18
|
|
**/
|
|
void
|
|
gtk_cell_renderer_toggle_set_activatable (GtkCellRendererToggle *toggle,
|
|
gboolean setting)
|
|
{
|
|
GtkCellRendererTogglePrivate *priv;
|
|
|
|
g_return_if_fail (GTK_IS_CELL_RENDERER_TOGGLE (toggle));
|
|
|
|
priv = toggle->priv;
|
|
|
|
if (priv->activatable != setting)
|
|
{
|
|
priv->activatable = setting ? TRUE : FALSE;
|
|
g_object_notify (G_OBJECT (toggle), "activatable");
|
|
}
|
|
}
|