gtktogglebutton.c 18.3 KB
Newer Older
Cody Russell's avatar
Cody Russell committed
1
/* GTK - The GIMP Toolkit
Elliot Lee's avatar
Elliot Lee committed
2 3 4
 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
 *
 * This library is free software; you can redistribute it and/or
5
 * modify it under the terms of the GNU Lesser General Public
Elliot Lee's avatar
Elliot Lee committed
6 7 8 9 10 11
 * 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
12
 * Lesser General Public License for more details.
Elliot Lee's avatar
Elliot Lee committed
13
 *
14
 * You should have received a copy of the GNU Lesser General Public
Javier Jardón's avatar
Javier Jardón committed
15
 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
Elliot Lee's avatar
Elliot Lee committed
16
 */
17 18

/*
19
 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
20 21 22 23 24
 * file for a list of people on the GTK+ Team.  See the ChangeLog
 * files for a list of changes.  These files are distributed with
 * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
 */

25
#include "config.h"
26 27 28 29

#include "gtktogglebutton.h"

#include "gtkbuttonprivate.h"
30
#include "gtktogglebuttonprivate.h"
Elliot Lee's avatar
Elliot Lee committed
31 32
#include "gtklabel.h"
#include "gtkmain.h"
33
#include "gtkmarshalers.h"
34 35
#include "deprecated/gtktoggleaction.h"
#include "deprecated/gtkactivatable.h"
36
#include "gtkprivate.h"
37
#include "gtkintl.h"
38
#include "a11y/gtktogglebuttonaccessible.h"
39

Elliot Lee's avatar
Elliot Lee committed
40

41 42 43 44 45 46
/**
 * SECTION:gtktogglebutton
 * @Short_description: Create buttons which retain their state
 * @Title: GtkToggleButton
 * @See_also: #GtkButton, #GtkCheckButton, #GtkCheckMenuItem
 *
47
 * A #GtkToggleButton is a #GtkButton which will remain “pressed-in” when
48 49 50 51 52
 * clicked. Clicking again will cause the toggle button to return to its
 * normal state.
 *
 * A toggle button is created by calling either gtk_toggle_button_new() or
 * gtk_toggle_button_new_with_label(). If using the former, it is advisable to
53
 * pack a widget, (such as a #GtkLabel and/or a #GtkImage), into the toggle
54
 * button’s container. (See #GtkButton for more information).
55 56 57 58 59 60 61
 *
 * The state of a #GtkToggleButton can be set specifically using
 * gtk_toggle_button_set_active(), and retrieved using
 * gtk_toggle_button_get_active().
 *
 * To simply switch the state of a toggle button, use gtk_toggle_button_toggled().
 *
62 63
 * ## Creating two #GtkToggleButton widgets.
 *
64
 * |[<!-- language="C" -->
65 66
 * void make_toggles (void) {
 *    GtkWidget *dialog, *toggle1, *toggle2;
67 68
 *    GtkWidget *content_area;
 *    const char *text;
69
 *
70 71 72 73 74
 *    dialog = gtk_dialog_new (text);
 *    content_area = gtk_dialog_get_content_area ();
 *
 *    text = "Hi, i’m a toggle button.";
 *    toggle1 = gtk_toggle_button_new_with_label (text);
75
 *
76
 *    // Makes this toggle button invisible
77 78
 *    gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (toggle1),
 *                                TRUE);
79 80
 *
 *    g_signal_connect (toggle1, "toggled",
81 82 83
 *                      G_CALLBACK (output_state),
 *                      NULL);
 *    gtk_box_pack_start (GTK_BOX (content_area),
84 85
 *                        toggle1, FALSE, FALSE, 2);
 *
86 87 88 89
 *    text = "Hi, i’m a toggle button.";
 *    toggle2 = gtk_toggle_button_new_with_label (text);
 *    gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (toggle2),
 *                                FALSE);
90
 *    g_signal_connect (toggle2, "toggled",
91 92 93
 *                      G_CALLBACK (output_state),
 *                      NULL);
 *    gtk_box_pack_start (GTK_BOX (content_area),
94 95 96 97
 *                        toggle2, FALSE, FALSE, 2);
 *
 *    gtk_widget_show_all (dialog);
 * }
98
 * ]|
99 100 101
 */


Elliot Lee's avatar
Elliot Lee committed
102 103 104 105
#define DEFAULT_LEFT_POS  4
#define DEFAULT_TOP_POS   4
#define DEFAULT_SPACING   7

106 107 108 109 110 111 112
struct _GtkToggleButtonPrivate
{
  guint active         : 1;
  guint draw_indicator : 1;
  guint inconsistent   : 1;
};

Elliot Lee's avatar
Elliot Lee committed
113 114 115 116 117
enum {
  TOGGLED,
  LAST_SIGNAL
};

118
enum {
119 120 121 122
  PROP_0,
  PROP_ACTIVE,
  PROP_INCONSISTENT,
  PROP_DRAW_INDICATOR
123 124
};

Elliot Lee's avatar
Elliot Lee committed
125

126 127
static gboolean gtk_toggle_button_mnemonic_activate  (GtkWidget            *widget,
                                                      gboolean              group_cycling);
128 129 130 131 132 133 134 135 136
static void gtk_toggle_button_clicked       (GtkButton            *button);
static void gtk_toggle_button_set_property  (GObject              *object,
					     guint                 prop_id,
					     const GValue         *value,
					     GParamSpec           *pspec);
static void gtk_toggle_button_get_property  (GObject              *object,
					     guint                 prop_id,
					     GValue               *value,
					     GParamSpec           *pspec);
Elliot Lee's avatar
Elliot Lee committed
137 138


139
static void gtk_toggle_button_activatable_interface_init (GtkActivatableIface  *iface);
140 141 142 143 144
static void gtk_toggle_button_update         	     (GtkActivatable       *activatable,
					 	      GtkAction            *action,
						      const gchar          *property_name);
static void gtk_toggle_button_sync_action_properties (GtkActivatable       *activatable,
						      GtkAction            *action);
145 146 147 148

static GtkActivatableIface *parent_activatable_iface;
static guint                toggle_button_signals[LAST_SIGNAL] = { 0 };

149
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
150
G_DEFINE_TYPE_WITH_CODE (GtkToggleButton, gtk_toggle_button, GTK_TYPE_BUTTON,
151
                         G_ADD_PRIVATE (GtkToggleButton)
152 153
			 G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTIVATABLE,
						gtk_toggle_button_activatable_interface_init))
154
G_GNUC_END_IGNORE_DEPRECATIONS;
Elliot Lee's avatar
Elliot Lee committed
155 156 157 158

static void
gtk_toggle_button_class_init (GtkToggleButtonClass *class)
{
Manish Singh's avatar
Manish Singh committed
159
  GObjectClass *gobject_class;
Elliot Lee's avatar
Elliot Lee committed
160 161 162
  GtkWidgetClass *widget_class;
  GtkButtonClass *button_class;

163
  gobject_class = G_OBJECT_CLASS (class);
Elliot Lee's avatar
Elliot Lee committed
164 165 166
  widget_class = (GtkWidgetClass*) class;
  button_class = (GtkButtonClass*) class;

167 168
  gobject_class->set_property = gtk_toggle_button_set_property;
  gobject_class->get_property = gtk_toggle_button_get_property;
169

170
  widget_class->mnemonic_activate = gtk_toggle_button_mnemonic_activate;
Elliot Lee's avatar
Elliot Lee committed
171 172 173 174

  button_class->clicked = gtk_toggle_button_clicked;

  class->toggled = NULL;
175

176 177 178
  g_object_class_install_property (gobject_class,
                                   PROP_ACTIVE,
                                   g_param_spec_boolean ("active",
179
							 P_("Active"),
180
							 P_("If the toggle button should be pressed in"),
181
							 FALSE,
182
							 GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY));
183 184 185 186

  g_object_class_install_property (gobject_class,
                                   PROP_INCONSISTENT,
                                   g_param_spec_boolean ("inconsistent",
187 188
							 P_("Inconsistent"),
							 P_("If the toggle button is in an \"in between\" state"),
189
							 FALSE,
190
							 GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY));
191 192 193

  g_object_class_install_property (gobject_class,
                                   PROP_DRAW_INDICATOR,
194
                                   g_param_spec_boolean ("draw-indicator",
195 196
							 P_("Draw Indicator"),
							 P_("If the toggle part of the button is displayed"),
197
							 FALSE,
198
							 GTK_PARAM_READWRITE));
199

200 201 202 203 204 205 206
  /**
   * GtkToggleButton::toggled:
   * @togglebutton: the object which received the signal.
   *
   * Should be connected if you wish to perform an action whenever the
   * #GtkToggleButton's state is changed.
   */
207
  toggle_button_signals[TOGGLED] =
208
    g_signal_new (I_("toggled"),
Manish Singh's avatar
Manish Singh committed
209 210 211 212 213 214
		  G_OBJECT_CLASS_TYPE (gobject_class),
		  G_SIGNAL_RUN_FIRST,
		  G_STRUCT_OFFSET (GtkToggleButtonClass, toggled),
		  NULL, NULL,
		  _gtk_marshal_VOID__VOID,
		  G_TYPE_NONE, 0);
215

216
  gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_TOGGLE_BUTTON_ACCESSIBLE);
Elliot Lee's avatar
Elliot Lee committed
217 218 219 220 221
}

static void
gtk_toggle_button_init (GtkToggleButton *toggle_button)
{
222 223 224
  toggle_button->priv = gtk_toggle_button_get_instance_private (toggle_button);
  toggle_button->priv->active = FALSE;
  toggle_button->priv->draw_indicator = FALSE;
Elliot Lee's avatar
Elliot Lee committed
225 226
}

227 228
static void
gtk_toggle_button_activatable_interface_init (GtkActivatableIface *iface)
229 230
{
  parent_activatable_iface = g_type_interface_peek_parent (iface);
231 232
  iface->update = gtk_toggle_button_update;
  iface->sync_action_properties = gtk_toggle_button_sync_action_properties;
233 234 235
}

static void
236 237 238
gtk_toggle_button_update (GtkActivatable *activatable,
			  GtkAction      *action,
			  const gchar    *property_name)
239 240 241 242 243 244 245 246 247
{
  GtkToggleButton *button;

  parent_activatable_iface->update (activatable, action, property_name);

  button = GTK_TOGGLE_BUTTON (activatable);

  if (strcmp (property_name, "active") == 0)
    {
248
      G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
249 250 251
      gtk_action_block_activate (action);
      gtk_toggle_button_set_active (button, gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)));
      gtk_action_unblock_activate (action);
252
      G_GNUC_END_IGNORE_DEPRECATIONS;
253 254 255 256 257
    }

}

static void
258 259
gtk_toggle_button_sync_action_properties (GtkActivatable *activatable,
				          GtkAction      *action)
260 261
{
  GtkToggleButton *button;
262
  gboolean is_toggle_action;
263

264
  parent_activatable_iface->sync_action_properties (activatable, action);
265

266 267 268 269 270
  G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
  is_toggle_action = GTK_IS_TOGGLE_ACTION (action);
  G_GNUC_END_IGNORE_DEPRECATIONS;

  if (!is_toggle_action)
271 272 273 274
    return;

  button = GTK_TOGGLE_BUTTON (activatable);

275
  G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
276 277 278
  gtk_action_block_activate (action);
  gtk_toggle_button_set_active (button, gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)));
  gtk_action_unblock_activate (action);
279
  G_GNUC_END_IGNORE_DEPRECATIONS;
280 281
}

282 283 284 285 286 287 288
/**
 * gtk_toggle_button_new:
 *
 * Creates a new toggle button. A widget should be packed into the button, as in gtk_button_new().
 *
 * Returns: a new toggle button.
 */
Elliot Lee's avatar
Elliot Lee committed
289
GtkWidget*
290
gtk_toggle_button_new (void)
Elliot Lee's avatar
Elliot Lee committed
291
{
Manish Singh's avatar
Manish Singh committed
292
  return g_object_new (GTK_TYPE_TOGGLE_BUTTON, NULL);
Elliot Lee's avatar
Elliot Lee committed
293 294
}

295 296 297 298 299 300 301 302
/**
 * gtk_toggle_button_new_with_label:
 * @label: a string containing the message to be placed in the toggle button.
 *
 * Creates a new toggle button with a text label.
 *
 * Returns: a new toggle button.
 */
Elliot Lee's avatar
Elliot Lee committed
303 304 305
GtkWidget*
gtk_toggle_button_new_with_label (const gchar *label)
{
306
  return g_object_new (GTK_TYPE_TOGGLE_BUTTON, "label", label, NULL);
Elliot Lee's avatar
Elliot Lee committed
307 308
}

309 310 311 312 313 314 315 316
/**
 * gtk_toggle_button_new_with_mnemonic:
 * @label: the text of the button, with an underscore in front of the
 *         mnemonic character
 *
 * Creates a new #GtkToggleButton containing a label. The label
 * will be created using gtk_label_new_with_mnemonic(), so underscores
 * in @label indicate the mnemonic for the button.
Matthias Clasen's avatar
Matthias Clasen committed
317 318 319
 *
 * Returns: a new #GtkToggleButton
 */
320 321 322
GtkWidget*
gtk_toggle_button_new_with_mnemonic (const gchar *label)
{
323 324 325 326
  return g_object_new (GTK_TYPE_TOGGLE_BUTTON, 
		       "label", label, 
		       "use-underline", TRUE, 
		       NULL);
327 328
}

329
static void
330 331 332 333
gtk_toggle_button_set_property (GObject      *object,
				guint         prop_id,
				const GValue *value,
				GParamSpec   *pspec)
334 335 336 337 338
{
  GtkToggleButton *tb;

  tb = GTK_TOGGLE_BUTTON (object);

339
  switch (prop_id)
340
    {
341 342 343 344 345
    case PROP_ACTIVE:
      gtk_toggle_button_set_active (tb, g_value_get_boolean (value));
      break;
    case PROP_INCONSISTENT:
      gtk_toggle_button_set_inconsistent (tb, g_value_get_boolean (value));
346
      break;
347 348
    case PROP_DRAW_INDICATOR:
      gtk_toggle_button_set_mode (tb, g_value_get_boolean (value));
349 350
      break;
    default:
351
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
352 353 354 355 356
      break;
    }
}

static void
357 358 359 360
gtk_toggle_button_get_property (GObject      *object,
				guint         prop_id,
				GValue       *value,
				GParamSpec   *pspec)
361
{
362 363
  GtkToggleButton *tb = GTK_TOGGLE_BUTTON (object);
  GtkToggleButtonPrivate *priv = tb->priv;
364

365
  switch (prop_id)
366
    {
367
    case PROP_ACTIVE:
368
      g_value_set_boolean (value, priv->active);
369 370
      break;
    case PROP_INCONSISTENT:
371
      g_value_set_boolean (value, priv->inconsistent);
372
      break;
373
    case PROP_DRAW_INDICATOR:
374
      g_value_set_boolean (value, priv->draw_indicator);
375 376
      break;
    default:
377
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
378 379 380 381
      break;
    }
}

382 383 384 385 386 387 388 389 390 391
/**
 * gtk_toggle_button_set_mode:
 * @toggle_button: a #GtkToggleButton
 * @draw_indicator: if %TRUE, draw the button as a separate indicator
 * and label; if %FALSE, draw the button like a normal button
 *
 * Sets whether the button is displayed as a separate indicator and label.
 * You can call this function on a checkbutton or a radiobutton with
 * @draw_indicator = %FALSE to make the button look like a normal button
 *
392
 * This function only affects instances of classes like #GtkCheckButton
393 394 395
 * and #GtkRadioButton that derive from #GtkToggleButton,
 * not instances of #GtkToggleButton itself.
 */
Elliot Lee's avatar
Elliot Lee committed
396 397
void
gtk_toggle_button_set_mode (GtkToggleButton *toggle_button,
398
			    gboolean         draw_indicator)
Elliot Lee's avatar
Elliot Lee committed
399
{
400 401
  GtkToggleButtonPrivate *priv;

Elliot Lee's avatar
Elliot Lee committed
402 403
  g_return_if_fail (GTK_IS_TOGGLE_BUTTON (toggle_button));

404 405
  priv = toggle_button->priv;

Elliot Lee's avatar
Elliot Lee committed
406 407
  draw_indicator = draw_indicator ? TRUE : FALSE;

408
  if (priv->draw_indicator != draw_indicator)
Elliot Lee's avatar
Elliot Lee committed
409
    {
410 411
      GtkStyleContext *context;

412
      priv->draw_indicator = draw_indicator;
413

414
      if (gtk_widget_get_visible (GTK_WIDGET (toggle_button)))
Elliot Lee's avatar
Elliot Lee committed
415
	gtk_widget_queue_resize (GTK_WIDGET (toggle_button));
416

417
      g_object_notify (G_OBJECT (toggle_button), "draw-indicator");
418 419 420 421 422 423 424 425 426 427

      /* Make toggle buttons conditionally have the "button"
       * class depending on draw_indicator.
       */
      context = gtk_widget_get_style_context (GTK_WIDGET (toggle_button));

      if (draw_indicator)
        gtk_style_context_remove_class (context, GTK_STYLE_CLASS_BUTTON);
      else
        gtk_style_context_add_class (context, GTK_STYLE_CLASS_BUTTON);
Elliot Lee's avatar
Elliot Lee committed
428 429 430
    }
}

431 432 433 434 435 436 437
/**
 * gtk_toggle_button_get_mode:
 * @toggle_button: a #GtkToggleButton
 *
 * Retrieves whether the button is displayed as a separate indicator
 * and label. See gtk_toggle_button_set_mode().
 *
438
 * Returns: %TRUE if the togglebutton is drawn as a separate indicator
439 440 441 442 443 444 445
 *   and label.
 **/
gboolean
gtk_toggle_button_get_mode (GtkToggleButton *toggle_button)
{
  g_return_val_if_fail (GTK_IS_TOGGLE_BUTTON (toggle_button), FALSE);

446
  return toggle_button->priv->draw_indicator;
447
}
448

449 450 451 452 453 454
/**
 * gtk_toggle_button_set_active:
 * @toggle_button: a #GtkToggleButton.
 * @is_active: %TRUE or %FALSE.
 *
 * Sets the status of the toggle button. Set to %TRUE if you want the
455
 * GtkToggleButton to be “pressed in”, and %FALSE to raise it.
456 457
 * This action causes the #GtkToggleButton::toggled signal and the
 * #GtkButton::clicked signal to be emitted.
458
 */
Elliot Lee's avatar
Elliot Lee committed
459
void
460 461
gtk_toggle_button_set_active (GtkToggleButton *toggle_button,
			      gboolean         is_active)
Elliot Lee's avatar
Elliot Lee committed
462
{
463 464
  GtkToggleButtonPrivate *priv;

Elliot Lee's avatar
Elliot Lee committed
465 466
  g_return_if_fail (GTK_IS_TOGGLE_BUTTON (toggle_button));

467 468
  priv = toggle_button->priv;

469
  is_active = is_active != FALSE;
470

471
  if (priv->active != is_active)
472 473 474 475
    {
      gtk_button_clicked (GTK_BUTTON (toggle_button));
      g_object_notify (G_OBJECT (toggle_button), "active");
    }
Elliot Lee's avatar
Elliot Lee committed
476 477
}

478 479 480 481
void
_gtk_toggle_button_set_active (GtkToggleButton *toggle_button,
                               gboolean         is_active)
{
482
  toggle_button->priv->active = is_active;
483 484 485 486 487 488

  if (is_active)
    gtk_widget_set_state_flags (GTK_WIDGET (toggle_button), GTK_STATE_FLAG_CHECKED, FALSE);
  else
    gtk_widget_unset_state_flags (GTK_WIDGET (toggle_button), GTK_STATE_FLAG_CHECKED);

489 490
}

491 492 493 494 495 496 497 498 499
/**
 * gtk_toggle_button_get_active:
 * @toggle_button: a #GtkToggleButton.
 *
 * Queries a #GtkToggleButton and returns its current state. Returns %TRUE if
 * the toggle button is pressed in and %FALSE if it is raised.
 *
 * Returns: a #gboolean value.
 */
500 501 502 503 504
gboolean
gtk_toggle_button_get_active (GtkToggleButton *toggle_button)
{
  g_return_val_if_fail (GTK_IS_TOGGLE_BUTTON (toggle_button), FALSE);

505
  return toggle_button->priv->active;
506 507
}

508 509 510 511 512 513 514 515
/**
 * gtk_toggle_button_toggled:
 * @toggle_button: a #GtkToggleButton.
 *
 * Emits the #GtkToggleButton::toggled signal on the
 * #GtkToggleButton. There is no good reason for an
 * application ever to call this function.
 */
Elliot Lee's avatar
Elliot Lee committed
516 517 518
void
gtk_toggle_button_toggled (GtkToggleButton *toggle_button)
{
519 520
  g_return_if_fail (GTK_IS_TOGGLE_BUTTON (toggle_button));

Manish Singh's avatar
Manish Singh committed
521
  g_signal_emit (toggle_button, toggle_button_signals[TOGGLED], 0);
Elliot Lee's avatar
Elliot Lee committed
522 523
}

524 525 526 527 528 529 530 531
/**
 * gtk_toggle_button_set_inconsistent:
 * @toggle_button: a #GtkToggleButton
 * @setting: %TRUE if state is inconsistent
 *
 * If the user has selected a range of elements (such as some text or
 * spreadsheet cells) that are affected by a toggle button, and the
 * current values in that range are inconsistent, you may want to
532 533
 * display the toggle in an “in between” state. This function turns on
 * “in between” display.  Normally you would turn off the inconsistent
534 535
 * state again if the user toggles the toggle button. This has to be
 * done manually, gtk_toggle_button_set_inconsistent() only affects
536
 * visual appearance, it doesn’t affect the semantics of the button.
537 538 539 540 541 542
 * 
 **/
void
gtk_toggle_button_set_inconsistent (GtkToggleButton *toggle_button,
                                    gboolean         setting)
{
543 544
  GtkToggleButtonPrivate *priv;

545
  g_return_if_fail (GTK_IS_TOGGLE_BUTTON (toggle_button));
546 547 548

  priv = toggle_button->priv;

549 550
  setting = setting != FALSE;

551
  if (setting != priv->inconsistent)
552
    {
553 554
      priv->inconsistent = setting;

555 556 557 558
      if (setting)
        gtk_widget_set_state_flags (GTK_WIDGET (toggle_button), GTK_STATE_FLAG_INCONSISTENT, FALSE);
      else
        gtk_widget_unset_state_flags (GTK_WIDGET (toggle_button), GTK_STATE_FLAG_INCONSISTENT);
559 560

      g_object_notify (G_OBJECT (toggle_button), "inconsistent");      
561 562 563 564 565 566 567 568 569
    }
}

/**
 * gtk_toggle_button_get_inconsistent:
 * @toggle_button: a #GtkToggleButton
 * 
 * Gets the value set by gtk_toggle_button_set_inconsistent().
 * 
570
 * Returns: %TRUE if the button is displayed as inconsistent, %FALSE otherwise
571 572 573 574 575 576
 **/
gboolean
gtk_toggle_button_get_inconsistent (GtkToggleButton *toggle_button)
{
  g_return_val_if_fail (GTK_IS_TOGGLE_BUTTON (toggle_button), FALSE);

577
  return toggle_button->priv->inconsistent;
578
}
Elliot Lee's avatar
Elliot Lee committed
579

580 581 582 583 584 585 586 587 588
static gboolean
gtk_toggle_button_mnemonic_activate (GtkWidget *widget,
                                     gboolean   group_cycling)
{
  /*
   * We override the standard implementation in 
   * gtk_widget_real_mnemonic_activate() in order to focus the widget even
   * if there is no mnemonic conflict.
   */
589
  if (gtk_widget_get_can_focus (widget))
590 591 592 593 594 595 596 597
    gtk_widget_grab_focus (widget);

  if (!group_cycling)
    gtk_widget_activate (widget);

  return TRUE;
}

Elliot Lee's avatar
Elliot Lee committed
598 599 600
static void
gtk_toggle_button_clicked (GtkButton *button)
{
601
  GtkToggleButton *toggle_button = GTK_TOGGLE_BUTTON (button);
602 603
  GtkToggleButtonPrivate *priv = toggle_button->priv;

604
  _gtk_toggle_button_set_active (toggle_button, !priv->active);
Elliot Lee's avatar
Elliot Lee committed
605 606 607

  gtk_toggle_button_toggled (toggle_button);

608
  g_object_notify (G_OBJECT (toggle_button), "active");
609

Matthias Clasen's avatar
Matthias Clasen committed
610 611
  if (GTK_BUTTON_CLASS (gtk_toggle_button_parent_class)->clicked)
    GTK_BUTTON_CLASS (gtk_toggle_button_parent_class)->clicked (button);
Elliot Lee's avatar
Elliot Lee committed
612 613
}