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