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 <gtk/gtkcellrenderertoggle.h>
  22 #include <gtk/gtksignal.h>
  23 #include "gtkintl.h"
  24
  25 static void gtk_cell_renderer_toggle_get_property  (GObject                    *object,
  26                                                     guint                       param_id,
  27                                                     GValue                     *value,
  28                                                     GParamSpec                 *pspec,
  29                                                     const gchar                *trailer);
  30 static void gtk_cell_renderer_toggle_set_property  (GObject                    *object,
  31                                                     guint                       param_id,
  32                                                     const GValue               *value,
  33                                                     GParamSpec                 *pspec,
  34                                                     const gchar                *trailer);
  35 static void gtk_cell_renderer_toggle_init       (GtkCellRendererToggle      *celltext);
  36 static void gtk_cell_renderer_toggle_class_init (GtkCellRendererToggleClass *class);
  37 static void gtk_cell_renderer_toggle_get_size   (GtkCellRenderer            *cell,
  38                                                  GtkWidget                  *widget,
  39                                                  gint                       *width,
  40                                                  gint                       *height);
  41 static void gtk_cell_renderer_toggle_render     (GtkCellRenderer            *cell,
  42                                                  GdkWindow                  *window,
  43                                                  GtkWidget                  *widget,
  44                                                  GdkRectangle               *background_area,
  45                                                  GdkRectangle               *cell_area,
  46                                                  GdkRectangle               *expose_area,
  47                                                  guint                       flags);
  48 static gint gtk_cell_renderer_toggle_event      (GtkCellRenderer            *cell,
  49                                                  GdkEvent                   *event,
  50                                                  GtkWidget                  *widget,
  51                                                  gchar                      *path,
  52                                                  GdkRectangle               *background_area,
  53                                                  GdkRectangle               *cell_area,
  54                                                  guint                       flags);
  55
  56
  57 enum {
  58   TOGGLED,
  59   LAST_SIGNAL
  60 };
  61
  62 enum {
  63   PROP_ZERO,
  64   PROP_ACTIVE,
  65   PROP_RADIO
  66 };
  67
  68
  69 #define TOGGLE_WIDTH 12
  70
  71 static guint toggle_cell_signals[LAST_SIGNAL] = { 0 };
  72
  73
  74 GtkType
  75 gtk_cell_renderer_toggle_get_type (void)
  76 {
  77   static GtkType cell_toggle_type = 0;
  78
  79   if (!cell_toggle_type)
  80     {
  81       static const GTypeInfo cell_toggle_info =
  82       {
  83         sizeof (GtkCellRendererToggleClass),
  84         NULL,           /* base_init */
  85         NULL,           /* base_finalize */
  86         (GClassInitFunc) gtk_cell_renderer_toggle_class_init,
  87         NULL,           /* class_finalize */
  88         NULL,           /* class_data */
  89         sizeof (GtkCellRendererToggle),
  90         0,              /* n_preallocs */
  91         (GInstanceInitFunc) gtk_cell_renderer_toggle_init,
  92       };
  93
  94       cell_toggle_type = g_type_register_static (GTK_TYPE_CELL_RENDERER, "GtkCellRendererToggle", &cell_toggle_info, 0);
  95     }
  96
  97   return cell_toggle_type;
  98 }
  99
 100 static void
 101 gtk_cell_renderer_toggle_init (GtkCellRendererToggle *celltoggle)
 102 {
 103   celltoggle->active = FALSE;
 104   celltoggle->radio = FALSE;
 105   GTK_CELL_RENDERER (celltoggle)->xpad = 2;
 106   GTK_CELL_RENDERER (celltoggle)->ypad = 2;
 107 }
 108
 109 static void
 110 gtk_cell_renderer_toggle_class_init (GtkCellRendererToggleClass *class)
 111 {
 112   GObjectClass *object_class = G_OBJECT_CLASS (class);
 113   GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (class);
 114
 115   object_class->get_property = gtk_cell_renderer_toggle_get_property;
 116   object_class->set_property = gtk_cell_renderer_toggle_set_property;
 117
 118   cell_class->get_size = gtk_cell_renderer_toggle_get_size;
 119   cell_class->render = gtk_cell_renderer_toggle_render;
 120   cell_class->event = gtk_cell_renderer_toggle_event;
 121
 122   g_object_class_install_property (object_class,
 123                                    PROP_ACTIVE,
 124                                    g_param_spec_boolean ("active",
 125                                                          _("Toggle state"),
 126                                                          _("The toggle state of the button"),
 127                                                          FALSE,
 128                                                          G_PARAM_READABLE |
 129                                                          G_PARAM_WRITABLE));
 130
 131   g_object_class_install_property (object_class,
 132                                    PROP_RADIO,
 133                                    g_param_spec_boolean ("radio",
 134                                                          _("Radio state"),
 135                                                          _("Draw the toggle button as a radio button"),
 136                                                          FALSE,
 137                                                          G_PARAM_READABLE |
 138                                                          G_PARAM_WRITABLE));
 139
 140
 141   toggle_cell_signals[TOGGLED] =
 142     gtk_signal_new ("toggled",
 143                     GTK_RUN_LAST,
 144                     GTK_CLASS_TYPE (object_class),
 145                     GTK_SIGNAL_OFFSET (GtkCellRendererToggleClass, toggled),
 146                     gtk_marshal_VOID__POINTER,
 147                     GTK_TYPE_NONE, 1,
 148                     GTK_TYPE_POINTER);
 149 }
 150
 151 static void
 152 gtk_cell_renderer_toggle_get_property (GObject     *object,
 153                                        guint        param_id,
 154                                        GValue      *value,
 155                                        GParamSpec  *pspec,
 156                                        const gchar *trailer)
 157 {
 158   GtkCellRendererToggle *celltoggle = GTK_CELL_RENDERER_TOGGLE (object);
 159
 160   switch (param_id)
 161     {
 162     case PROP_ACTIVE:
 163       g_value_set_boolean (value, celltoggle->active);
 164       break;
 165     case PROP_RADIO:
 166       g_value_set_boolean (value, celltoggle->radio);
 167       break;
 168     default:
 169       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 170       break;
 171     }
 172 }
 173
 174
 175 static void
 176 gtk_cell_renderer_toggle_set_property (GObject      *object,
 177                                        guint         param_id,
 178                                        const GValue *value,
 179                                        GParamSpec   *pspec,
 180                                        const gchar  *trailer)
 181 {
 182   GtkCellRendererToggle *celltoggle = GTK_CELL_RENDERER_TOGGLE (object);
 183
 184   switch (param_id)
 185     {
 186     case PROP_ACTIVE:
 187       celltoggle->active = g_value_get_boolean (value);
 188       break;
 189     case PROP_RADIO:
 190       celltoggle->radio = g_value_get_boolean (value);
 191       break;
 192     default:
 193       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 194       break;
 195     }
 196 }
 197
 198 /**
 199  * gtk_cell_renderer_toggle_new:
 200  *
 201  * Creates a new #GtkCellRendererToggle. Adjust rendering
 202  * parameters using object properties. Object properties can be set
 203  * globally (with g_object_set()). Also, with #GtkTreeViewColumn, you
 204  * can bind a property to a value in a #GtkTreeModel. For example, you
 205  * can bind the "active" property on the cell renderer to a boolean value
 206  * in the model, thus causing the check button to reflect the state of
 207  * the model.
 208  *
 209  * Return value: the new cell renderer
 210  **/
 211 GtkCellRenderer *
 212 gtk_cell_renderer_toggle_new (void)
 213 {
 214   return GTK_CELL_RENDERER (gtk_type_new (gtk_cell_renderer_toggle_get_type ()));
 215 }
 216
 217 static void
 218 gtk_cell_renderer_toggle_get_size (GtkCellRenderer *cell,
 219                                    GtkWidget       *widget,
 220                                    gint            *width,
 221                                    gint            *height)
 222 {
 223   if (width)
 224     *width = (gint) cell->xpad * 2 + TOGGLE_WIDTH;
 225
 226   if (height)
 227     *height = (gint) cell->ypad * 2 + TOGGLE_WIDTH;
 228 }
 229
 230 static void
 231 gtk_cell_renderer_toggle_render (GtkCellRenderer *cell,
 232                                  GdkWindow       *window,
 233                                  GtkWidget       *widget,
 234                                  GdkRectangle    *background_area,
 235                                  GdkRectangle    *cell_area,
 236                                  GdkRectangle    *expose_area,
 237                                  guint            flags)
 238 {
 239   GtkCellRendererToggle *celltoggle = (GtkCellRendererToggle *) cell;
 240   gint width, height;
 241   gint real_xoffset, real_yoffset;
 242   GtkShadowType shadow;
 243   GtkStateType state;
 244
 245   width = MIN (TOGGLE_WIDTH, cell_area->width - cell->xpad * 2);
 246   height = MIN (TOGGLE_WIDTH, cell_area->height - cell->ypad * 2);
 247
 248   if (width <= 0 || height <= 0)
 249     return;
 250
 251   real_xoffset = cell->xalign * (cell_area->width - width - (2 * cell->xpad));
 252   real_xoffset = MAX (real_xoffset, 0) + cell->xpad;
 253   real_yoffset = cell->yalign * (cell_area->height - height - (2 * cell->ypad));
 254   real_yoffset = MAX (real_yoffset, 0) + cell->ypad;
 255
 256   shadow = celltoggle->active ? GTK_SHADOW_IN : GTK_SHADOW_OUT;
 257
 258   if ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED)
 259     state = GTK_STATE_SELECTED;
 260   else
 261     state = GTK_STATE_NORMAL;
 262
 263   if (celltoggle->radio)
 264     {
 265       gtk_paint_option (widget->style,
 266                         window,
 267                         state, shadow,
 268                         cell_area, widget, "cellradio",
 269                         cell_area->x + real_xoffset,
 270                         cell_area->y + real_yoffset,
 271                         width, height);
 272     }
 273   else
 274     {
 275       gtk_paint_check (widget->style,
 276                        window,
 277                        state, shadow,
 278                        cell_area, widget, "cellcheck",
 279                        cell_area->x + real_xoffset,
 280                        cell_area->y + real_yoffset,
 281                        width, height);
 282     }
 283 }
 284
 285 static gint
 286 gtk_cell_renderer_toggle_event (GtkCellRenderer *cell,
 287                                 GdkEvent        *event,
 288                                 GtkWidget       *widget,
 289                                 gchar           *path,
 290                                 GdkRectangle    *background_area,
 291                                 GdkRectangle    *cell_area,
 292                                 guint            flags)
 293 {
 294   GtkCellRendererToggle *celltoggle;
 295   gint retval = FALSE;
 296
 297   celltoggle = GTK_CELL_RENDERER_TOGGLE (cell);
 298
 299   switch (event->type)
 300     {
 301     case GDK_BUTTON_PRESS:
 302       {
 303         gtk_signal_emit (GTK_OBJECT (cell), toggle_cell_signals[TOGGLED], path);
 304         retval = TRUE;
 305       }
 306       break;
 307
 308     default:
 309       break;
 310     }
 311
 312   return retval;
 313 }
 314
 315 /**
 316  * gtk_cell_renderer_toggle_set_radio:
 317  * @toggle: a #GtkCellRendererToggle
 318  * @radio: %TRUE to make the toggle look like a radio button
 319  *
 320  * If @radio is %TRUE, the cell renderer renders a radio toggle
 321  * (i.e. a toggle in a group of mutually-exclusive toggles).
 322  * If %FALSE, it renders a check toggle (a standalone boolean option).
 323  * This can be set globally for the cell renderer, or changed just
 324  * before rendering each cell in the model (for #GtkTreeView, you set
 325  * up a per-row setting using #GtkTreeViewColumn to associate model
 326  * columns with cell renderer properties).
 327  **/
 328 void
 329 gtk_cell_renderer_toggle_set_radio (GtkCellRendererToggle *toggle,
 330                                     gboolean               radio)
 331 {
 332   g_return_if_fail (GTK_IS_CELL_RENDERER_TOGGLE (toggle));
 333
 334   toggle->radio = radio;
 335 }
 336
 337 /**
 338  * gtk_cell_renderer_toggle_get_radio:
 339  * @toggle: a #GtkCellRendererToggle
 340  *
 341  * Return value: %TRUE if we're rendering radio toggles rather than checkboxes
 342  **/
 343 gboolean
 344 gtk_cell_renderer_toggle_get_radio (GtkCellRendererToggle *toggle)
 345 {
 346   g_return_val_if_fail (GTK_IS_CELL_RENDERER_TOGGLE (toggle), FALSE);
 347
 348   return toggle->radio;
 349 }