gtktoolbutton.c 29.8 KB
Newer Older
1 2
/* gtktoolbutton.c
 *
Anders Carlsson's avatar
Anders Carlsson committed
3
 * Copyright (C) 2002 Anders Carlsson <andersca@gnome.org>
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
 * 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
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

23
#include <config.h>
24 25 26 27 28 29 30 31 32 33
#include "gtktoolbutton.h"
#include "gtkbutton.h"
#include "gtkhbox.h"
#include "gtkiconfactory.h"
#include "gtkimage.h"
#include "gtkimagemenuitem.h"
#include "gtklabel.h"
#include "gtkstock.h"
#include "gtkvbox.h"
#include "gtkintl.h"
Soeren Sandmann's avatar
Soeren Sandmann committed
34
#include "gtktoolbar.h"
35
#include "gtkiconfactory.h"
36
#include "gtkprivate.h"
37
#include "gtkalias.h"
38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

#include <string.h>

#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,
54
  PROP_ICON_NAME,
55
  PROP_ICON_WIDGET
56 57 58 59 60 61 62 63 64 65 66 67 68
};

static void gtk_tool_button_init          (GtkToolButton      *button,
					   GtkToolButtonClass *klass);
static void gtk_tool_button_class_init    (GtkToolButtonClass *klass);
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);
69 70
static void gtk_tool_button_property_notify (GObject          *object,
					     GParamSpec       *pspec);
71 72 73 74 75 76
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);
77 78
static void gtk_tool_button_style_set      (GtkWidget          *widget,
					    GtkStyle           *prev_style);
79 80 81 82 83 84

static void gtk_tool_button_construct_contents (GtkToolItem *tool_item);
      
static GObjectClass *parent_class = NULL;
static guint         toolbutton_signals[LAST_SIGNAL] = { 0 };

Matthias Clasen's avatar
Matthias Clasen committed
85 86
#define GTK_TOOL_BUTTON_GET_PRIVATE(obj)(G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_TOOL_BUTTON, GtkToolButtonPrivate))

87 88 89 90 91
struct _GtkToolButtonPrivate
{
  GtkWidget *button;

  gchar *stock_id;
92
  gchar *icon_name;
93 94 95 96 97 98 99
  gchar *label_text;
  GtkWidget *label_widget;
  GtkWidget *icon_widget;
  
  guint use_underline : 1;
};

100 101 102 103 104 105
GType
gtk_tool_button_get_type (void)
{
  static GtkType type = 0;

  if (!type)
Matthias Clasen's avatar
Matthias Clasen committed
106 107 108 109 110 111 112
    type = 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);
113 114 115 116 117 118 119
  return type;
}

static void
gtk_tool_button_class_init (GtkToolButtonClass *klass)
{
  GObjectClass *object_class;
120
  GtkWidgetClass *widget_class;
121 122 123 124 125
  GtkToolItemClass *tool_item_class;
  
  parent_class = g_type_class_peek_parent (klass);
  
  object_class = (GObjectClass *)klass;
126
  widget_class = (GtkWidgetClass *)klass;
127 128 129 130
  tool_item_class = (GtkToolItemClass *)klass;
  
  object_class->set_property = gtk_tool_button_set_property;
  object_class->get_property = gtk_tool_button_get_property;
131
  object_class->notify = gtk_tool_button_property_notify;
132 133
  object_class->finalize = gtk_tool_button_finalize;

134 135
  widget_class->style_set = gtk_tool_button_style_set;

136 137 138 139 140
  tool_item_class->create_menu_proxy = gtk_tool_button_create_menu_proxy;
  tool_item_class->toolbar_reconfigured = gtk_tool_button_toolbar_reconfigured;
  
  klass->button_type = GTK_TYPE_BUTTON;

141 142 143 144 145
  /* 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
146 147 148
   *            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.
149 150 151 152 153
   *
   *          - 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
154 155 156
   *            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.
157 158 159 160 161 162 163 164 165 166 167 168
   *
   *	      - 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
169 170
   *                      used in the overflow menu should be used as a
   *                      mnemonic.
171 172
   *
   *		In short: use_underline = TRUE means that the label text has
173 174
   *            the form "_Open" and the toolbar should take appropriate
   *            action.
175 176
   */

177 178 179
  g_object_class_install_property (object_class,
				   PROP_LABEL,
				   g_param_spec_string ("label",
180 181
							P_("Label"),
							P_("Text to show in the item."),
182
							NULL,
183
							GTK_PARAM_READWRITE));
184 185
  g_object_class_install_property (object_class,
				   PROP_USE_UNDERLINE,
186
				   g_param_spec_boolean ("use-underline",
187 188
							 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"),
189
							 FALSE,
190
							 GTK_PARAM_READWRITE));
191 192
  g_object_class_install_property (object_class,
				   PROP_LABEL_WIDGET,
193
				   g_param_spec_object ("label-widget",
194 195
							P_("Label widget"),
							P_("Widget to use as the item label"),
196
							GTK_TYPE_WIDGET,
197
							GTK_PARAM_READWRITE));
198 199
  g_object_class_install_property (object_class,
				   PROP_STOCK_ID,
200
				   g_param_spec_string ("stock-id",
201 202
							P_("Stock Id"),
							P_("The stock icon displayed on the item"),
203
							NULL,
204
							GTK_PARAM_READWRITE));
205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221

  /**
   * GtkToolButton:icon-name:
   * 
   * The name of the themed icon displayed on the item.
   * This property only has an effect if not overridden by "label", 
   * "icon_widget" or "stock_id" properties.
   *
   * 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));
222 223
  g_object_class_install_property (object_class,
				   PROP_ICON_WIDGET,
224
				   g_param_spec_object ("icon-widget",
225 226
							P_("Icon widget"),
							P_("Icon widget to display in the item"),
227
							GTK_TYPE_WIDGET,
228
							GTK_PARAM_READWRITE));
229

230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
  /**
   * GtkButton::icon-spacing:
   * 
   * 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,
							     0,
							     GTK_PARAM_READWRITE));

246 247 248 249 250 251 252
/**
 * 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.
 **/
253
  toolbutton_signals[CLICKED] =
Matthias Clasen's avatar
Matthias Clasen committed
254
    g_signal_new (I_("clicked"),
255
		  G_OBJECT_CLASS_TYPE (klass),
256
		  G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
257 258 259 260
		  G_STRUCT_OFFSET (GtkToolButtonClass, clicked),
		  NULL, NULL,
		  g_cclosure_marshal_VOID__VOID,
		  G_TYPE_NONE, 0);
261 262
  
  g_type_class_add_private (object_class, sizeof (GtkToolButtonPrivate));
263 264 265 266 267 268 269
}

static void
gtk_tool_button_init (GtkToolButton      *button,
		      GtkToolButtonClass *klass)
{
  GtkToolItem *toolitem = GTK_TOOL_ITEM (button);
270
  
271
  button->priv = GTK_TOOL_BUTTON_GET_PRIVATE (button);
272 273

  gtk_tool_item_set_homogeneous (toolitem, TRUE);
274 275

  /* create button */
276 277 278
  button->priv->button = g_object_new (klass->button_type, NULL);
  gtk_button_set_focus_on_click (GTK_BUTTON (button->priv->button), FALSE);
  g_signal_connect_object (button->priv->button, "clicked",
279 280
			   G_CALLBACK (button_clicked), button, 0);

281 282
  gtk_container_add (GTK_CONTAINER (button), button->priv->button);
  gtk_widget_show (button->priv->button);
283 284 285 286 287 288 289 290 291 292 293 294 295
}

static void
gtk_tool_button_construct_contents (GtkToolItem *tool_item)
{
  GtkToolButton *button = GTK_TOOL_BUTTON (tool_item);
  GtkWidget *label = NULL;
  GtkWidget *icon = NULL;
  GtkToolbarStyle style;
  gboolean need_label = FALSE;
  gboolean need_icon = FALSE;
  GtkIconSize icon_size;
  GtkWidget *box = NULL;
296 297 298 299 300
  guint icon_spacing;

  gtk_widget_style_get (GTK_WIDGET (tool_item), 
			"icon-spacing", &icon_spacing,
			NULL);
301

302
  if (button->priv->icon_widget && button->priv->icon_widget->parent)
303
    {
304 305
      gtk_container_remove (GTK_CONTAINER (button->priv->icon_widget->parent),
			    button->priv->icon_widget);
306 307
    }

308
  if (button->priv->label_widget && button->priv->label_widget->parent)
309
    {
310 311
      gtk_container_remove (GTK_CONTAINER (button->priv->label_widget->parent),
			    button->priv->label_widget);
312 313
    }

314
  if (GTK_BIN (button->priv->button)->child)
315
    {
316 317 318
      /* Note: we are not destroying the label_widget or icon_widget
       * here because they were removed from their containers above
       */
319
      gtk_widget_destroy (GTK_BIN (button->priv->button)->child);
320 321 322 323 324 325
    }

  style = gtk_tool_item_get_toolbar_style (GTK_TOOL_ITEM (button));
  
  if (style != GTK_TOOLBAR_TEXT)
    need_icon = TRUE;
326 327 328 329 330 331 332 333 334 335

  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)) ||
       gtk_tool_item_get_orientation (GTK_TOOL_ITEM (button)) == GTK_ORIENTATION_VERTICAL))
    {
      need_label = TRUE;
    }
336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351
  
  if (style == GTK_TOOLBAR_ICONS && button->priv->icon_widget == NULL &&
      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;
    }
352

353 354
  if (need_label)
    {
355
      if (button->priv->label_widget)
356
	{
357
	  label = button->priv->label_widget;
358 359 360 361
	}
      else
	{
	  GtkStockItem stock_item;
362
	  gboolean elide;
363 364
	  gchar *label_text;

365
	  if (button->priv->label_text)
366
	    {
367 368
	      label_text = button->priv->label_text;
	      elide = button->priv->use_underline;
369
	    }
370
	  else if (button->priv->stock_id && gtk_stock_lookup (button->priv->stock_id, &stock_item))
371 372 373 374
	    {
	      label_text = stock_item.label;
	      elide = TRUE;
	    }
375
	  else
376 377 378 379
	    {
	      label_text = "";
	      elide = FALSE;
	    }
380 381

	  if (elide)
Soeren Sandmann's avatar
Soeren Sandmann committed
382
	    label_text = _gtk_toolbar_elide_underscores (label_text);
383 384 385 386 387 388 389 390 391 392 393 394 395 396
	  else
	    label_text = g_strdup (label_text);

	  label = gtk_label_new (label_text);

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

  icon_size = gtk_tool_item_get_icon_size (GTK_TOOL_ITEM (button));
  if (need_icon)
    {
397
      if (button->priv->icon_widget)
398
	{
399
	  icon = button->priv->icon_widget;
400 401 402
	  
	  if (GTK_IS_IMAGE (icon))
	    {
403
	      g_object_set (button->priv->icon_widget,
404 405
			    "icon-size", icon_size,
			    NULL);
406 407
	    }
	}
408
      else if (button->priv->stock_id)
409
	{
410
	  icon = gtk_image_new_from_stock (button->priv->stock_id, icon_size);
411 412
	  gtk_widget_show (icon);
	}
413 414 415 416 417
      else if (button->priv->icon_name)
	{
	  icon = gtk_image_new_from_icon_name (button->priv->icon_name, icon_size);
	  gtk_widget_show (icon);
	}
418 419 420 421 422 423
    }

  switch (style)
    {
    case GTK_TOOLBAR_ICONS:
      if (icon)
424
	gtk_container_add (GTK_CONTAINER (button->priv->button), icon);
425 426 427
      break;

    case GTK_TOOLBAR_BOTH:
428
      box = gtk_vbox_new (FALSE, icon_spacing);
429 430
      if (icon)
	gtk_box_pack_start (GTK_BOX (box), icon, TRUE, TRUE, 0);
431
      gtk_box_pack_start (GTK_BOX (box), label, FALSE, TRUE, 0);
432
      gtk_container_add (GTK_CONTAINER (button->priv->button), box);
433 434 435
      break;

    case GTK_TOOLBAR_BOTH_HORIZ:
436
      box = gtk_hbox_new (FALSE, icon_spacing);
437 438
      if (icon)
	gtk_box_pack_start (GTK_BOX (box), icon, label? FALSE : TRUE, TRUE, 0);
439 440
      if (label)
	gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 0);
441
      gtk_container_add (GTK_CONTAINER (button->priv->button), box);
442 443 444
      break;

    case GTK_TOOLBAR_TEXT:
445
      gtk_container_add (GTK_CONTAINER (button->priv->button), label);
446 447 448 449 450 451
      break;
    }

  if (box)
    gtk_widget_show (box);

452
  gtk_button_set_relief (GTK_BUTTON (button->priv->button),
453 454
			 gtk_tool_item_get_relief_style (GTK_TOOL_ITEM (button)));

455 456
  gtk_tool_item_rebuild_menu (tool_item);
  
457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481
  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:
      gtk_tool_button_set_stock_id (button, g_value_get_string (value));
      break;
482 483 484
    case PROP_ICON_NAME:
      gtk_tool_button_set_icon_name (button, g_value_get_string (value));
      break;
485 486 487 488 489 490 491 492
    case PROP_ICON_WIDGET:
      gtk_tool_button_set_icon_widget (button, g_value_get_object (value));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}

493 494 495 496
static void
gtk_tool_button_property_notify (GObject          *object,
				 GParamSpec       *pspec)
{
497
  if (strcmp (pspec->name, "is-important") == 0)
498
    gtk_tool_button_construct_contents (GTK_TOOL_ITEM (object));
499 500 501

  if (parent_class->notify)
    parent_class->notify (object, pspec);
502 503
}

504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523
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:
524
      g_value_set_string (value, button->priv->stock_id);
525
      break;
526 527 528
    case PROP_ICON_NAME:
      g_value_set_string (value, button->priv->icon_name);
      break;
529
    case PROP_ICON_WIDGET:
530
      g_value_set_object (value, button->priv->icon_widget);
531 532 533 534 535 536 537 538 539 540 541
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}

static void
gtk_tool_button_finalize (GObject *object)
{
  GtkToolButton *button = GTK_TOOL_BUTTON (object);

542 543 544
  g_free (button->priv->stock_id);
  g_free (button->priv->icon_name);
  g_free (button->priv->label_text);
545 546

  if (button->priv->label_widget)
547
    g_object_unref (button->priv->label_widget);
548 549

  if (button->priv->icon_widget)
550
    g_object_unref (button->priv->icon_widget);
551
  
552 553 554
  parent_class->finalize (object);
}

555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580
static GtkWidget *
clone_image_menu_size (GtkImage *image, GtkSettings *settings)
{
  GtkImageType storage_type = gtk_image_get_storage_type (image);

  if (storage_type == GTK_IMAGE_STOCK)
    {
      gchar *stock_id;
      gtk_image_get_stock (image, &stock_id, NULL);
      return gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_MENU);
    }
  else if (storage_type == GTK_IMAGE_ICON_SET)
    {
      GtkIconSet *icon_set;
      gtk_image_get_icon_set (image, &icon_set, NULL);
      return gtk_image_new_from_icon_set (icon_set, GTK_ICON_SIZE_MENU);
    }
  else if (storage_type == GTK_IMAGE_PIXBUF)
    {
      gint width, height;
      
      if (settings &&
	  gtk_icon_size_lookup_for_settings (settings, GTK_ICON_SIZE_MENU,
					     &width, &height))
	{
	  GdkPixbuf *src_pixbuf, *dest_pixbuf;
581
	  GtkWidget *cloned_image;
582 583 584 585 586

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

587
	  cloned_image = gtk_image_new_from_pixbuf (dest_pixbuf);
Matthias Clasen's avatar
Matthias Clasen committed
588 589
	  g_object_unref (dest_pixbuf);

590
	  return cloned_image;
591 592 593 594 595 596
	}
    }

  return NULL;
}
      
597 598 599 600 601 602 603 604
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;
605
  const char *label;
606

607
  if (button->priv->label_widget && GTK_IS_LABEL (button->priv->label_widget))
608
    {
609 610
      label = gtk_label_get_label (GTK_LABEL (button->priv->label_widget));
      use_mnemonic = gtk_label_get_use_underline (GTK_LABEL (button->priv->label_widget));
611
    }
612
  else if (button->priv->label_text)
613
    {
614 615
      label = button->priv->label_text;
      use_mnemonic = button->priv->use_underline;
616
    }
617
  else if (button->priv->stock_id && gtk_stock_lookup (button->priv->stock_id, &stock_item))
618 619 620 621 622 623 624
    {
      label = stock_item.label;
    }
  else
    {
      label = "";
    }
625 626 627 628 629 630
  
  if (use_mnemonic)
    menu_item = gtk_image_menu_item_new_with_mnemonic (label);
  else
    menu_item = gtk_image_menu_item_new_with_label (label);

631
  if (button->priv->icon_widget && GTK_IS_IMAGE (button->priv->icon_widget))
632
    {
633
      menu_image = clone_image_menu_size (GTK_IMAGE (button->priv->icon_widget),
634
					  gtk_widget_get_settings (GTK_WIDGET (button)));
635
    }
636
  else if (button->priv->stock_id)
637
    {
638
      menu_image = gtk_image_new_from_stock (button->priv->stock_id, GTK_ICON_SIZE_MENU);
639 640 641 642 643 644 645 646
    }

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

  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),
647
							      G_OBJECT (GTK_TOOL_BUTTON (button)->priv->button)),
648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667
				  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)
{
  g_signal_emit_by_name (button, "clicked");
}

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

668 669 670 671 672 673 674
static void
gtk_tool_button_style_set (GtkWidget *widget,
			   GtkStyle  *prev_style)
{
  gtk_tool_button_construct_contents (GTK_TOOL_ITEM (widget));
}

675 676 677 678 679 680 681 682 683 684 685 686 687 688
/**
 * 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.
 * 
 * Return value: A new #GtkToolButton
 * 
 * Since: 2.4
 **/
689 690 691 692 693 694 695 696
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,
697
			 "stock-id", stock_id,
698 699 700 701 702
			 NULL);

  return GTK_TOOL_ITEM (button);
}

703 704 705 706 707 708 709 710 711 712 713 714
/**
 * gtk_tool_button_new:
 * @label: a string that will be used as label, or %NULL
 * @icon_widget: a widget that will be used as icon widget, or %NULL
 * 
 * Creates a new %GtkToolButton using @icon_widget as icon and @label as
 * label.
 * 
 * Return value: A new #GtkToolButton
 * 
 * Since: 2.4
 **/
715
GtkToolItem *
716 717
gtk_tool_button_new (GtkWidget	 *icon_widget,
		     const gchar *label)
718 719
{
  GtkToolButton *button;
Soeren Sandmann's avatar
Soeren Sandmann committed
720

721 722
  button = g_object_new (GTK_TYPE_TOOL_BUTTON,
			 NULL);
Soeren Sandmann's avatar
Soeren Sandmann committed
723 724 725 726 727 728
  
  if (label)
    gtk_tool_button_set_label (button, label);

  if (icon_widget)
    gtk_tool_button_set_icon_widget (button, icon_widget);
729 730 731 732

  return GTK_TOOL_ITEM (button);  
}

733 734 735 736 737 738 739 740 741 742 743 744 745
/**
 * gtk_tool_button_set_label:
 * @button: a #GtkToolButton
 * @label: a string that will be used as label, or %NULL.
 * 
 * Sets @label as the label used for the tool button. The "label" property
 * only has an effect if not overridden by a non-%NULL "label_widget" property.
 * If both the "label_widget" and "label" properties are %NULL, the label
 * is determined by the "stock_id" property. If the "stock_id" property is also
 * %NULL, @button will not have a label.
 * 
 * Since: 2.4
 **/
746 747 748 749 750 751 752 753
void
gtk_tool_button_set_label (GtkToolButton *button,
			   const gchar   *label)
{
  gchar *old_label;
  
  g_return_if_fail (GTK_IS_TOOL_BUTTON (button));

754
  old_label = button->priv->label_text;
755

756
  button->priv->label_text = g_strdup (label);
757 758 759 760 761 762 763 764
  gtk_tool_button_construct_contents (GTK_TOOL_ITEM (button));
      
  g_object_notify (G_OBJECT (button), "label");

  if (old_label)
    g_free (old_label);
}

765 766 767 768 769 770 771 772 773 774 775 776
/**
 * gtk_tool_button_get_label:
 * @button: a #GtkToolButton
 * 
 * Returns the label used by the tool button, or %NULL if the tool button
 * doesn't have a label. or uses a the label from a stock item. The returned
 * string is owned by GTK+, and must not be modified or freed.
 * 
 * Return value: The label, or %NULL
 * 
 * Since: 2.4
 **/
777 778 779 780 781
G_CONST_RETURN gchar *
gtk_tool_button_get_label (GtkToolButton *button)
{
  g_return_val_if_fail (GTK_IS_TOOL_BUTTON (button), NULL);

782
  return button->priv->label_text;
783 784
}

785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800
/**
 * gtk_tool_button_set_use_underline:
 * @button: a #GtkToolButton
 * @use_underline: whether the button label has the form "_Open"
 *
 * 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
 * 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
 * menu will have an underlined 'O'.
 * 
 * Labels shown on tool buttons never have mnemonics on them; this property
 * only affects the menu item on the overflow menu.
 * 
 * Since: 2.4
 **/
801 802 803 804 805 806 807 808
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;

809
  if (use_underline != button->priv->use_underline)
810
    {
811
      button->priv->use_underline = use_underline;
812 813 814

      gtk_tool_button_construct_contents (GTK_TOOL_ITEM (button));

815
      g_object_notify (G_OBJECT (button), "use-underline");
816 817 818
    }
}

819 820 821 822 823 824 825 826 827 828 829 830
/**
 * 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().
 * 
 * Return value: %TRUE if underscores in the label property are used as
 * mnemonics on menu items on the overflow menu.
 * 
 * Since: 2.4
 **/
831 832 833 834 835
gboolean
gtk_tool_button_get_use_underline (GtkToolButton *button)
{
  g_return_val_if_fail (GTK_IS_TOOL_BUTTON (button), FALSE);

836
  return button->priv->use_underline;
837 838
}

839 840 841 842 843 844 845 846 847 848 849
/**
 * gtk_tool_button_set_stock_id:
 * @button: a #GtkToolButton
 * @stock_id: a name of a stock item, or %NULL
 * 
 * Sets the name of the stock item. See gtk_tool_button_new_from_stock().
 * The stock_id property only has an effect if not
 * overridden by non-%NULL "label" and "icon_widget" properties.
 * 
 * Since: 2.4
 **/
850 851 852 853 854 855 856 857
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));

858
  old_stock_id = button->priv->stock_id;
859

860
  button->priv->stock_id = g_strdup (stock_id);
861 862
  gtk_tool_button_construct_contents (GTK_TOOL_ITEM (button));
  
863
  g_object_notify (G_OBJECT (button), "stock-id");
864 865 866 867

  g_free (old_stock_id);
}

868 869 870 871 872 873 874 875 876 877 878
/**
 * 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.
 * 
 * Return value: the name of the stock item for @button.
 * 
 * Since: 2.4
 **/
879 880 881 882 883
G_CONST_RETURN gchar *
gtk_tool_button_get_stock_id (GtkToolButton *button)
{
  g_return_val_if_fail (GTK_IS_TOOL_BUTTON (button), NULL);

884
  return button->priv->stock_id;
885 886
}

887 888 889
/**
 * gtk_tool_button_set_icon_name
 * @button: a #GtkToolButton
890
 * @icon_name: the name of the themed icon
891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937
 * 
 * Sets the icon for the tool button from a named themed icon.
 * See the docs for #GtkIconTheme for more details.
 * The "icon_name" property only has an effect if not
 * overridden by non-%NULL "label", "icon_widget" and "stock_id"
 * properties.
 * 
 * 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);
  gtk_tool_button_construct_contents (GTK_TOOL_ITEM (button));

  g_object_notify (G_OBJECT (button), "icon-name");

  g_free (old_icon_name);
}

/**
 * gtk_tool_button_get_icon_name
 * @button: a #GtkToolButton
 * 
 * Returns the name of the themed icon for the tool button,
 * see gtk_tool_button_set_icon_name().
 *
 * Returns: the icon name or %NULL if the tool button has
 * no themed icon
 * 
 * Since: 2.8
 **/
G_CONST_RETURN gchar*
gtk_tool_button_get_icon_name (GtkToolButton *button)
{
  g_return_val_if_fail (GTK_IS_TOOL_BUTTON (button), NULL);

  return button->priv->icon_name;
}

938 939 940 941 942 943 944 945 946 947 948
/**
 * gtk_tool_button_set_icon_widget:
 * @button: a #GtkToolButton
 * @icon_widget: the widget used as icon, or %NULL
 * 
 * Sets @icon as the widget used as icon on @button. If @icon_widget is
 * %NULL the icon is determined by the "stock_id" property. If the
 * "stock_id" property is also %NULL, @button will not have an icon.
 * 
 * Since: 2.4
 **/
949 950
void
gtk_tool_button_set_icon_widget (GtkToolButton *button,
951
				 GtkWidget     *icon_widget)
952 953
{
  g_return_if_fail (GTK_IS_TOOL_BUTTON (button));
954
  g_return_if_fail (icon_widget == NULL || GTK_IS_WIDGET (icon_widget));
955

956
  if (icon_widget != button->priv->icon_widget)
957
    {
958
      if (button->priv->icon_widget)
959 960 961 962 963 964
	{
	  if (button->priv->icon_widget->parent)
	    {
	      gtk_container_remove (GTK_CONTAINER (button->priv->icon_widget->parent),
				    button->priv->icon_widget);
	    }
965

966
	  g_object_unref (button->priv->icon_widget);
967 968
	}
      
969
      if (icon_widget)
970
	{
971
	  g_object_ref_sink (icon_widget);
972 973
	}

974
      button->priv->icon_widget = icon_widget;
975 976 977

      gtk_tool_button_construct_contents (GTK_TOOL_ITEM (button));
      
978
      g_object_notify (G_OBJECT (button), "icon-widget");
979 980 981
    }
}

982 983 984 985 986 987 988 989 990 991 992 993 994
/**
 * gtk_tool_button_set_label_widget:
 * @button: a #GtkToolButton
 * @label_widget: the widget used as label, or %NULL
 * 
 * Sets @label_widget as the widget that will be used as the label
 * for @button. If @label_widget is %NULL the "label" property is used
 * as label. If "label" is also %NULL, the label in the stock item
 * determined by the "stock_id" property is used as label. If
 * "stock_id" is also %NULL, @button does not have a label.
 * 
 * Since: 2.4
 **/
995 996 997 998 999 1000 1001
void
gtk_tool_button_set_label_widget (GtkToolButton *button,
				  GtkWidget     *label_widget)
{
  g_return_if_fail (GTK_IS_TOOL_BUTTON (button));
  g_return_if_fail (label_widget == NULL || GTK_IS_WIDGET (label_widget));

1002
  if (label_widget != button->priv->label_widget)
1003
    {
1004
      if (button->priv->label_widget)
1005
	{
1006
	  if (button->priv->label_widget->parent)
1007
	    {
1008 1009
	      gtk_container_remove (GTK_CONTAINER (button->priv->label_widget->parent),
				    button->priv->label_widget);
1010 1011 1012 1013 1014
	    }
	  
	  g_object_unref (button->priv->label_widget);
	}
      
1015 1016
      if (label_widget)
	{
1017
	  g_object_ref_sink (label_widget);
1018 1019
	}

1020
      button->priv->label_widget = label_widget;
1021 1022 1023

      gtk_tool_button_construct_contents (GTK_TOOL_ITEM (button));
      
1024
      g_object_notify (G_OBJECT (button), "label-widget");
1025 1026 1027
    }
}

1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038
/**
 * gtk_tool_button_get_label_widget:
 * @button: a #GtkToolButton
 * 
 * Returns the widget used as label on @button. See
 * gtk_tool_button_set_label_widget().
 * 
 * Return value: The widget used as label on @button, or %NULL.
 * 
 * Since: 2.4
 **/
1039 1040 1041 1042 1043
GtkWidget *
gtk_tool_button_get_label_widget (GtkToolButton *button)
{
  g_return_val_if_fail (GTK_IS_TOOL_BUTTON (button), NULL);

1044
  return button->priv->label_widget;
1045 1046
}

1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
/**
 * gtk_tool_button_get_icon_widget:
 * @button: a #GtkToolButton
 * 
 * Return the widget used as icon widget on @button. See
 * gtk_tool_button_set_icon_widget().
 * 
 * Return value: The widget used as icon on @button, or %NULL.
 * 
 * Since: 2.4
 **/
1058 1059 1060
GtkWidget *
gtk_tool_button_get_icon_widget (GtkToolButton *button)
{
1061
  g_return_val_if_fail (GTK_IS_TOOL_BUTTON (button), NULL);
1062

1063 1064 1065 1066 1067 1068 1069 1070 1071
  return button->priv->icon_widget;
}

GtkWidget *
_gtk_tool_button_get_button (GtkToolButton *button)
{
  g_return_val_if_fail (GTK_IS_TOOL_BUTTON (button), NULL);

  return button->priv->button;
1072
}
1073

1074

1075 1076
#define __GTK_TOOL_BUTTON_C__
#include "gtkaliasdef.c"