gtktoolbutton.c 45.7 KB
Newer Older
1 2
/* gtktoolbutton.c
 *
3
 * Copyright (C) 2002 Anders Carlsson <andersca@gnome.org>
4 5 6 7 8 9 10 11 12 13 14 15 16 17
 * Copyright (C) 2002 James Henstridge <james@daa.com.au>
 * Copyright (C) 2003 Soeren Sandmann <sandmann@daimi.au.dk>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
Javier Jardón's avatar
Javier Jardón committed
18
 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
19 20
 */

21
#include "config.h"
22 23 24
#include "gtktoolbutton.h"
#include "gtkbutton.h"
#include "gtkimage.h"
25
#include "deprecated/gtkimagemenuitem.h"
26
#include "gtklabel.h"
27
#include "deprecated/gtkstock.h"
Matthias Clasen's avatar
Matthias Clasen committed
28
#include "gtkbox.h"
29
#include "gtkintl.h"
30
#include "gtktoolbarprivate.h"
31
#include "deprecated/gtkactivatable.h"
32
#include "gtkactionable.h"
33
#include "gtkprivate.h"
34 35 36

#include <string.h>

37 38 39 40 41 42 43 44

/**
 * SECTION:gtktoolbutton
 * @Short_description: A GtkToolItem subclass that displays buttons
 * @Title: GtkToolButton
 * @See_also: #GtkToolbar, #GtkMenuToolButton, #GtkToggleToolButton,
 *   #GtkRadioToolButton, #GtkSeparatorToolItem
 *
45
 * #GtkToolButtons are #GtkToolItems containing buttons.
46
 *
47
 * Use gtk_tool_button_new() to create a new #GtkToolButton.
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
 *
 * The label of a #GtkToolButton is determined by the properties
 * #GtkToolButton:label-widget, #GtkToolButton:label, and
 * #GtkToolButton:stock-id. If #GtkToolButton:label-widget is
 * non-%NULL, then that widget is used as the label. Otherwise, if
 * #GtkToolButton:label is non-%NULL, that string is used as the label.
 * Otherwise, if #GtkToolButton:stock-id is non-%NULL, the label is
 * determined by the stock item. Otherwise, the button does not have a label.
 *
 * The icon of a #GtkToolButton is determined by the properties
 * #GtkToolButton:icon-widget and #GtkToolButton:stock-id. If
 * #GtkToolButton:icon-widget is non-%NULL, then
 * that widget is used as the icon. Otherwise, if #GtkToolButton:stock-id is
 * non-%NULL, the icon is determined by the stock item. Otherwise,
 * the button does not have a icon.
63 64 65 66
 *
 * # CSS nodes
 *
 * GtkToolButton has a single CSS node with name toolbutton.
67 68 69
 */


70 71 72 73 74 75 76 77 78 79 80 81 82
#define MENU_ID "gtk-tool-button-menu-id"

enum {
  CLICKED,
  LAST_SIGNAL
};

enum {
  PROP_0,
  PROP_LABEL,
  PROP_USE_UNDERLINE,
  PROP_LABEL_WIDGET,
  PROP_STOCK_ID,
83
  PROP_ICON_NAME,
84 85 86
  PROP_ICON_WIDGET,
  PROP_ACTION_NAME,
  PROP_ACTION_TARGET
87 88
};

89 90 91
static void gtk_tool_button_init          (GtkToolButton      *button,
					   GtkToolButtonClass *klass);
static void gtk_tool_button_class_init    (GtkToolButtonClass *klass);
92 93 94 95 96 97 98 99
static void gtk_tool_button_set_property  (GObject            *object,
					   guint               prop_id,
					   const GValue       *value,
					   GParamSpec         *pspec);
static void gtk_tool_button_get_property  (GObject            *object,
					   guint               prop_id,
					   GValue             *value,
					   GParamSpec         *pspec);
100 101
static void gtk_tool_button_property_notify (GObject          *object,
					     GParamSpec       *pspec);
102 103 104 105 106 107
static void gtk_tool_button_finalize      (GObject            *object);

static void gtk_tool_button_toolbar_reconfigured (GtkToolItem *tool_item);
static gboolean   gtk_tool_button_create_menu_proxy (GtkToolItem     *item);
static void       button_clicked                    (GtkWidget       *widget,
						     GtkToolButton   *button);
108
static void gtk_tool_button_style_updated  (GtkWidget          *widget);
109 110 111

static void gtk_tool_button_construct_contents (GtkToolItem *tool_item);

112
static void gtk_tool_button_actionable_iface_init      (GtkActionableInterface *iface);
113
static void gtk_tool_button_activatable_interface_init (GtkActivatableIface  *iface);
114
static void gtk_tool_button_update                     (GtkActivatable       *activatable,
115 116
							GtkAction            *action,
							const gchar          *property_name);
117
static void gtk_tool_button_sync_action_properties     (GtkActivatable       *activatable,
118 119
							GtkAction            *action);

Matthias Clasen's avatar
Matthias Clasen committed
120

121 122 123 124 125
struct _GtkToolButtonPrivate
{
  GtkWidget *button;

  gchar *stock_id;
126
  gchar *icon_name;
127 128 129
  gchar *label_text;
  GtkWidget *label_widget;
  GtkWidget *icon_widget;
130 131 132

  GtkSizeGroup *text_size_group;

133
  guint use_underline : 1;
134
  guint contents_invalid : 1;
135 136
};

137
static GObjectClass        *parent_class = NULL;
138 139 140
static GtkActivatableIface *parent_activatable_iface;
static guint                toolbutton_signals[LAST_SIGNAL] = { 0 };

141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
GType
gtk_tool_button_get_type (void)
{
  static GType g_define_type_id = 0;

  if (!g_define_type_id)
    {
      const GInterfaceInfo actionable_info =
      {
        (GInterfaceInitFunc) gtk_tool_button_actionable_iface_init,
        (GInterfaceFinalizeFunc) NULL,
        NULL
      };
      const GInterfaceInfo activatable_info =
      {
        (GInterfaceInitFunc) gtk_tool_button_activatable_interface_init,
        (GInterfaceFinalizeFunc) NULL,
        NULL
      };

      g_define_type_id = g_type_register_static_simple (GTK_TYPE_TOOL_ITEM,
                                                        I_("GtkToolButton"),
                                                        sizeof (GtkToolButtonClass),
                                                        (GClassInitFunc) gtk_tool_button_class_init,
                                                        sizeof (GtkToolButton),
                                                        (GInstanceInitFunc) gtk_tool_button_init,
                                                        0);

      G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
      g_type_add_interface_static (g_define_type_id,
                                   GTK_TYPE_ACTIONABLE, &actionable_info);
      g_type_add_interface_static (g_define_type_id,
                                   GTK_TYPE_ACTIVATABLE, &activatable_info);
      G_GNUC_END_IGNORE_DEPRECATIONS;
    }
  return g_define_type_id;
}
178 179 180 181 182

static void
gtk_tool_button_class_init (GtkToolButtonClass *klass)
{
  GObjectClass *object_class;
183
  GtkWidgetClass *widget_class;
184
  GtkToolItemClass *tool_item_class;
185 186 187
  
  parent_class = g_type_class_peek_parent (klass);
  
188
  object_class = (GObjectClass *)klass;
189
  widget_class = (GtkWidgetClass *)klass;
190
  tool_item_class = (GtkToolItemClass *)klass;
191
  
192 193
  object_class->set_property = gtk_tool_button_set_property;
  object_class->get_property = gtk_tool_button_get_property;
194
  object_class->notify = gtk_tool_button_property_notify;
195 196
  object_class->finalize = gtk_tool_button_finalize;

197
  widget_class->style_updated = gtk_tool_button_style_updated;
198

199 200
  tool_item_class->create_menu_proxy = gtk_tool_button_create_menu_proxy;
  tool_item_class->toolbar_reconfigured = gtk_tool_button_toolbar_reconfigured;
201
  
202 203
  klass->button_type = GTK_TYPE_BUTTON;

204 205 206 207 208
  /* Properties are interpreted like this:
   *
   *          - if the tool button has an icon_widget, then that widget
   *            will be used as the icon. Otherwise, if the tool button
   *            has a stock id, the corresponding stock icon will be
209 210 211
   *            used. Otherwise, if the tool button has an icon name,
   *            the corresponding icon from the theme will be used.
   *            Otherwise, the tool button will not have an icon.
212 213 214 215 216
   *
   *          - if the tool button has a label_widget then that widget
   *            will be used as the label. Otherwise, if the tool button
   *            has a label text, that text will be used as label. Otherwise,
   *            if the toolbutton has a stock id, the corresponding text
217 218 219
   *            will be used as label. Otherwise, if the tool button has
   *            an icon name, the corresponding icon name from the theme will
   *            be used. Otherwise, the toolbutton will have an empty label.
220 221 222 223 224 225 226 227 228 229 230 231
   *
   *	      - The use_underline property only has an effect when the label
   *            on the toolbutton comes from the label property (ie. not from
   *            label_widget or from stock_id).
   *
   *            In that case, if use_underline is set,
   *
   *			- underscores are removed from the label text before
   *                      the label is shown on the toolbutton unless the
   *                      underscore is followed by another underscore
   *
   *			- an underscore indicates that the next character when
232 233
   *                      used in the overflow menu should be used as a
   *                      mnemonic.
234 235
   *
   *		In short: use_underline = TRUE means that the label text has
236 237
   *            the form "_Open" and the toolbar should take appropriate
   *            action.
238 239
   */

240 241 242
  g_object_class_install_property (object_class,
				   PROP_LABEL,
				   g_param_spec_string ("label",
243 244
							P_("Label"),
							P_("Text to show in the item."),
245
							NULL,
246
							GTK_PARAM_READWRITE));
247 248
  g_object_class_install_property (object_class,
				   PROP_USE_UNDERLINE,
249
				   g_param_spec_boolean ("use-underline",
250 251
							 P_("Use underline"),
							 P_("If set, an underline in the label property indicates that the next character should be used for the mnemonic accelerator key in the overflow menu"),
252
							 FALSE,
253
							 GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY));
254 255
  g_object_class_install_property (object_class,
				   PROP_LABEL_WIDGET,
256
				   g_param_spec_object ("label-widget",
257 258
							P_("Label widget"),
							P_("Widget to use as the item label"),
259
							GTK_TYPE_WIDGET,
260
							GTK_PARAM_READWRITE));
261 262 263 264 265
  /**
   * GtkToolButton:stock-id:
   *
   * Deprecated: 3.10: Use #GtkToolButton:icon-name instead.
   */
266 267
  g_object_class_install_property (object_class,
				   PROP_STOCK_ID,
268
				   g_param_spec_string ("stock-id",
269 270
							P_("Stock Id"),
							P_("The stock icon displayed on the item"),
271
							NULL,
272
							GTK_PARAM_READWRITE | G_PARAM_DEPRECATED));
273 274 275 276 277

  /**
   * GtkToolButton:icon-name:
   * 
   * The name of the themed icon displayed on the item.
278 279 280
   * This property only has an effect if not overridden by
   * #GtkToolButton:label-widget, #GtkToolButton:icon-widget or
   * #GtkToolButton:stock-id properties.
281 282 283 284 285 286 287 288 289 290
   *
   * Since: 2.8 
   */
  g_object_class_install_property (object_class,
				   PROP_ICON_NAME,
				   g_param_spec_string ("icon-name",
							P_("Icon name"),
							P_("The name of the themed icon displayed on the item"),
							NULL,
							GTK_PARAM_READWRITE));
291 292
  g_object_class_install_property (object_class,
				   PROP_ICON_WIDGET,
293
				   g_param_spec_object ("icon-widget",
294 295
							P_("Icon widget"),
							P_("Icon widget to display in the item"),
296
							GTK_TYPE_WIDGET,
297
							GTK_PARAM_READWRITE));
298

299 300 301
  g_object_class_override_property (object_class, PROP_ACTION_NAME, "action-name");
  g_object_class_override_property (object_class, PROP_ACTION_TARGET, "action-target");

302
  /**
303
   * GtkButton:icon-spacing:
304 305 306 307 308 309 310 311 312 313 314
   * 
   * Spacing in pixels between the icon and label.
   * 
   * Since: 2.10
   */
  gtk_widget_class_install_style_property (widget_class,
					   g_param_spec_int ("icon-spacing",
							     P_("Icon spacing"),
							     P_("Spacing in pixels between the icon and label"),
							     0,
							     G_MAXINT,
315
							     3,
316
							     GTK_PARAM_READWRITE));
317

318 319 320 321 322 323 324
/**
 * GtkToolButton::clicked:
 * @toolbutton: the object that emitted the signal
 *
 * This signal is emitted when the tool button is clicked with the mouse
 * or activated with the keyboard.
 **/
325
  toolbutton_signals[CLICKED] =
326
    g_signal_new (I_("clicked"),
327
		  G_OBJECT_CLASS_TYPE (klass),
328
		  G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
329 330 331 332
		  G_STRUCT_OFFSET (GtkToolButtonClass, clicked),
		  NULL, NULL,
		  g_cclosure_marshal_VOID__VOID,
		  G_TYPE_NONE, 0);
333 334
  
  g_type_class_add_private (object_class, sizeof (GtkToolButtonPrivate));
335 336

  gtk_widget_class_set_css_name (widget_class, "toolbutton");
337 338 339
}

static void
340 341
gtk_tool_button_init (GtkToolButton      *button,
		      GtkToolButtonClass *klass)
342 343
{
  GtkToolItem *toolitem = GTK_TOOL_ITEM (button);
344

345 346 347
  button->priv = G_TYPE_INSTANCE_GET_PRIVATE (button,
                                              GTK_TYPE_TOOL_BUTTON,
                                              GtkToolButtonPrivate);
348

349 350
  button->priv->contents_invalid = TRUE;

351
  gtk_tool_item_set_homogeneous (toolitem, TRUE);
352 353

  /* create button */
354
  button->priv->button = g_object_new (klass->button_type, NULL);
355
  gtk_widget_set_focus_on_click (GTK_WIDGET (button->priv->button), FALSE);
356
  g_signal_connect_object (button->priv->button, "clicked",
357 358
			   G_CALLBACK (button_clicked), button, 0);

359 360
  gtk_container_add (GTK_CONTAINER (button), button->priv->button);
  gtk_widget_show (button->priv->button);
361 362 363 364 365 366
}

static void
gtk_tool_button_construct_contents (GtkToolItem *tool_item)
{
  GtkToolButton *button = GTK_TOOL_BUTTON (tool_item);
Javier Jardón's avatar
Javier Jardón committed
367
  GtkWidget *child;
368 369 370 371 372 373 374
  GtkWidget *label = NULL;
  GtkWidget *icon = NULL;
  GtkToolbarStyle style;
  gboolean need_label = FALSE;
  gboolean need_icon = FALSE;
  GtkIconSize icon_size;
  GtkWidget *box = NULL;
375
  guint icon_spacing;
376 377
  GtkOrientation text_orientation = GTK_ORIENTATION_HORIZONTAL;
  GtkSizeGroup *size_group = NULL;
378
  GtkWidget *parent;
379

380 381
  button->priv->contents_invalid = FALSE;

382 383 384
  gtk_widget_style_get (GTK_WIDGET (tool_item), 
			"icon-spacing", &icon_spacing,
			NULL);
385

386
  if (button->priv->icon_widget)
387
    {
388 389 390 391 392 393
      parent = gtk_widget_get_parent (button->priv->icon_widget);
      if (parent)
        {
          gtk_container_remove (GTK_CONTAINER (parent),
                                button->priv->icon_widget);
        }
394 395
    }

396
  if (button->priv->label_widget)
397
    {
398 399 400 401 402 403
      parent = gtk_widget_get_parent (button->priv->label_widget);
      if (parent)
        {
          gtk_container_remove (GTK_CONTAINER (parent),
                                button->priv->label_widget);
        }
404 405
    }

Javier Jardón's avatar
Javier Jardón committed
406 407
  child = gtk_bin_get_child (GTK_BIN (button->priv->button));
  if (child)
408
    {
409 410 411
      /* Note: we are not destroying the label_widget or icon_widget
       * here because they were removed from their containers above
       */
Javier Jardón's avatar
Javier Jardón committed
412
      gtk_widget_destroy (child);
413 414 415 416 417 418
    }

  style = gtk_tool_item_get_toolbar_style (GTK_TOOL_ITEM (button));
  
  if (style != GTK_TOOLBAR_TEXT)
    need_icon = TRUE;
419 420 421 422 423 424

  if (style != GTK_TOOLBAR_ICONS && style != GTK_TOOLBAR_BOTH_HORIZ)
    need_label = TRUE;

  if (style == GTK_TOOLBAR_BOTH_HORIZ &&
      (gtk_tool_item_get_is_important (GTK_TOOL_ITEM (button)) ||
425 426
       gtk_tool_item_get_orientation (GTK_TOOL_ITEM (button)) == GTK_ORIENTATION_VERTICAL ||
       gtk_tool_item_get_text_orientation (GTK_TOOL_ITEM (button)) == GTK_ORIENTATION_VERTICAL))
427 428 429
    {
      need_label = TRUE;
    }
430
  
431
  if (style != GTK_TOOLBAR_TEXT && button->priv->icon_widget == NULL &&
432 433 434 435 436 437 438 439 440 441 442 443 444 445
      button->priv->stock_id == NULL && button->priv->icon_name == NULL)
    {
      need_label = TRUE;
      need_icon = FALSE;
      style = GTK_TOOLBAR_TEXT;
    }

  if (style == GTK_TOOLBAR_TEXT && button->priv->label_widget == NULL &&
      button->priv->stock_id == NULL && button->priv->label_text == NULL)
    {
      need_label = FALSE;
      need_icon = TRUE;
      style = GTK_TOOLBAR_ICONS;
    }
446

447 448
  if (need_label)
    {
449
      if (button->priv->label_widget)
450
	{
451
	  label = button->priv->label_widget;
452 453 454 455
	}
      else
	{
	  GtkStockItem stock_item;
456
	  gboolean elide;
457 458
	  gchar *label_text;

459 460
          G_GNUC_BEGIN_IGNORE_DEPRECATIONS;

461
	  if (button->priv->label_text)
462
	    {
463 464
	      label_text = button->priv->label_text;
	      elide = button->priv->use_underline;
465
	    }
466
	  else if (button->priv->stock_id && gtk_stock_lookup (button->priv->stock_id, &stock_item))
467 468 469 470
	    {
	      label_text = stock_item.label;
	      elide = TRUE;
	    }
471
	  else
472 473 474 475
	    {
	      label_text = "";
	      elide = FALSE;
	    }
476

477 478
          G_GNUC_END_IGNORE_DEPRECATIONS;

479
	  if (elide)
480
	    label_text = _gtk_toolbar_elide_underscores (label_text);
481 482 483 484 485 486 487 488 489
	  else
	    label_text = g_strdup (label_text);

	  label = gtk_label_new (label_text);

	  g_free (label_text);
	  
	  gtk_widget_show (label);
	}
490

491
      if (GTK_IS_LABEL (label))
492
        {
493 494 495 496 497
          gtk_label_set_ellipsize (GTK_LABEL (label),
			           gtk_tool_item_get_ellipsize_mode (GTK_TOOL_ITEM (button)));
          text_orientation = gtk_tool_item_get_text_orientation (GTK_TOOL_ITEM (button));
          if (text_orientation == GTK_ORIENTATION_HORIZONTAL)
	    {
498 499
              gfloat align;

500
              gtk_label_set_angle (GTK_LABEL (label), 0);
501 502 503 504 505 506 507
              align = gtk_tool_item_get_text_alignment (GTK_TOOL_ITEM (button));
              if (align < 0.4)
                gtk_widget_set_halign (label, GTK_ALIGN_START);
              else if (align > 0.6)
                gtk_widget_set_halign (label, GTK_ALIGN_END);
              else
                gtk_widget_set_halign (label, GTK_ALIGN_CENTER);
508 509 510
            }
          else
            {
511 512
              gfloat align;

513 514 515 516 517
              gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_NONE);
	      if (gtk_widget_get_direction (GTK_WIDGET (tool_item)) == GTK_TEXT_DIR_RTL)
	        gtk_label_set_angle (GTK_LABEL (label), -90);
	      else
	        gtk_label_set_angle (GTK_LABEL (label), 90);
518 519 520 521 522 523 524
              align = gtk_tool_item_get_text_alignment (GTK_TOOL_ITEM (button));
              if (align < 0.4)
                gtk_widget_set_valign (label, GTK_ALIGN_END);
              else if (align > 0.6)
                gtk_widget_set_valign (label, GTK_ALIGN_START);
              else
                gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
525
            }
526
        }
527 528 529 530 531
    }

  icon_size = gtk_tool_item_get_icon_size (GTK_TOOL_ITEM (button));
  if (need_icon)
    {
532 533 534 535 536 537 538 539 540
      GtkIconSet *icon_set = NULL;

      if (button->priv->stock_id)
        {
          G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
          icon_set = gtk_icon_factory_lookup_default (button->priv->stock_id);
          G_GNUC_END_IGNORE_DEPRECATIONS;
        }

541
      if (button->priv->icon_widget)
542
	{
543
	  icon = button->priv->icon_widget;
544 545 546
	  
	  if (GTK_IS_IMAGE (icon))
	    {
547
	      g_object_set (button->priv->icon_widget,
548 549
			    "icon-size", icon_size,
			    NULL);
550 551
	    }
	}
552
      else if (icon_set != NULL)
553
	{
554
          G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
555
	  icon = gtk_image_new_from_stock (button->priv->stock_id, icon_size);
556
          G_GNUC_END_IGNORE_DEPRECATIONS;
557 558
	  gtk_widget_show (icon);
	}
559 560 561 562 563
      else if (button->priv->icon_name)
	{
	  icon = gtk_image_new_from_icon_name (button->priv->icon_name, icon_size);
	  gtk_widget_show (icon);
	}
564 565 566

      if (icon)
	{
567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591
          if (text_orientation == GTK_ORIENTATION_HORIZONTAL)
            {
              gfloat align;

              align = gtk_tool_item_get_text_alignment (GTK_TOOL_ITEM (button));
              if (align > 0.6) 
                gtk_widget_set_halign (icon, GTK_ALIGN_START);
              else if (align < 0.4)
                gtk_widget_set_halign (icon, GTK_ALIGN_END);
              else
                gtk_widget_set_halign (icon, GTK_ALIGN_CENTER);
            }
          else
            {
              gfloat align;

              align = gtk_tool_item_get_text_alignment (GTK_TOOL_ITEM (button));
              if (align > 0.6) 
                gtk_widget_set_valign (icon, GTK_ALIGN_END);
              else if (align < 0.4)
                gtk_widget_set_valign (icon, GTK_ALIGN_START);
              else
               gtk_widget_set_valign (icon, GTK_ALIGN_CENTER);
            }

592 593 594 595
	  size_group = gtk_tool_item_get_text_size_group (GTK_TOOL_ITEM (button));
	  if (size_group != NULL)
	    gtk_size_group_add_widget (size_group, icon);
	}
596 597 598 599 600 601
    }

  switch (style)
    {
    case GTK_TOOLBAR_ICONS:
      if (icon)
602 603
        gtk_container_add (GTK_CONTAINER (button->priv->button), icon);
      gtk_style_context_add_class (gtk_widget_get_style_context (button->priv->button), "image-button");
604
      gtk_style_context_remove_class (gtk_widget_get_style_context (button->priv->button), "text-button");
605 606 607
      break;

    case GTK_TOOLBAR_BOTH:
608
      if (text_orientation == GTK_ORIENTATION_HORIZONTAL)
609
	box = gtk_box_new (GTK_ORIENTATION_VERTICAL, icon_spacing);
610
      else
611
	box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, icon_spacing);
612 613
      if (icon)
	gtk_box_pack_start (GTK_BOX (box), icon, TRUE, TRUE, 0);
614
      gtk_box_pack_end (GTK_BOX (box), label, FALSE, TRUE, 0);
615
      gtk_container_add (GTK_CONTAINER (button->priv->button), box);
616 617
      gtk_style_context_add_class (gtk_widget_get_style_context (button->priv->button), "image-button");
      gtk_style_context_add_class (gtk_widget_get_style_context (button->priv->button), "text-button");
618 619 620
      break;

    case GTK_TOOLBAR_BOTH_HORIZ:
621 622
      if (text_orientation == GTK_ORIENTATION_HORIZONTAL)
	{
623
	  box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, icon_spacing);
624 625 626 627 628 629 630
	  if (icon)
	    gtk_box_pack_start (GTK_BOX (box), icon, label? FALSE : TRUE, TRUE, 0);
	  if (label)
	    gtk_box_pack_end (GTK_BOX (box), label, TRUE, TRUE, 0);
	}
      else
	{
631
	  box = gtk_box_new (GTK_ORIENTATION_VERTICAL, icon_spacing);
632 633 634 635 636
	  if (icon)
	    gtk_box_pack_end (GTK_BOX (box), icon, label ? FALSE : TRUE, TRUE, 0);
	  if (label)
	    gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 0);
	}
637
      gtk_container_add (GTK_CONTAINER (button->priv->button), box);
638 639
      gtk_style_context_add_class (gtk_widget_get_style_context (button->priv->button), "image-button");
      gtk_style_context_add_class (gtk_widget_get_style_context (button->priv->button), "text-button");
640 641 642
      break;

    case GTK_TOOLBAR_TEXT:
643
      gtk_container_add (GTK_CONTAINER (button->priv->button), label);
644
      gtk_style_context_add_class (gtk_widget_get_style_context (button->priv->button), "text-button");
645
      gtk_style_context_remove_class (gtk_widget_get_style_context (button->priv->button), "image-button");
646 647 648 649 650 651
      break;
    }

  if (box)
    gtk_widget_show (box);

652
  gtk_button_set_relief (GTK_BUTTON (button->priv->button),
653 654
			 gtk_tool_item_get_relief_style (GTK_TOOL_ITEM (button)));

655 656
  gtk_tool_item_rebuild_menu (tool_item);
  
657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679
  gtk_widget_queue_resize (GTK_WIDGET (button));
}

static void
gtk_tool_button_set_property (GObject         *object,
			      guint            prop_id,
			      const GValue    *value,
			      GParamSpec      *pspec)
{
  GtkToolButton *button = GTK_TOOL_BUTTON (object);
  
  switch (prop_id)
    {
    case PROP_LABEL:
      gtk_tool_button_set_label (button, g_value_get_string (value));
      break;
    case PROP_USE_UNDERLINE:
      gtk_tool_button_set_use_underline (button, g_value_get_boolean (value));
      break;
    case PROP_LABEL_WIDGET:
      gtk_tool_button_set_label_widget (button, g_value_get_object (value));
      break;
    case PROP_STOCK_ID:
680
      G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
681
      gtk_tool_button_set_stock_id (button, g_value_get_string (value));
682
      G_GNUC_END_IGNORE_DEPRECATIONS;
683
      break;
684 685 686
    case PROP_ICON_NAME:
      gtk_tool_button_set_icon_name (button, g_value_get_string (value));
      break;
687 688 689
    case PROP_ICON_WIDGET:
      gtk_tool_button_set_icon_widget (button, g_value_get_object (value));
      break;
690 691 692 693 694 695
    case PROP_ACTION_NAME:
      g_object_set_property (G_OBJECT (button->priv->button), "action-name", value);
      break;
    case PROP_ACTION_TARGET:
      g_object_set_property (G_OBJECT (button->priv->button), "action-target", value);
      break;
696 697
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
698
      break;
699 700 701
    }
}

702 703 704 705
static void
gtk_tool_button_property_notify (GObject          *object,
				 GParamSpec       *pspec)
{
706 707
  GtkToolButton *button = GTK_TOOL_BUTTON (object);

708 709
  if (button->priv->contents_invalid ||
      strcmp ("is-important", pspec->name) == 0)
710
    gtk_tool_button_construct_contents (GTK_TOOL_ITEM (object));
711

712 713
  if (parent_class->notify)
    parent_class->notify (object, pspec);
714 715
}

716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735
static void
gtk_tool_button_get_property (GObject         *object,
			      guint            prop_id,
			      GValue          *value,
			      GParamSpec      *pspec)
{
  GtkToolButton *button = GTK_TOOL_BUTTON (object);

  switch (prop_id)
    {
    case PROP_LABEL:
      g_value_set_string (value, gtk_tool_button_get_label (button));
      break;
    case PROP_LABEL_WIDGET:
      g_value_set_object (value, gtk_tool_button_get_label_widget (button));
      break;
    case PROP_USE_UNDERLINE:
      g_value_set_boolean (value, gtk_tool_button_get_use_underline (button));
      break;
    case PROP_STOCK_ID:
736
      g_value_set_string (value, button->priv->stock_id);
737
      break;
738 739 740
    case PROP_ICON_NAME:
      g_value_set_string (value, button->priv->icon_name);
      break;
741
    case PROP_ICON_WIDGET:
742
      g_value_set_object (value, button->priv->icon_widget);
743
      break;
744 745 746 747 748 749
    case PROP_ACTION_NAME:
      g_object_get_property (G_OBJECT (button->priv->button), "action-name", value);
      break;
    case PROP_ACTION_TARGET:
      g_object_get_property (G_OBJECT (button->priv->button), "action-target", value);
      break;
750 751
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
752
      break;
753 754 755
    }
}

756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798
static const gchar *
gtk_tool_button_get_action_name (GtkActionable *actionable)
{
  GtkToolButton *button = GTK_TOOL_BUTTON (actionable);

  return gtk_actionable_get_action_name (GTK_ACTIONABLE (button->priv->button));
}

static void
gtk_tool_button_set_action_name (GtkActionable *actionable,
                                 const gchar   *action_name)
{
  GtkToolButton *button = GTK_TOOL_BUTTON (actionable);

  gtk_actionable_set_action_name (GTK_ACTIONABLE (button->priv->button), action_name);
}

static GVariant *
gtk_tool_button_get_action_target_value (GtkActionable *actionable)
{
  GtkToolButton *button = GTK_TOOL_BUTTON (actionable);

  return gtk_actionable_get_action_target_value (GTK_ACTIONABLE (button->priv->button));
}

static void
gtk_tool_button_set_action_target_value (GtkActionable *actionable,
                                         GVariant      *action_target)
{
  GtkToolButton *button = GTK_TOOL_BUTTON (actionable);

  gtk_actionable_set_action_target_value (GTK_ACTIONABLE (button->priv->button), action_target);
}

static void
gtk_tool_button_actionable_iface_init (GtkActionableInterface *iface)
{
  iface->get_action_name = gtk_tool_button_get_action_name;
  iface->set_action_name = gtk_tool_button_set_action_name;
  iface->get_action_target_value = gtk_tool_button_get_action_target_value;
  iface->set_action_target_value = gtk_tool_button_set_action_target_value;
}

799 800 801 802 803
static void
gtk_tool_button_finalize (GObject *object)
{
  GtkToolButton *button = GTK_TOOL_BUTTON (object);

804 805 806
  g_free (button->priv->stock_id);
  g_free (button->priv->icon_name);
  g_free (button->priv->label_text);
807 808

  if (button->priv->label_widget)
809
    g_object_unref (button->priv->label_widget);
810 811

  if (button->priv->icon_widget)
812
    g_object_unref (button->priv->icon_widget);
813 814
  
  parent_class->finalize (object);
815 816
}

817
static GtkWidget *
818
clone_image_menu_size (GtkImage *image)
819 820 821 822 823 824
{
  GtkImageType storage_type = gtk_image_get_storage_type (image);

  if (storage_type == GTK_IMAGE_STOCK)
    {
      gchar *stock_id;
825 826
      GtkWidget *widget;
      G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
827
      gtk_image_get_stock (image, &stock_id, NULL);
828 829 830
      widget = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_MENU);
      G_GNUC_END_IGNORE_DEPRECATIONS;
      return widget;
831
    }
832 833 834 835 836 837
  else if (storage_type == GTK_IMAGE_ICON_NAME)
    {
      const gchar *icon_name;
      gtk_image_get_icon_name (image, &icon_name, NULL);
      return gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
    }
838 839
  else if (storage_type == GTK_IMAGE_ICON_SET)
    {
840
      GtkWidget *widget;
841
      GtkIconSet *icon_set;
842
      G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
843
      gtk_image_get_icon_set (image, &icon_set, NULL);
844 845 846
      widget = gtk_image_new_from_icon_set (icon_set, GTK_ICON_SIZE_MENU);
      G_GNUC_END_IGNORE_DEPRECATIONS;
      return widget;
847
    }
848 849 850 851 852 853
  else if (storage_type == GTK_IMAGE_GICON)
    {
      GIcon *icon;
      gtk_image_get_gicon (image, &icon, NULL);
      return gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_MENU);
    }
854 855 856 857
  else if (storage_type == GTK_IMAGE_PIXBUF)
    {
      gint width, height;
      
858
      if (gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &width, &height))
859 860
	{
	  GdkPixbuf *src_pixbuf, *dest_pixbuf;
861
	  GtkWidget *cloned_image;
862 863 864 865 866

	  src_pixbuf = gtk_image_get_pixbuf (image);
	  dest_pixbuf = gdk_pixbuf_scale_simple (src_pixbuf, width, height,
						 GDK_INTERP_BILINEAR);

867
	  cloned_image = gtk_image_new_from_pixbuf (dest_pixbuf);
Matthias Clasen's avatar
Matthias Clasen committed
868 869
	  g_object_unref (dest_pixbuf);

870
	  return cloned_image;
871 872 873 874 875 876
	}
    }

  return NULL;
}
      
877 878 879 880 881 882 883 884
static gboolean
gtk_tool_button_create_menu_proxy (GtkToolItem *item)
{
  GtkToolButton *button = GTK_TOOL_BUTTON (item);
  GtkWidget *menu_item;
  GtkWidget *menu_image = NULL;
  GtkStockItem stock_item;
  gboolean use_mnemonic = TRUE;
885
  const char *label;
886

887 888
  if (_gtk_tool_item_create_menu_proxy (item))
    return TRUE;
889 890 891

  G_GNUC_BEGIN_IGNORE_DEPRECATIONS;

892
  if (GTK_IS_LABEL (button->priv->label_widget))
893
    {
894 895
      label = gtk_label_get_label (GTK_LABEL (button->priv->label_widget));
      use_mnemonic = gtk_label_get_use_underline (GTK_LABEL (button->priv->label_widget));
896
    }
897
  else if (button->priv->label_text)
898
    {
899 900
      label = button->priv->label_text;
      use_mnemonic = button->priv->use_underline;
901
    }
902
  else if (button->priv->stock_id && gtk_stock_lookup (button->priv->stock_id, &stock_item))
903 904 905 906 907 908 909
    {
      label = stock_item.label;
    }
  else
    {
      label = "";
    }
910

911 912 913 914 915
  if (use_mnemonic)
    menu_item = gtk_image_menu_item_new_with_mnemonic (label);
  else
    menu_item = gtk_image_menu_item_new_with_label (label);

916
  if (GTK_IS_IMAGE (button->priv->icon_widget))
917
    {
918
      menu_image = clone_image_menu_size (GTK_IMAGE (button->priv->icon_widget));
919
    }
920
  else if (button->priv->stock_id)
921
    {
922
      menu_image = gtk_image_new_from_stock (button->priv->stock_id, GTK_ICON_SIZE_MENU);
923 924 925 926 927
    }

  if (menu_image)
    gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), menu_image);

928 929
  G_GNUC_END_IGNORE_DEPRECATIONS;

930 931 932
  g_signal_connect_closure_by_id (menu_item,
				  g_signal_lookup ("activate", G_OBJECT_TYPE (menu_item)), 0,
				  g_cclosure_new_object_swap (G_CALLBACK (gtk_button_clicked),
933
							      G_OBJECT (GTK_TOOL_BUTTON (button)->priv->button)),
934 935 936 937 938 939 940 941 942 943 944
				  FALSE);

  gtk_tool_item_set_proxy_menu_item (GTK_TOOL_ITEM (button), MENU_ID, menu_item);
  
  return TRUE;
}

static void
button_clicked (GtkWidget     *widget,
		GtkToolButton *button)
{
945 946
  GtkAction *action;

947 948
  G_GNUC_BEGIN_IGNORE_DEPRECATIONS;

949 950 951 952 953
  action = gtk_activatable_get_related_action (GTK_ACTIVATABLE (button));
  
  if (action)
    gtk_action_activate (action);

954 955
  G_GNUC_END_IGNORE_DEPRECATIONS;

956 957 958 959 960 961 962 963 964
  g_signal_emit_by_name (button, "clicked");
}

static void
gtk_tool_button_toolbar_reconfigured (GtkToolItem *tool_item)
{
  gtk_tool_button_construct_contents (tool_item);
}

965 966 967 968 969 970
static void 
gtk_tool_button_update_icon_spacing (GtkToolButton *button)
{
  GtkWidget *box;
  guint spacing;

Javier Jardón's avatar
Javier Jardón committed
971
  box = gtk_bin_get_child (GTK_BIN (button->priv->button));
972 973 974 975 976 977 978 979 980
  if (GTK_IS_BOX (box))
    {
      gtk_widget_style_get (GTK_WIDGET (button), 
			    "icon-spacing", &spacing,
			    NULL);
      gtk_box_set_spacing (GTK_BOX (box), spacing);      
    }
}

981
static void
982
gtk_tool_button_style_updated (GtkWidget *widget)
983
{
984
  GTK_WIDGET_CLASS (parent_class)->style_updated (widget);
985

986
  gtk_tool_button_update_icon_spacing (GTK_TOOL_BUTTON (widget));
987 988
}

989 990 991 992
static void 
gtk_tool_button_activatable_interface_init (GtkActivatableIface  *iface)
{
  parent_activatable_iface = g_type_interface_peek_parent (iface);
993 994
  iface->update = gtk_tool_button_update;
  iface->sync_action_properties = gtk_tool_button_sync_action_properties;
995 996 997
}

static void
998 999 1000
gtk_tool_button_update (GtkActivatable *activatable,
			GtkAction      *action,
			const gchar    *property_name)
1001 1002 1003
{
  GtkToolButton *button;
  GtkWidget *image;
1004
  gboolean use_action_appearance;
1005 1006 1007

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

1008 1009 1010 1011 1012
  G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
  use_action_appearance = gtk_activatable_get_use_action_appearance (activatable);
  G_GNUC_END_IGNORE_DEPRECATIONS;

  if (!use_action_appearance)
1013 1014 1015 1016
    return;

  button = GTK_TOOL_BUTTON (activatable);
  
1017 1018
  G_GNUC_BEGIN_IGNORE_DEPRECATIONS;

1019
  if (strcmp (property_name, "short-label") == 0)
1020
    gtk_tool_button_set_label (button, gtk_action_get_short_label (action));
1021
  else if (strcmp (property_name, "stock-id") == 0)
1022
    gtk_tool_button_set_stock_id (button, gtk_action_get_stock_id (action));
1023 1024 1025 1026 1027
  else if (strcmp (property_name, "gicon") == 0)
    {
      const gchar *stock_id = gtk_action_get_stock_id (action);
      GIcon *icon = gtk_action_get_gicon (action);
      GtkIconSize icon_size = GTK_ICON_SIZE_BUTTON;
1028
      GtkIconSet *icon_set = NULL;
1029

1030 1031 1032 1033 1034 1035
      if (stock_id)
        {
          G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
          icon_set = gtk_icon_factory_lookup_default (stock_id);
          G_GNUC_END_IGNORE_DEPRECATIONS;
        }
1036
      G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
1037 1038

      if (icon_set != NULL || !icon)
1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053
	image = NULL;
      else 
	{   
	  image = gtk_tool_button_get_icon_widget (button);
	  icon_size = gtk_tool_item_get_icon_size (GTK_TOOL_ITEM (button));

	  if (!image)
	    image = gtk_image_new ();
	}

      gtk_tool_button_set_icon_widget (button, image);
      gtk_image_set_from_gicon (GTK_IMAGE (image), icon, icon_size);

    }
  else if (strcmp (property_name, "icon-name") == 0)
1054
    gtk_tool_button_set_icon_name (button, gtk_action_get_icon_name (action));
1055 1056

  G_GNUC_END_IGNORE_DEPRECATIONS;
1057 1058 1059
}

static void
1060 1061
gtk_tool_button_sync_action_properties (GtkActivatable *activatable,
				        GtkAction      *action)
1062 1063 1064
{
  GtkToolButton *button;
  GIcon         *icon;
1065
  const gchar   *stock_id;
1066
  GtkIconSet    *icon_set = NULL;
1067

1068
  parent_activatable_iface->sync_action_properties (activatable, action);
1069 1070 1071 1072 1073 1074 1075 1076

  if (!action)
    return;

  if (!gtk_activatable_get_use_action_appearance (activatable))
    return;

  button = GTK_TOOL_BUTTON (activatable);
1077
  G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
1078
  stock_id = gtk_action_get_stock_id (action);
1079
  G_GNUC_END_IGNORE_DEPRECATIONS;
1080 1081

  gtk_tool_button_set_label (button, gtk_action_get_short_label (action));
1082
  gtk_tool_button_set_use_underline (button, TRUE);
1083
  G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
1084
  gtk_tool_button_set_stock_id (button, stock_id);
1085
  G_GNUC_END_IGNORE_DEPRECATIONS;
1086 1087
  gtk_tool_button_set_icon_name (button, gtk_action_get_icon_name (action));

1088 1089 1090 1091 1092 1093 1094 1095
  if (stock_id)
    {
      G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
      icon_set = gtk_icon_factory_lookup_default (stock_id);
      G_GNUC_END_IGNORE_DEPRECATIONS;
    }

  if (icon_set != NULL)
1096
      gtk_tool_button_set_icon_widget (button, NULL);
1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116
  else if ((icon = gtk_action_get_gicon (action)) != NULL)
    {
      GtkIconSize icon_size = gtk_tool_item_get_icon_size (GTK_TOOL_ITEM (button));
      GtkWidget  *image = gtk_tool_button_get_icon_widget (button);
      
      if (!image)
	{
	  image = gtk_image_new ();
	  gtk_widget_show (image);
	  gtk_tool_button_set_icon_widget (button, image);
	}

      gtk_image_set_from_gicon (GTK_IMAGE (image), icon, icon_size);
    }
  else if (gtk_action_get_icon_name (action))
    gtk_tool_button_set_icon_name (button, gtk_action_get_icon_name (action));
  else
    gtk_tool_button_set_label (button, gtk_action_get_short_label (action));
}

1117 1118 1119 1120 1121 1122 1123 1124 1125 1126
/**
 * gtk_tool_button_new_from_stock:
 * @stock_id: the name of the stock item 
 *
 * Creates a new #GtkToolButton containing the image and text from a
 * stock item. Some stock ids have preprocessor macros like #GTK_STOCK_OK
 * and #GTK_STOCK_APPLY.
 *
 * It is an error if @stock_id is not a name of a stock item.
 * 
1127
 * Returns: A new #GtkToolButton
1128 1129
 * 
 * Since: 2.4
1130
 *
1131 1132
 * Deprecated: 3.10: Use gtk_tool_button_new() together with
 * gtk_image_new_from_icon_name() instead.
1133
 **/
1134 1135 1136 1137 1138 1139 1140 1141
GtkToolItem *
gtk_tool_button_new_from_stock (const gchar *stock_id)
{
  GtkToolButton *button;

  g_return_val_if_fail (stock_id != NULL, NULL);
    
  button = g_object_new (GTK_TYPE_TOOL_BUTTON,
1142
			 "stock-id", stock_id,
1143 1144 1145 1146 1147
			 NULL);

  return GTK_TOOL_ITEM (button);
}

1148 1149
/**
 * gtk_tool_button_new:
1150
 * @label: (allow-none): a string that will be used as label, or %NULL
1151
 * @icon_widget: (allow-none): a widget that will be used as the button contents, or %NULL
1152
 *
1153
 * Creates a new #GtkToolButton using @icon_widget as contents and @label as
1154
 * label.
1155
 *
1156
 * Returns: A new #GtkToolButton
1157 1158 1159
 * 
 * Since: 2.4
 **/
1160
GtkToolItem *
1161 1162
gtk_tool_button_new (GtkWidget	 *icon_widget,
		     const gchar *label)
1163 1164
{
  GtkToolButton *button;
1165

1166
  g_return_val_if_fail (icon_widget == NULL || GTK_IS_WIDGET (icon_widget), NULL);
1167

1168
  button = g_object_new (GTK_TYPE_TOOL_BUTTON,
1169 1170
                         "label", label,
                         "icon-widget", icon_widget,
1171 1172 1173 1174 1175
			 NULL);

  return GTK_TOOL_ITEM (button);  
}

1176 1177 1178
/**
 * gtk_tool_button_set_label:
 * @button: a #GtkToolButton
1179 1180
 * @label: (allow-none): a string that will be used as label, or %NULL.
 *
1181 1182 1183 1184 1185 1186
 * Sets @label as the label used for the tool button. The #GtkToolButton:label
 * property only has an effect if not overridden by a non-%NULL 
 * #GtkToolButton:label-widget property. If both the #GtkToolButton:label-widget
 * and #GtkToolButton:label properties are %NULL, the label is determined by the
 * #GtkToolButton:stock-id property. If the #GtkToolButton:stock-id property is
 * also %NULL, @button will not have a label.
1187 1188 1189
 * 
 * Since: 2.4
 **/
1190 1191 1192 1193 1194
void
gtk_tool_button_set_label (GtkToolButton *button,
			   const gchar   *label)
{
  gchar *old_label;
1195 1196
  gchar *elided_label;
  AtkObject *accessible;
1197 1198 1199
  
  g_return_if_fail (GTK_IS_TOOL_BUTTON (button));

1200
  old_label = button->priv->label_text;
1201

1202
  button->priv->label_text = g_strdup (label);
1203
  button->priv->contents_invalid = TRUE;     
1204

1205 1206 1207 1208 1209 1210 1211
  if (label)
    {
      elided_label = _gtk_toolbar_elide_underscores (label);
      accessible = gtk_widget_get_accessible (GTK_WIDGET (button->priv->button));
      atk_object_set_name (accessible, elided_label);
      g_free (elided_label);
    }
1212

1213 1214 1215
  g_free (old_label);
 
  g_object_notify (G_OBJECT (button), "label");
1216 1217
}

1218 1219 1220 1221 1222
/**
 * gtk_tool_button_get_label:
 * @button: a #GtkToolButton
 * 
 * Returns the label used by the tool button, or %NULL if the tool button
1223
 * doesn’t have a label. or uses a the label from a stock item. The returned
1224 1225
 * string is owned by GTK+, and must not be modified or freed.
 * 
1226
 * Returns: (nullable): The label, or %NULL
1227 1228 1229
 * 
 * Since: 2.4
 **/
1230
const gchar *
1231 1232 1233 1234
gtk_tool_button_get_label (GtkToolButton *button)
{
  g_return_val_if_fail (GTK_IS_TOOL_BUTTON (button), NULL);

1235
  return button->priv->label_text;
1236 1237
}

1238 1239 1240
/**
 * gtk_tool_button_set_use_underline:
 * @button: a #GtkToolButton
1241
 * @use_underline: whether the button label has the form “_Open”
1242 1243 1244
 *
 * If set, an underline in the label property indicates that the next character
 * should be used for the mnemonic accelerator key in the overflow menu. For
1245 1246
 * example, if the label property is “_Open” and @use_underline is %TRUE,
 * the label on the tool button will be “Open” and the item on the overflow
1247
 * menu will have an underlined “O”.
1248 1249 1250 1251 1252 1253
 * 
 * Labels shown on tool buttons never have mnemonics on them; this property
 * only affects the menu item on the overflow menu.
 * 
 * Since: 2.4
 **/
1254 1255 1256 1257 1258 1259 1260 1261
void
gtk_tool_button_set_use_underline (GtkToolButton *button,
				   gboolean       use_underline)
{
  g_return_if_fail (GTK_IS_TOOL_BUTTON (button));

  use_underline = use_underline != FALSE;

1262
  if (use_underline != button->priv->use_underline)
1263
    {
1264
      button->priv->use_underline = use_underline;
1265
      button->priv->contents_invalid = TRUE;
1266

1267
      g_object_notify (G_OBJECT (button), "use-underline");
1268 1269 1270
    }
}

1271 1272 1273 1274 1275 1276 1277
/**
 * gtk_tool_button_get_use_underline:
 * @button: a #GtkToolButton
 * 
 * Returns whether underscores in the label property are used as mnemonics
 * on menu items on the overflow menu. See gtk_tool_button_set_use_underline().
 * 
1278
 * Returns: %TRUE if underscores in the label property are used as
1279 1280 1281 1282
 * mnemonics on menu items on the overflow menu.
 * 
 * Since: 2.4
 **/
1283 1284 1285 1286 1287
gboolean
gtk_tool_button_get_use_underline (GtkToolButton *button)
{
  g_return_val_if_fail (GTK_IS_TOOL_BUTTON (button), FALSE);

1288
  return button->priv->use_underline;
1289 1290
}

1291 1292 1293
/**
 * gtk_tool_button_set_stock_id:
 * @button: a #GtkToolButton
1294 1295
 * @stock_id: (allow-none): a name of a stock item, or %NULL
 *
1296
 * Sets the name of the stock item. See gtk_tool_button_new_from_stock().
1297 1298
 * The stock_id property only has an effect if not overridden by non-%NULL 
 * #GtkToolButton:label-widget and #GtkToolButton:icon-widget properties.
1299 1300
 * 
 * Since: 2.4
1301 1302
 *
 * Deprecated: 3.10: Use gtk_tool_button_set_icon_name() instead.
1303
 **/
1304 1305 1306 1307 1308 1309 1310 1311
void
gtk_tool_button_set_stock_id (GtkToolButton *button,
			      const gchar   *stock_id)
{
  gchar *old_stock_id;
  
  g_return_if_fail (GTK_IS_TOOL_BUTTON (button));

1312
  old_stock_id = button->priv->stock_id;
1313

1314
  button->priv->stock_id = g_strdup (stock_id);
1315
  button->priv->contents_invalid = TRUE;
1316 1317

  g_free (old_stock_id);
1318 1319
  
  g_object_notify (G_OBJECT (button), "stock-id");
1320 1321
}

1322 1323 1324 1325 1326 1327 1328
/**
 * gtk_tool_button_get_stock_id:
 * @button: a #GtkToolButton
 * 
 * Returns the name of the stock item. See gtk_tool_button_set_stock_id().
 * The returned string is owned by GTK+ and must not be freed or modifed.
 * 
1329
 * Returns: the name of the stock item for @button.
1330 1331
 * 
 * Since: 2.4
1332 1333
 *
 * Deprecated: 3.10: Use gtk_tool_button_get_icon_name() instead.
1334
 **/
1335
const gchar *
1336 1337 1338 1339
gtk_tool_button_get_stock_id (GtkToolButton *button)
{
  g_return_val_if_fail (GTK_IS_TOOL_BUTTON (button), NULL);

1340
  return button->priv->stock_id;
1341 1342
}

1343
/**
1344
 * gtk_tool_button_set_icon_name:
1345
 * @button: a #GtkToolButton
1346 1347
 * @icon_name: (allow-none): the name of the themed icon
 *
1348 1349
 * Sets the icon for the tool button from a named themed icon.
 * See the docs for #GtkIconTheme for more details.
1350 1351 1352
 * The #GtkToolButton:icon-name property only has an effect if not
 * overridden by non-%NULL #GtkToolButton:label-widget, 
 * #GtkToolButton:icon-widget and #GtkToolButton:stock-id properties.
1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366
 * 
 * Since: 2.8
 **/
void
gtk_tool_button_set_icon_name (GtkToolButton *button,
			       const gchar   *icon_name)
{
  gchar *old_icon_name;

  g_return_if_fail (GTK_IS_TOOL_BUTTON (button));

  old_icon_name = button->priv->icon_name;

  button->priv->icon_name = g_strdup (icon_name);
1367
  button->priv->contents_invalid = TRUE; 
1368 1369

  g_free (old_icon_name);
1370 1371

  g_object_notify (G_OBJECT (button), "icon-name");
1372 1373 1374
}

/**
1375
 * gtk_tool_button_get_icon_name:
1376
 * @button: a #GtkToolButton
1377
 *
1378 1379 1380
 * Returns the name of the themed icon for the tool button,
 * see gtk_tool_button_set_icon_name().
 *
1381
 * Returns: (nullable): the icon name or %NULL if the tool button has
1382
 * no themed icon
1383
 *
1384 1385
 * Since: 2.8
 **/
1386
const gchar*
1387 1388 1389 1390 1391 1392 1393
gtk_tool_button_get_icon_name (GtkToolButton *button)
{
  g_return_val_if_fail (GTK_IS_TOOL_BUTTON (button), NULL);

  return button->priv->icon_name;
}