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

   1 /*
   2  * GTK - The GIMP Toolkit
   3  * Copyright (C) 1998, 1999 Red Hat, Inc.
   4  * All rights reserved.
   5  *
   6  * This Library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public License as
   8  * published by the Free Software Foundation; either version 2 of the
   9  * License, or (at your option) any later version.
  10  *
  11  * This Library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with the Gnome Library; see the file COPYING.LIB.  If not,
  18  * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 /*
  23  * Author: James Henstridge <james@daa.com.au>
  24  *
  25  * Modified by the GTK+ Team and others 2003.  See the AUTHORS
  26  * file for a list of people on the GTK+ Team.  See the ChangeLog
  27  * files for a list of changes.  These files are distributed with
  28  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  29  */
  30
  31 #include "config.h"
  32
  33 #include "gtkradioaction.h"
  34 #include "gtkradiomenuitem.h"
  35 #include "gtktoggleactionprivate.h"
  36 #include "gtktoggletoolbutton.h"
  37 #include "gtkintl.h"
  38 #include "gtkprivate.h"
  39
  40 /**
  41  * SECTION:gtkradioaction
  42  * @Short_description: An action of which only one in a group can be active
  43  * @Title: GtkRadioAction
  44  *
  45  * A #GtkRadioAction is similar to #GtkRadioMenuItem. A number of radio
  46  * actions can be linked together so that only one may be active at any
  47  * one time.
  48  */
  49
  50
  51 struct _GtkRadioActionPrivate
  52 {
  53   GSList *group;
  54   gint    value;
  55 };
  56
  57 enum
  58 {
  59   CHANGED,
  60   LAST_SIGNAL
  61 };
  62
  63 enum
  64 {
  65   PROP_0,
  66   PROP_VALUE,
  67   PROP_GROUP,
  68   PROP_CURRENT_VALUE
  69 };
  70
  71 static void gtk_radio_action_finalize     (GObject *object);
  72 static void gtk_radio_action_set_property (GObject         *object,
  73                                            guint            prop_id,
  74                                            const GValue    *value,
  75                                            GParamSpec      *pspec);
  76 static void gtk_radio_action_get_property (GObject         *object,
  77                                            guint            prop_id,
  78                                            GValue          *value,
  79                                            GParamSpec      *pspec);
  80 static void gtk_radio_action_activate     (GtkAction *action);
  81 static GtkWidget *create_menu_item        (GtkAction *action);
  82
  83
  84 G_DEFINE_TYPE (GtkRadioAction, gtk_radio_action, GTK_TYPE_TOGGLE_ACTION)
  85
  86 static guint         radio_action_signals[LAST_SIGNAL] = { 0 };
  87
  88 static void
  89 gtk_radio_action_class_init (GtkRadioActionClass *klass)
  90 {
  91   GObjectClass *gobject_class;
  92   GtkActionClass *action_class;
  93
  94   gobject_class = G_OBJECT_CLASS (klass);
  95   action_class = GTK_ACTION_CLASS (klass);
  96
  97   gobject_class->finalize = gtk_radio_action_finalize;
  98   gobject_class->set_property = gtk_radio_action_set_property;
  99   gobject_class->get_property = gtk_radio_action_get_property;
 100
 101   action_class->activate = gtk_radio_action_activate;
 102
 103   action_class->create_menu_item = create_menu_item;
 104
 105   /**
 106    * GtkRadioAction:value:
 107    *
 108    * The value is an arbitrary integer which can be used as a
 109    * convenient way to determine which action in the group is
 110    * currently active in an ::activate or ::changed signal handler.
 111    * See gtk_radio_action_get_current_value() and #GtkRadioActionEntry
 112    * for convenient ways to get and set this property.
 113    *
 114    * Since: 2.4
 115    */
 116   g_object_class_install_property (gobject_class,
 117                                    PROP_VALUE,
 118                                    g_param_spec_int ("value",
 119                                                      P_("The value"),
 120                                                      P_("The value returned by gtk_radio_action_get_current_value() when this action is the current action of its group."),
 121                                                      G_MININT,
 122                                                      G_MAXINT,
 123                                                      0,
 124                                                      GTK_PARAM_READWRITE));
 125
 126   /**
 127    * GtkRadioAction:group:
 128    *
 129    * Sets a new group for a radio action.
 130    *
 131    * Since: 2.4
 132    */
 133   g_object_class_install_property (gobject_class,
 134                                    PROP_GROUP,
 135                                    g_param_spec_object ("group",
 136                                                         P_("Group"),
 137                                                         P_("The radio action whose group this action belongs to."),
 138                                                         GTK_TYPE_RADIO_ACTION,
 139                                                         GTK_PARAM_WRITABLE));
 140
 141   /**
 142    * GtkRadioAction:current-value:
 143    *
 144    * The value property of the currently active member of the group to which
 145    * this action belongs.
 146    *
 147    * Since: 2.10
 148    */
 149   g_object_class_install_property (gobject_class,
 150                                    PROP_CURRENT_VALUE,
 151                                    g_param_spec_int ("current-value",
 152                                                      P_("The current value"),
 153                                                      P_("The value property of the currently active member of the group to which this action belongs."),
 154                                                      G_MININT,
 155                                                      G_MAXINT,
 156                                                      0,
 157                                                      GTK_PARAM_READWRITE));
 158
 159   /**
 160    * GtkRadioAction::changed:
 161    * @action: the action on which the signal is emitted
 162    * @current: the member of @action<!-- -->s group which has just been activated
 163    *
 164    * The ::changed signal is emitted on every member of a radio group when the
 165    * active member is changed. The signal gets emitted after the ::activate signals
 166    * for the previous and current active members.
 167    *
 168    * Since: 2.4
 169    */
 170   radio_action_signals[CHANGED] =
 171     g_signal_new (I_("changed"),
 172                   G_OBJECT_CLASS_TYPE (klass),
 173                   G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
 174                   G_STRUCT_OFFSET (GtkRadioActionClass, changed),  NULL, NULL,
 175                   g_cclosure_marshal_VOID__OBJECT,
 176                   G_TYPE_NONE, 1, GTK_TYPE_RADIO_ACTION);
 177
 178   g_type_class_add_private (gobject_class, sizeof (GtkRadioActionPrivate));
 179 }
 180
 181 static void
 182 gtk_radio_action_init (GtkRadioAction *action)
 183 {
 184   action->private_data = G_TYPE_INSTANCE_GET_PRIVATE (action,
 185                                                       GTK_TYPE_RADIO_ACTION,
 186                                                       GtkRadioActionPrivate);
 187
 188   action->private_data->group = g_slist_prepend (NULL, action);
 189   action->private_data->value = 0;
 190
 191   gtk_toggle_action_set_draw_as_radio (GTK_TOGGLE_ACTION (action), TRUE);
 192 }
 193
 194 /**
 195  * gtk_radio_action_new:
 196  * @name: A unique name for the action
 197  * @label: (allow-none): The label displayed in menu items and on buttons, or %NULL
 198  * @tooltip: (allow-none): A tooltip for this action, or %NULL
 199  * @stock_id: The stock icon to display in widgets representing this
 200  *   action, or %NULL
 201  * @value: The value which gtk_radio_action_get_current_value() should
 202  *   return if this action is selected.
 203  *
 204  * Creates a new #GtkRadioAction object. To add the action to
 205  * a #GtkActionGroup and set the accelerator for the action,
 206  * call gtk_action_group_add_action_with_accel().
 207  *
 208  * Return value: a new #GtkRadioAction
 209  *
 210  * Since: 2.4
 211  */
 212 GtkRadioAction *
 213 gtk_radio_action_new (const gchar *name,
 214                       const gchar *label,
 215                       const gchar *tooltip,
 216                       const gchar *stock_id,
 217                       gint value)
 218 {
 219   g_return_val_if_fail (name != NULL, NULL);
 220
 221   return g_object_new (GTK_TYPE_RADIO_ACTION,
 222                        "name", name,
 223                        "label", label,
 224                        "tooltip", tooltip,
 225                        "stock-id", stock_id,
 226                        "value", value,
 227                        NULL);
 228 }
 229
 230 static void
 231 gtk_radio_action_finalize (GObject *object)
 232 {
 233   GtkRadioAction *action;
 234   GSList *tmp_list;
 235
 236   action = GTK_RADIO_ACTION (object);
 237
 238   action->private_data->group = g_slist_remove (action->private_data->group, action);
 239
 240   tmp_list = action->private_data->group;
 241
 242   while (tmp_list)
 243     {
 244       GtkRadioAction *tmp_action = tmp_list->data;
 245
 246       tmp_list = tmp_list->next;
 247       tmp_action->private_data->group = action->private_data->group;
 248     }
 249
 250   G_OBJECT_CLASS (gtk_radio_action_parent_class)->finalize (object);
 251 }
 252
 253 static void
 254 gtk_radio_action_set_property (GObject         *object,
 255                                guint            prop_id,
 256                                const GValue    *value,
 257                                GParamSpec      *pspec)
 258 {
 259   GtkRadioAction *radio_action;
 260
 261   radio_action = GTK_RADIO_ACTION (object);
 262
 263   switch (prop_id)
 264     {
 265     case PROP_VALUE:
 266       radio_action->private_data->value = g_value_get_int (value);
 267       break;
 268     case PROP_GROUP:
 269       {
 270         GtkRadioAction *arg;
 271         GSList *slist = NULL;
 272
 273         if (G_VALUE_HOLDS_OBJECT (value))
 274           {
 275             arg = GTK_RADIO_ACTION (g_value_get_object (value));
 276             if (arg)
 277               slist = gtk_radio_action_get_group (arg);
 278             gtk_radio_action_set_group (radio_action, slist);
 279           }
 280       }
 281       break;
 282     case PROP_CURRENT_VALUE:
 283       gtk_radio_action_set_current_value (radio_action,
 284                                           g_value_get_int (value));
 285       break;
 286     default:
 287       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 288       break;
 289     }
 290 }
 291
 292 static void
 293 gtk_radio_action_get_property (GObject    *object,
 294                                guint       prop_id,
 295                                GValue     *value,
 296                                GParamSpec *pspec)
 297 {
 298   GtkRadioAction *radio_action;
 299
 300   radio_action = GTK_RADIO_ACTION (object);
 301
 302   switch (prop_id)
 303     {
 304     case PROP_VALUE:
 305       g_value_set_int (value, radio_action->private_data->value);
 306       break;
 307     case PROP_CURRENT_VALUE:
 308       g_value_set_int (value,
 309                        gtk_radio_action_get_current_value (radio_action));
 310       break;
 311     default:
 312       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 313       break;
 314     }
 315 }
 316
 317 static void
 318 gtk_radio_action_activate (GtkAction *action)
 319 {
 320   GtkRadioAction *radio_action;
 321   GtkToggleAction *toggle_action;
 322   GtkToggleAction *tmp_action;
 323   GSList *tmp_list;
 324   gboolean active;
 325
 326   radio_action = GTK_RADIO_ACTION (action);
 327   toggle_action = GTK_TOGGLE_ACTION (action);
 328
 329   active = gtk_toggle_action_get_active (toggle_action);
 330   if (active)
 331     {
 332       tmp_list = radio_action->private_data->group;
 333
 334       while (tmp_list)
 335         {
 336           tmp_action = tmp_list->data;
 337           tmp_list = tmp_list->next;
 338
 339           if (gtk_toggle_action_get_active (tmp_action) &&
 340               (tmp_action != toggle_action))
 341             {
 342               gtk_toggle_action_set_active (toggle_action, !active);
 343
 344               break;
 345             }
 346         }
 347       g_object_notify (G_OBJECT (action), "active");
 348     }
 349   else
 350     {
 351       gtk_toggle_action_set_active (toggle_action, !active);
 352       g_object_notify (G_OBJECT (action), "active");
 353
 354       tmp_list = radio_action->private_data->group;
 355       while (tmp_list)
 356         {
 357           tmp_action = tmp_list->data;
 358           tmp_list = tmp_list->next;
 359
 360           if (gtk_toggle_action_get_active (tmp_action) &&
 361               (tmp_action != toggle_action))
 362             {
 363               _gtk_action_emit_activate (GTK_ACTION (tmp_action));
 364               break;
 365             }
 366         }
 367
 368       tmp_list = radio_action->private_data->group;
 369       while (tmp_list)
 370         {
 371           tmp_action = tmp_list->data;
 372           tmp_list = tmp_list->next;
 373
 374           g_object_notify (G_OBJECT (tmp_action), "current-value");
 375
 376           g_signal_emit (tmp_action, radio_action_signals[CHANGED], 0, radio_action);
 377         }
 378     }
 379
 380   gtk_toggle_action_toggled (toggle_action);
 381 }
 382
 383 static GtkWidget *
 384 create_menu_item (GtkAction *action)
 385 {
 386   return g_object_new (GTK_TYPE_CHECK_MENU_ITEM,
 387                        "draw-as-radio", TRUE,
 388                        NULL);
 389 }
 390
 391 /**
 392  * gtk_radio_action_get_group:
 393  * @action: the action object
 394  *
 395  * Returns the list representing the radio group for this object.
 396  * Note that the returned list is only valid until the next change
 397  * to the group.
 398  *
 399  * A common way to set up a group of radio group is the following:
 400  * |[
 401  *   GSList *group = NULL;
 402  *   GtkRadioAction *action;
 403  *
 404  *   while (/&ast; more actions to add &ast;/)
 405  *     {
 406  *        action = gtk_radio_action_new (...);
 407  *
 408  *        gtk_radio_action_set_group (action, group);
 409  *        group = gtk_radio_action_get_group (action);
 410  *     }
 411  * ]|
 412  *
 413  * Returns:  (element-type GtkRadioAction) (transfer none): the list representing the radio group for this object
 414  *
 415  * Since: 2.4
 416  */
 417 GSList *
 418 gtk_radio_action_get_group (GtkRadioAction *action)
 419 {
 420   g_return_val_if_fail (GTK_IS_RADIO_ACTION (action), NULL);
 421
 422   return action->private_data->group;
 423 }
 424
 425 /**
 426  * gtk_radio_action_set_group:
 427  * @action: the action object
 428  * @group: (element-type GtkRadioAction): a list representing a radio group
 429  *
 430  * Sets the radio group for the radio action object.
 431  *
 432  * Since: 2.4
 433  */
 434 void
 435 gtk_radio_action_set_group (GtkRadioAction *action,
 436                             GSList         *group)
 437 {
 438   g_return_if_fail (GTK_IS_RADIO_ACTION (action));
 439   g_return_if_fail (!g_slist_find (group, action));
 440
 441   if (action->private_data->group)
 442     {
 443       GSList *slist;
 444
 445       action->private_data->group = g_slist_remove (action->private_data->group, action);
 446
 447       for (slist = action->private_data->group; slist; slist = slist->next)
 448         {
 449           GtkRadioAction *tmp_action = slist->data;
 450
 451           tmp_action->private_data->group = action->private_data->group;
 452         }
 453     }
 454
 455   action->private_data->group = g_slist_prepend (group, action);
 456
 457   if (group)
 458     {
 459       GSList *slist;
 460
 461       for (slist = action->private_data->group; slist; slist = slist->next)
 462         {
 463           GtkRadioAction *tmp_action = slist->data;
 464
 465           tmp_action->private_data->group = action->private_data->group;
 466         }
 467     }
 468   else
 469     {
 470       gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), TRUE);
 471     }
 472 }
 473
 474 /**
 475  * gtk_radio_action_join_group:
 476  * @action: the action object
 477  * @group_source: (allow-none): a radio action object whos group we are
 478  *   joining, or %NULL to remove the radio action from its group
 479  *
 480  * Joins a radio action object to the group of another radio action object.
 481  *
 482  * Use this in language bindings instead of the gtk_radio_action_get_group()
 483  * and gtk_radio_action_set_group() methods
 484  *
 485  * A common way to set up a group of radio actions is the following:
 486  * |[
 487  *   GtkRadioAction *action;
 488  *   GtkRadioAction *last_action;
 489  *
 490  *   while (/&ast; more actions to add &ast;/)
 491  *     {
 492  *        action = gtk_radio_action_new (...);
 493  *
 494  *        gtk_radio_action_join_group (action, last_action);
 495  *        last_action = action;
 496  *     }
 497  * ]|
 498  *
 499  * Since: 3.0
 500  */
 501 void
 502 gtk_radio_action_join_group (GtkRadioAction *action,
 503                              GtkRadioAction *group_source)
 504 {
 505   g_return_if_fail (GTK_IS_RADIO_ACTION (action));
 506   g_return_if_fail (group_source == NULL || GTK_IS_RADIO_ACTION (group_source));
 507
 508   if (group_source)
 509     {
 510       GSList *group;
 511       group = gtk_radio_action_get_group (group_source);
 512
 513       if (!group)
 514         {
 515           /* if we are not already part of a group we need to set up a new one
 516              and then get the newly created group */
 517           gtk_radio_action_set_group (group_source, NULL);
 518           group = gtk_radio_action_get_group (group_source);
 519         }
 520
 521       gtk_radio_action_set_group (action, group);
 522     }
 523   else
 524     {
 525       gtk_radio_action_set_group (action, NULL);
 526     }
 527 }
 528
 529 /**
 530  * gtk_radio_action_get_current_value:
 531  * @action: a #GtkRadioAction
 532  *
 533  * Obtains the value property of the currently active member of
 534  * the group to which @action belongs.
 535  *
 536  * Return value: The value of the currently active group member
 537  *
 538  * Since: 2.4
 539  **/
 540 gint
 541 gtk_radio_action_get_current_value (GtkRadioAction *action)
 542 {
 543   GSList *slist;
 544
 545   g_return_val_if_fail (GTK_IS_RADIO_ACTION (action), 0);
 546
 547   if (action->private_data->group)
 548     {
 549       for (slist = action->private_data->group; slist; slist = slist->next)
 550         {
 551           GtkToggleAction *toggle_action = slist->data;
 552
 553           if (gtk_toggle_action_get_active (toggle_action))
 554             return GTK_RADIO_ACTION (toggle_action)->private_data->value;
 555         }
 556     }
 557
 558   return action->private_data->value;
 559 }
 560
 561 /**
 562  * gtk_radio_action_set_current_value:
 563  * @action: a #GtkRadioAction
 564  * @current_value: the new value
 565  *
 566  * Sets the currently active group member to the member with value
 567  * property @current_value.
 568  *
 569  * Since: 2.10
 570  **/
 571 void
 572 gtk_radio_action_set_current_value (GtkRadioAction *action,
 573                                     gint            current_value)
 574 {
 575   GSList *slist;
 576
 577   g_return_if_fail (GTK_IS_RADIO_ACTION (action));
 578
 579   if (action->private_data->group)
 580     {
 581       for (slist = action->private_data->group; slist; slist = slist->next)
 582         {
 583           GtkRadioAction *radio_action = slist->data;
 584
 585           if (radio_action->private_data->value == current_value)
 586             {
 587               gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (radio_action),
 588                                             TRUE);
 589               return;
 590             }
 591         }
 592     }
 593
 594   if (action->private_data->value == current_value)
 595     gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), TRUE);
 596   else
 597     g_warning ("Radio group does not contain an action with value '%d'",
 598                current_value);
 599 }