Pileus Git - ~andy/gtk/blob - gtk/gtkcellrenderertoggle.c

   1 /* gtkcellrenderertoggle.c
   2  * Copyright (C) 2000  Red Hat, Inc.,  Jonathan Blandford <jrb@redhat.com>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include <stdlib.h>
  21 #include "gtkcellrenderertoggle.h"
  22 #include "gtkintl.h"
  23 #include "gtkmarshalers.h"
  24 #include "gtktreeprivate.h"
  25
  26 static void gtk_cell_renderer_toggle_get_property  (GObject                    *object,
  27                                                     guint                       param_id,
  28                                                     GValue                     *value,
  29                                                     GParamSpec                 *pspec);
  30 static void gtk_cell_renderer_toggle_set_property  (GObject                    *object,
  31                                                     guint                       param_id,
  32                                                     const GValue               *value,
  33                                                     GParamSpec                 *pspec);
  34 static void gtk_cell_renderer_toggle_init       (GtkCellRendererToggle      *celltext);
  35 static void gtk_cell_renderer_toggle_class_init (GtkCellRendererToggleClass *class);
  36 static void gtk_cell_renderer_toggle_get_size   (GtkCellRenderer            *cell,
  37                                                  GtkWidget                  *widget,
  38                                                  GdkRectangle               *cell_area,
  39                                                  gint                       *x_offset,
  40                                                  gint                       *y_offset,
  41                                                  gint                       *width,
  42                                                  gint                       *height);
  43 static void gtk_cell_renderer_toggle_render     (GtkCellRenderer            *cell,
  44                                                  GdkWindow                  *window,
  45                                                  GtkWidget                  *widget,
  46                                                  GdkRectangle               *background_area,
  47                                                  GdkRectangle               *cell_area,
  48                                                  GdkRectangle               *expose_area,
  49                                                  GtkCellRendererState        flags);
  50 static gboolean gtk_cell_renderer_toggle_activate  (GtkCellRenderer            *cell,
  51                                                     GdkEvent                   *event,
  52                                                     GtkWidget                  *widget,
  53                                                     const gchar                *path,
  54                                                     GdkRectangle               *background_area,
  55                                                     GdkRectangle               *cell_area,
  56                                                     GtkCellRendererState        flags);
  57
  58
  59 enum {
  60   TOGGLED,
  61   LAST_SIGNAL
  62 };
  63
  64 enum {
  65   PROP_ZERO,
  66   PROP_ACTIVATABLE,
  67   PROP_ACTIVE,
  68   PROP_RADIO,
  69   PROP_INCONSISTENT
  70 };
  71
  72 #define TOGGLE_WIDTH 12
  73
  74 static guint toggle_cell_signals[LAST_SIGNAL] = { 0 };
  75
  76 #define GTK_CELL_RENDERER_TOGGLE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_CELL_RENDERER_TOGGLE, GtkCellRendererTogglePrivate))
  77
  78 typedef struct _GtkCellRendererTogglePrivate GtkCellRendererTogglePrivate;
  79 struct _GtkCellRendererTogglePrivate
  80 {
  81   guint inconsistent : 1;
  82 };
  83
  84
  85 GType
  86 gtk_cell_renderer_toggle_get_type (void)
  87 {
  88   static GType cell_toggle_type = 0;
  89
  90   if (!cell_toggle_type)
  91     {
  92       static const GTypeInfo cell_toggle_info =
  93       {
  94         sizeof (GtkCellRendererToggleClass),
  95         NULL,           /* base_init */
  96         NULL,           /* base_finalize */
  97         (GClassInitFunc) gtk_cell_renderer_toggle_class_init,
  98         NULL,           /* class_finalize */
  99         NULL,           /* class_data */
 100         sizeof (GtkCellRendererToggle),
 101         0,              /* n_preallocs */
 102         (GInstanceInitFunc) gtk_cell_renderer_toggle_init,
 103       };
 104
 105       cell_toggle_type =
 106         g_type_register_static (GTK_TYPE_CELL_RENDERER, "GtkCellRendererToggle",
 107                                 &cell_toggle_info, 0);
 108     }
 109
 110   return cell_toggle_type;
 111 }
 112
 113 static void
 114 gtk_cell_renderer_toggle_init (GtkCellRendererToggle *celltoggle)
 115 {
 116   celltoggle->activatable = TRUE;
 117   celltoggle->active = FALSE;
 118   celltoggle->radio = FALSE;
 119   GTK_CELL_RENDERER (celltoggle)->mode = GTK_CELL_RENDERER_MODE_ACTIVATABLE;
 120   GTK_CELL_RENDERER (celltoggle)->xpad = 2;
 121   GTK_CELL_RENDERER (celltoggle)->ypad = 2;
 122 }
 123
 124 static void
 125 gtk_cell_renderer_toggle_class_init (GtkCellRendererToggleClass *class)
 126 {
 127   GObjectClass *object_class = G_OBJECT_CLASS (class);
 128   GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (class);
 129
 130   object_class->get_property = gtk_cell_renderer_toggle_get_property;
 131   object_class->set_property = gtk_cell_renderer_toggle_set_property;
 132
 133   cell_class->get_size = gtk_cell_renderer_toggle_get_size;
 134   cell_class->render = gtk_cell_renderer_toggle_render;
 135   cell_class->activate = gtk_cell_renderer_toggle_activate;
 136
 137   g_object_class_install_property (object_class,
 138                                    PROP_ACTIVE,
 139                                    g_param_spec_boolean ("active",
 140                                                          P_("Toggle state"),
 141                                                          P_("The toggle state of the button"),
 142                                                          FALSE,
 143                                                          G_PARAM_READABLE |
 144                                                          G_PARAM_WRITABLE));
 145
 146   g_object_class_install_property (object_class,
 147                                    PROP_INCONSISTENT,
 148                                    g_param_spec_boolean ("inconsistent",
 149                                                          P_("Inconsistent state"),
 150                                                          P_("The inconsistent state of the button"),
 151                                                          FALSE,
 152                                                          G_PARAM_READABLE |
 153                                                          G_PARAM_WRITABLE));
 154
 155   g_object_class_install_property (object_class,
 156                                    PROP_ACTIVATABLE,
 157                                    g_param_spec_boolean ("activatable",
 158                                                          P_("Activatable"),
 159                                                          P_("The toggle button can be activated"),
 160                                                          TRUE,
 161                                                          G_PARAM_READABLE |
 162                                                          G_PARAM_WRITABLE));
 163
 164   g_object_class_install_property (object_class,
 165                                    PROP_RADIO,
 166                                    g_param_spec_boolean ("radio",
 167                                                          P_("Radio state"),
 168                                                          P_("Draw the toggle button as a radio button"),
 169                                                          FALSE,
 170                                                          G_PARAM_READABLE |
 171                                                          G_PARAM_WRITABLE));
 172
 173
 174   toggle_cell_signals[TOGGLED] =
 175     g_signal_new ("toggled",
 176                   G_OBJECT_CLASS_TYPE (object_class),
 177                   G_SIGNAL_RUN_LAST,
 178                   G_STRUCT_OFFSET (GtkCellRendererToggleClass, toggled),
 179                   NULL, NULL,
 180                   _gtk_marshal_VOID__STRING,
 181                   G_TYPE_NONE, 1,
 182                   G_TYPE_STRING);
 183
 184   g_type_class_add_private (object_class, sizeof (GtkCellRendererTogglePrivate));
 185 }
 186
 187 static void
 188 gtk_cell_renderer_toggle_get_property (GObject     *object,
 189                                        guint        param_id,
 190                                        GValue      *value,
 191                                        GParamSpec  *pspec)
 192 {
 193   GtkCellRendererToggle *celltoggle = GTK_CELL_RENDERER_TOGGLE (object);
 194   GtkCellRendererTogglePrivate *priv;
 195
 196   priv = GTK_CELL_RENDERER_TOGGLE_GET_PRIVATE (object);
 197
 198   switch (param_id)
 199     {
 200     case PROP_ACTIVE:
 201       g_value_set_boolean (value, celltoggle->active);
 202       break;
 203     case PROP_INCONSISTENT:
 204       g_value_set_boolean (value, priv->inconsistent);
 205       break;
 206     case PROP_ACTIVATABLE:
 207       g_value_set_boolean (value, celltoggle->activatable);
 208       break;
 209     case PROP_RADIO:
 210       g_value_set_boolean (value, celltoggle->radio);
 211       break;
 212     default:
 213       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 214       break;
 215     }
 216 }
 217
 218
 219 static void
 220 gtk_cell_renderer_toggle_set_property (GObject      *object,
 221                                        guint         param_id,
 222                                        const GValue *value,
 223                                        GParamSpec   *pspec)
 224 {
 225   GtkCellRendererToggle *celltoggle = GTK_CELL_RENDERER_TOGGLE (object);
 226   GtkCellRendererTogglePrivate *priv;
 227
 228   priv = GTK_CELL_RENDERER_TOGGLE_GET_PRIVATE (object);
 229
 230   switch (param_id)
 231     {
 232     case PROP_ACTIVE:
 233       celltoggle->active = g_value_get_boolean (value);
 234       g_object_notify (G_OBJECT(object), "active");
 235       break;
 236     case PROP_INCONSISTENT:
 237       priv->inconsistent = g_value_get_boolean (value);
 238       g_object_notify (G_OBJECT (object), "inconsistent");
 239       break;
 240     case PROP_ACTIVATABLE:
 241       celltoggle->activatable = g_value_get_boolean (value);
 242       g_object_notify (G_OBJECT(object), "activatable");
 243       break;
 244     case PROP_RADIO:
 245       celltoggle->radio = g_value_get_boolean (value);
 246       g_object_notify (G_OBJECT(object), "radio");
 247       break;
 248     default:
 249       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 250       break;
 251     }
 252 }
 253
 254 /**
 255  * gtk_cell_renderer_toggle_new:
 256  *
 257  * Creates a new #GtkCellRendererToggle. Adjust rendering
 258  * parameters using object properties. Object properties can be set
 259  * globally (with g_object_set()). Also, with #GtkTreeViewColumn, you
 260  * can bind a property to a value in a #GtkTreeModel. For example, you
 261  * can bind the "active" property on the cell renderer to a boolean value
 262  * in the model, thus causing the check button to reflect the state of
 263  * the model.
 264  *
 265  * Return value: the new cell renderer
 266  **/
 267 GtkCellRenderer *
 268 gtk_cell_renderer_toggle_new (void)
 269 {
 270   return g_object_new (GTK_TYPE_CELL_RENDERER_TOGGLE, NULL);
 271 }
 272
 273 static void
 274 gtk_cell_renderer_toggle_get_size (GtkCellRenderer *cell,
 275                                    GtkWidget       *widget,
 276                                    GdkRectangle    *cell_area,
 277                                    gint            *x_offset,
 278                                    gint            *y_offset,
 279                                    gint            *width,
 280                                    gint            *height)
 281 {
 282   gint calc_width;
 283   gint calc_height;
 284
 285   calc_width = (gint) cell->xpad * 2 + TOGGLE_WIDTH;
 286   calc_height = (gint) cell->ypad * 2 + TOGGLE_WIDTH;
 287
 288   if (width)
 289     *width = calc_width;
 290
 291   if (height)
 292     *height = calc_height;
 293
 294   if (cell_area)
 295     {
 296       if (x_offset)
 297         {
 298           *x_offset = ((gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) ?
 299                        (1.0 - cell->xalign) : cell->xalign) * (cell_area->width - calc_width);
 300           *x_offset = MAX (*x_offset, 0);
 301         }
 302       if (y_offset)
 303         {
 304           *y_offset = cell->yalign * (cell_area->height - calc_height);
 305           *y_offset = MAX (*y_offset, 0);
 306         }
 307     }
 308 }
 309
 310 static void
 311 gtk_cell_renderer_toggle_render (GtkCellRenderer      *cell,
 312                                  GdkDrawable          *window,
 313                                  GtkWidget            *widget,
 314                                  GdkRectangle         *background_area,
 315                                  GdkRectangle         *cell_area,
 316                                  GdkRectangle         *expose_area,
 317                                  GtkCellRendererState  flags)
 318 {
 319   GtkCellRendererToggle *celltoggle = (GtkCellRendererToggle *) cell;
 320   GtkCellRendererTogglePrivate *priv;
 321   gint width, height;
 322   gint x_offset, y_offset;
 323   GtkShadowType shadow;
 324   GtkStateType state = 0;
 325
 326   priv = GTK_CELL_RENDERER_TOGGLE_GET_PRIVATE (cell);
 327
 328   gtk_cell_renderer_toggle_get_size (cell, widget, cell_area,
 329                                      &x_offset, &y_offset,
 330                                      &width, &height);
 331   width -= cell->xpad*2;
 332   height -= cell->ypad*2;
 333
 334   if (width <= 0 || height <= 0)
 335     return;
 336
 337   if (priv->inconsistent)
 338     shadow = GTK_SHADOW_ETCHED_IN;
 339   else
 340     shadow = celltoggle->active ? GTK_SHADOW_IN : GTK_SHADOW_OUT;
 341
 342   if ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED)
 343     {
 344       if (GTK_WIDGET_HAS_FOCUS (widget))
 345         state = GTK_STATE_SELECTED;
 346       else
 347         state = GTK_STATE_ACTIVE;
 348     }
 349   else
 350     {
 351       if (celltoggle->activatable)
 352         state = GTK_STATE_NORMAL;
 353       else
 354         state = GTK_STATE_INSENSITIVE;
 355     }
 356
 357   if (celltoggle->radio)
 358     {
 359       gtk_paint_option (widget->style,
 360                         window,
 361                         state, shadow,
 362                         expose_area, widget, "cellradio",
 363                         cell_area->x + x_offset + cell->xpad,
 364                         cell_area->y + y_offset + cell->ypad,
 365                         width - 1, height - 1);
 366     }
 367   else
 368     {
 369       gtk_paint_check (widget->style,
 370                        window,
 371                        state, shadow,
 372                        expose_area, widget, "cellcheck",
 373                        cell_area->x + x_offset + cell->xpad,
 374                        cell_area->y + y_offset + cell->ypad,
 375                        width - 1, height - 1);
 376     }
 377 }
 378
 379 static gint
 380 gtk_cell_renderer_toggle_activate (GtkCellRenderer      *cell,
 381                                    GdkEvent             *event,
 382                                    GtkWidget            *widget,
 383                                    const gchar          *path,
 384                                    GdkRectangle         *background_area,
 385                                    GdkRectangle         *cell_area,
 386                                    GtkCellRendererState  flags)
 387 {
 388   GtkCellRendererToggle *celltoggle;
 389
 390   celltoggle = GTK_CELL_RENDERER_TOGGLE (cell);
 391   if (celltoggle->activatable)
 392     {
 393       g_signal_emit (cell, toggle_cell_signals[TOGGLED], 0, path);
 394       return TRUE;
 395     }
 396
 397   return FALSE;
 398 }
 399
 400 /**
 401  * gtk_cell_renderer_toggle_set_radio:
 402  * @toggle: a #GtkCellRendererToggle
 403  * @radio: %TRUE to make the toggle look like a radio button
 404  *
 405  * If @radio is %TRUE, the cell renderer renders a radio toggle
 406  * (i.e. a toggle in a group of mutually-exclusive toggles).
 407  * If %FALSE, it renders a check toggle (a standalone boolean option).
 408  * This can be set globally for the cell renderer, or changed just
 409  * before rendering each cell in the model (for #GtkTreeView, you set
 410  * up a per-row setting using #GtkTreeViewColumn to associate model
 411  * columns with cell renderer properties).
 412  **/
 413 void
 414 gtk_cell_renderer_toggle_set_radio (GtkCellRendererToggle *toggle,
 415                                     gboolean               radio)
 416 {
 417   g_return_if_fail (GTK_IS_CELL_RENDERER_TOGGLE (toggle));
 418
 419   toggle->radio = radio;
 420 }
 421
 422 /**
 423  * gtk_cell_renderer_toggle_get_radio:
 424  * @toggle: a #GtkCellRendererToggle
 425  *
 426  * Returns wether we're rendering radio toggles rather than checkboxes.
 427  *
 428  * Return value: %TRUE if we're rendering radio toggles rather than checkboxes
 429  **/
 430 gboolean
 431 gtk_cell_renderer_toggle_get_radio (GtkCellRendererToggle *toggle)
 432 {
 433   g_return_val_if_fail (GTK_IS_CELL_RENDERER_TOGGLE (toggle), FALSE);
 434
 435   return toggle->radio;
 436 }
 437
 438 /**
 439  * gtk_cell_renderer_toggle_get_active:
 440  * @toggle: a #GtkCellRendererToggle
 441  *
 442  * Returns whether the cell renderer is active. See
 443  * gtk_cell_renderer_toggle_set_active().
 444  *
 445  * Return value: %TRUE if the cell renderer is active.
 446  **/
 447 gboolean
 448 gtk_cell_renderer_toggle_get_active (GtkCellRendererToggle *toggle)
 449 {
 450   g_return_val_if_fail (GTK_IS_CELL_RENDERER_TOGGLE (toggle), FALSE);
 451
 452   return toggle->active;
 453 }
 454
 455 /**
 456  * gtk_cell_renderer_toggle_set_active:
 457  * @toggle: a #GtkCellRendererToggle.
 458  * @setting: the value to set.
 459  *
 460  * Activates or deactivates a cell renderer.
 461  **/
 462 void
 463 gtk_cell_renderer_toggle_set_active (GtkCellRendererToggle *toggle,
 464                                      gboolean               setting)
 465 {
 466   g_return_if_fail (GTK_IS_CELL_RENDERER_TOGGLE (toggle));
 467
 468   g_object_set (toggle, "active", setting ? TRUE : FALSE, NULL);
 469 }