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

   1 /* gtktoolbutton.c
   2  *
   3  * Copyright (C) 2002 Anders Carlsson <andersca@gnome.org>
   4  * Copyright (C) 2002 James Henstridge <james@daa.com.au>
   5  * Copyright (C) 2003 Soeren Sandmann <sandmann@daimi.au.dk>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 #include <config.h>
  24 #include "gtktoolbutton.h"
  25 #include "gtkbutton.h"
  26 #include "gtkhbox.h"
  27 #include "gtkiconfactory.h"
  28 #include "gtkimage.h"
  29 #include "gtkimagemenuitem.h"
  30 #include "gtklabel.h"
  31 #include "gtkstock.h"
  32 #include "gtkvbox.h"
  33 #include "gtkintl.h"
  34 #include "gtktoolbar.h"
  35 #include "gtkiconfactory.h"
  36
  37 #include <string.h>
  38
  39 #define MENU_ID "gtk-tool-button-menu-id"
  40
  41 enum {
  42   CLICKED,
  43   LAST_SIGNAL
  44 };
  45
  46 enum {
  47   PROP_0,
  48   PROP_LABEL,
  49   PROP_USE_UNDERLINE,
  50   PROP_LABEL_WIDGET,
  51   PROP_STOCK_ID,
  52   PROP_ICON_WIDGET,
  53 };
  54
  55 static void gtk_tool_button_init          (GtkToolButton      *button,
  56                                            GtkToolButtonClass *klass);
  57 static void gtk_tool_button_class_init    (GtkToolButtonClass *klass);
  58 static void gtk_tool_button_set_property  (GObject            *object,
  59                                            guint               prop_id,
  60                                            const GValue       *value,
  61                                            GParamSpec         *pspec);
  62 static void gtk_tool_button_get_property  (GObject            *object,
  63                                            guint               prop_id,
  64                                            GValue             *value,
  65                                            GParamSpec         *pspec);
  66 static void gtk_tool_button_property_notify (GObject          *object,
  67                                              GParamSpec       *pspec);
  68 static void gtk_tool_button_finalize      (GObject            *object);
  69
  70 static void gtk_tool_button_toolbar_reconfigured (GtkToolItem *tool_item);
  71 static gboolean   gtk_tool_button_create_menu_proxy (GtkToolItem     *item);
  72 static void       button_clicked                    (GtkWidget       *widget,
  73                                                      GtkToolButton   *button);
  74
  75 static void gtk_tool_button_construct_contents (GtkToolItem *tool_item);
  76
  77 static GObjectClass *parent_class = NULL;
  78 static guint         toolbutton_signals[LAST_SIGNAL] = { 0 };
  79
  80 #define GTK_TOOL_BUTTON_GET_PRIVATE(obj)(G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_TOOL_BUTTON, GtkToolButtonPrivate))
  81
  82 struct _GtkToolButtonPrivate
  83 {
  84   GtkWidget *button;
  85
  86   gchar *stock_id;
  87   gchar *label_text;
  88   GtkWidget *label_widget;
  89   GtkWidget *icon_widget;
  90
  91   guint use_underline : 1;
  92 };
  93
  94 GType
  95 gtk_tool_button_get_type (void)
  96 {
  97   static GtkType type = 0;
  98
  99   if (!type)
 100     {
 101       static const GTypeInfo type_info =
 102         {
 103           sizeof (GtkToolButtonClass),
 104           (GBaseInitFunc) NULL,
 105           (GBaseFinalizeFunc) NULL,
 106           (GClassInitFunc) gtk_tool_button_class_init,
 107           (GClassFinalizeFunc) NULL,
 108           NULL,
 109           sizeof (GtkToolButton),
 110           0, /* n_preallocs */
 111           (GInstanceInitFunc) gtk_tool_button_init,
 112         };
 113
 114       type = g_type_register_static (GTK_TYPE_TOOL_ITEM,
 115                                      "GtkToolButton",
 116                                      &type_info, 0);
 117     }
 118   return type;
 119 }
 120
 121 static void
 122 gtk_tool_button_class_init (GtkToolButtonClass *klass)
 123 {
 124   GObjectClass *object_class;
 125   GtkWidgetClass *widget_class;
 126   GtkToolItemClass *tool_item_class;
 127
 128   parent_class = g_type_class_peek_parent (klass);
 129
 130   object_class = (GObjectClass *)klass;
 131   widget_class = (GtkWidgetClass *)klass;
 132   tool_item_class = (GtkToolItemClass *)klass;
 133
 134   object_class->set_property = gtk_tool_button_set_property;
 135   object_class->get_property = gtk_tool_button_get_property;
 136   object_class->notify = gtk_tool_button_property_notify;
 137   object_class->finalize = gtk_tool_button_finalize;
 138
 139   tool_item_class->create_menu_proxy = gtk_tool_button_create_menu_proxy;
 140   tool_item_class->toolbar_reconfigured = gtk_tool_button_toolbar_reconfigured;
 141
 142   klass->button_type = GTK_TYPE_BUTTON;
 143
 144   /* Properties are interpreted like this:
 145    *
 146    *          - if the tool button has an icon_widget, then that widget
 147    *            will be used as the icon. Otherwise, if the tool button
 148    *            has a stock id, the corresponding stock icon will be
 149    *            used. Otherwise, the tool button will not have an icon.
 150    *
 151    *          - if the tool button has a label_widget then that widget
 152    *            will be used as the label. Otherwise, if the tool button
 153    *            has a label text, that text will be used as label. Otherwise,
 154    *            if the toolbutton has a stock id, the corresponding text
 155    *            will be used as label. Otherwise, the toolbutton will
 156    *            have an empty label.
 157    *
 158    *          - The use_underline property only has an effect when the label
 159    *            on the toolbutton comes from the label property (ie. not from
 160    *            label_widget or from stock_id).
 161    *
 162    *            In that case, if use_underline is set,
 163    *
 164    *                    - underscores are removed from the label text before
 165    *                      the label is shown on the toolbutton unless the
 166    *                      underscore is followed by another underscore
 167    *
 168    *                    - an underscore indicates that the next character when
 169    *                      used in the overflow menu should be used as a
 170    *                      mnemonic.
 171    *
 172    *            In short: use_underline = TRUE means that the label text has
 173    *            the form "_Open" and the toolbar should take appropriate
 174    *            action.
 175    */
 176
 177   g_object_class_install_property (object_class,
 178                                    PROP_LABEL,
 179                                    g_param_spec_string ("label",
 180                                                         P_("Label"),
 181                                                         P_("Text to show in the item."),
 182                                                         NULL,
 183                                                         G_PARAM_READWRITE));
 184   g_object_class_install_property (object_class,
 185                                    PROP_USE_UNDERLINE,
 186                                    g_param_spec_boolean ("use_underline",
 187                                                          P_("Use underline"),
 188                                                          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                                                          G_PARAM_READWRITE));
 191   g_object_class_install_property (object_class,
 192                                    PROP_LABEL_WIDGET,
 193                                    g_param_spec_object ("label_widget",
 194                                                         P_("Label widget"),
 195                                                         P_("Widget to use as the item label"),
 196                                                         GTK_TYPE_WIDGET,
 197                                                         G_PARAM_READWRITE));
 198   g_object_class_install_property (object_class,
 199                                    PROP_STOCK_ID,
 200                                    g_param_spec_string ("stock_id",
 201                                                         P_("Stock Id"),
 202                                                         P_("The stock icon displayed on the item"),
 203                                                         NULL,
 204                                                         G_PARAM_READWRITE));
 205   g_object_class_install_property (object_class,
 206                                    PROP_ICON_WIDGET,
 207                                    g_param_spec_object ("icon_widget",
 208                                                         P_("Icon widget"),
 209                                                         P_("Icon widget to display in the item"),
 210                                                         GTK_TYPE_WIDGET,
 211                                                         G_PARAM_READWRITE));
 212
 213 /**
 214  * GtkToolButton::clicked:
 215  * @toolbutton: the object that emitted the signal
 216  *
 217  * This signal is emitted when the tool button is clicked with the mouse
 218  * or activated with the keyboard.
 219  **/
 220   toolbutton_signals[CLICKED] =
 221     g_signal_new ("clicked",
 222                   G_OBJECT_CLASS_TYPE (klass),
 223                   G_SIGNAL_RUN_FIRST,
 224                   G_STRUCT_OFFSET (GtkToolButtonClass, clicked),
 225                   NULL, NULL,
 226                   g_cclosure_marshal_VOID__VOID,
 227                   G_TYPE_NONE, 0);
 228
 229   g_type_class_add_private (object_class, sizeof (GtkToolButtonPrivate));
 230 }
 231
 232 static void
 233 gtk_tool_button_init (GtkToolButton      *button,
 234                       GtkToolButtonClass *klass)
 235 {
 236   GtkToolItem *toolitem = GTK_TOOL_ITEM (button);
 237
 238   button->priv = GTK_TOOL_BUTTON_GET_PRIVATE (button);
 239
 240   gtk_tool_item_set_homogeneous (toolitem, TRUE);
 241
 242   /* create button */
 243   button->priv->button = g_object_new (klass->button_type, NULL);
 244   gtk_button_set_focus_on_click (GTK_BUTTON (button->priv->button), FALSE);
 245   g_signal_connect_object (button->priv->button, "clicked",
 246                            G_CALLBACK (button_clicked), button, 0);
 247
 248   gtk_container_add (GTK_CONTAINER (button), button->priv->button);
 249   gtk_widget_show (button->priv->button);
 250 }
 251
 252 static void
 253 gtk_tool_button_construct_contents (GtkToolItem *tool_item)
 254 {
 255   GtkToolButton *button = GTK_TOOL_BUTTON (tool_item);
 256   GtkWidget *label = NULL;
 257   GtkWidget *icon = NULL;
 258   GtkToolbarStyle style;
 259   gboolean need_label = FALSE;
 260   gboolean need_icon = FALSE;
 261   GtkIconSize icon_size;
 262   GtkWidget *box = NULL;
 263
 264   if (gtk_tool_item_get_proxy_menu_item (tool_item, MENU_ID))
 265     {
 266       /* Remove item, so it will be recreated on the next
 267        * create_proxy_menu_item()
 268        */
 269       gtk_tool_item_set_proxy_menu_item (tool_item, MENU_ID, NULL);
 270     }
 271
 272   if (button->priv->icon_widget && button->priv->icon_widget->parent)
 273     {
 274       gtk_container_remove (GTK_CONTAINER (button->priv->icon_widget->parent),
 275                             button->priv->icon_widget);
 276     }
 277
 278   if (button->priv->label_widget && button->priv->label_widget->parent)
 279     {
 280       gtk_container_remove (GTK_CONTAINER (button->priv->label_widget->parent),
 281                             button->priv->label_widget);
 282     }
 283
 284   if (GTK_BIN (button->priv->button)->child)
 285     {
 286       /* Note: we are not destroying the label_widget or icon_widget
 287        * here because they were removed from their containers above
 288        */
 289       gtk_widget_destroy (GTK_BIN (button->priv->button)->child);
 290     }
 291
 292   style = gtk_tool_item_get_toolbar_style (GTK_TOOL_ITEM (button));
 293
 294   if (style != GTK_TOOLBAR_TEXT)
 295     need_icon = TRUE;
 296
 297   if (style != GTK_TOOLBAR_ICONS && style != GTK_TOOLBAR_BOTH_HORIZ)
 298     need_label = TRUE;
 299
 300   if (style == GTK_TOOLBAR_BOTH_HORIZ &&
 301       (gtk_tool_item_get_is_important (GTK_TOOL_ITEM (button)) ||
 302        gtk_tool_item_get_orientation (GTK_TOOL_ITEM (button)) == GTK_ORIENTATION_VERTICAL))
 303     {
 304       need_label = TRUE;
 305     }
 306
 307   if (style != GTK_TOOLBAR_ICONS &&
 308       ((style != GTK_TOOLBAR_BOTH_HORIZ ||
 309         gtk_tool_item_get_is_important (GTK_TOOL_ITEM (button)))))
 310     need_label = TRUE;
 311
 312   if (need_label)
 313     {
 314       if (button->priv->label_widget)
 315         {
 316           label = button->priv->label_widget;
 317         }
 318       else
 319         {
 320           GtkStockItem stock_item;
 321           gboolean elide;
 322           gchar *label_text;
 323
 324           if (button->priv->label_text)
 325             {
 326               label_text = button->priv->label_text;
 327               elide = button->priv->use_underline;
 328             }
 329           else if (button->priv->stock_id && gtk_stock_lookup (button->priv->stock_id, &stock_item))
 330             {
 331               label_text = stock_item.label;
 332               elide = TRUE;
 333             }
 334           else
 335             {
 336               label_text = "";
 337               elide = FALSE;
 338             }
 339
 340           if (elide)
 341             label_text = _gtk_toolbar_elide_underscores (label_text);
 342           else
 343             label_text = g_strdup (label_text);
 344
 345           label = gtk_label_new (label_text);
 346
 347           g_free (label_text);
 348
 349           gtk_widget_show (label);
 350         }
 351     }
 352
 353   icon_size = gtk_tool_item_get_icon_size (GTK_TOOL_ITEM (button));
 354   if (need_icon)
 355     {
 356       if (button->priv->icon_widget)
 357         {
 358           icon = button->priv->icon_widget;
 359
 360           if (GTK_IS_IMAGE (icon))
 361             {
 362               g_object_set (G_OBJECT (button->priv->icon_widget),
 363                             "icon-size", icon_size,
 364                             NULL);
 365             }
 366         }
 367       else if (button->priv->stock_id)
 368         {
 369           icon = gtk_image_new_from_stock (button->priv->stock_id, icon_size);
 370           gtk_widget_show (icon);
 371         }
 372     }
 373
 374   switch (style)
 375     {
 376     case GTK_TOOLBAR_ICONS:
 377       if (icon)
 378         gtk_container_add (GTK_CONTAINER (button->priv->button), icon);
 379       break;
 380
 381     case GTK_TOOLBAR_BOTH:
 382       box = gtk_vbox_new (FALSE, 0);
 383       if (icon)
 384         gtk_box_pack_start (GTK_BOX (box), icon, TRUE, TRUE, 0);
 385       gtk_box_pack_start (GTK_BOX (box), label, FALSE, TRUE, 0);
 386       gtk_container_add (GTK_CONTAINER (button->priv->button), box);
 387       break;
 388
 389     case GTK_TOOLBAR_BOTH_HORIZ:
 390       box = gtk_hbox_new (FALSE, 0);
 391       if (icon)
 392         gtk_box_pack_start (GTK_BOX (box), icon, label? FALSE : TRUE, TRUE, 0);
 393       if (label)
 394         gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 0);
 395       gtk_container_add (GTK_CONTAINER (button->priv->button), box);
 396       break;
 397
 398     case GTK_TOOLBAR_TEXT:
 399       gtk_container_add (GTK_CONTAINER (button->priv->button), label);
 400       break;
 401     }
 402
 403   if (box)
 404     gtk_widget_show (box);
 405
 406   gtk_button_set_relief (GTK_BUTTON (button->priv->button),
 407                          gtk_tool_item_get_relief_style (GTK_TOOL_ITEM (button)));
 408
 409   gtk_widget_queue_resize (GTK_WIDGET (button));
 410 }
 411
 412 static void
 413 gtk_tool_button_set_property (GObject         *object,
 414                               guint            prop_id,
 415                               const GValue    *value,
 416                               GParamSpec      *pspec)
 417 {
 418   GtkToolButton *button = GTK_TOOL_BUTTON (object);
 419
 420   switch (prop_id)
 421     {
 422     case PROP_LABEL:
 423       gtk_tool_button_set_label (button, g_value_get_string (value));
 424       break;
 425     case PROP_USE_UNDERLINE:
 426       gtk_tool_button_set_use_underline (button, g_value_get_boolean (value));
 427       break;
 428     case PROP_LABEL_WIDGET:
 429       gtk_tool_button_set_label_widget (button, g_value_get_object (value));
 430       break;
 431     case PROP_STOCK_ID:
 432       gtk_tool_button_set_stock_id (button, g_value_get_string (value));
 433       break;
 434     case PROP_ICON_WIDGET:
 435       gtk_tool_button_set_icon_widget (button, g_value_get_object (value));
 436       break;
 437     default:
 438       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 439     }
 440 }
 441
 442 static void
 443 gtk_tool_button_property_notify (GObject          *object,
 444                                  GParamSpec       *pspec)
 445 {
 446   if (strcmp (pspec->name, "is-important") == 0)
 447     gtk_tool_button_construct_contents (GTK_TOOL_ITEM (object));
 448
 449   if (parent_class->notify)
 450     parent_class->notify (object, pspec);
 451 }
 452
 453 static void
 454 gtk_tool_button_get_property (GObject         *object,
 455                               guint            prop_id,
 456                               GValue          *value,
 457                               GParamSpec      *pspec)
 458 {
 459   GtkToolButton *button = GTK_TOOL_BUTTON (object);
 460
 461   switch (prop_id)
 462     {
 463     case PROP_LABEL:
 464       g_value_set_string (value, gtk_tool_button_get_label (button));
 465       break;
 466     case PROP_LABEL_WIDGET:
 467       g_value_set_object (value, gtk_tool_button_get_label_widget (button));
 468       break;
 469     case PROP_USE_UNDERLINE:
 470       g_value_set_boolean (value, gtk_tool_button_get_use_underline (button));
 471       break;
 472     case PROP_STOCK_ID:
 473       g_value_set_string (value, button->priv->stock_id);
 474       break;
 475     case PROP_ICON_WIDGET:
 476       g_value_set_object (value, button->priv->icon_widget);
 477       break;
 478     default:
 479       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 480     }
 481 }
 482
 483 static void
 484 gtk_tool_button_finalize (GObject *object)
 485 {
 486   GtkToolButton *button = GTK_TOOL_BUTTON (object);
 487
 488   if (button->priv->stock_id)
 489     g_free (button->priv->stock_id);
 490
 491   if (button->priv->label_text)
 492     g_free (button->priv->label_text);
 493
 494   if (button->priv->label_widget)
 495     g_object_unref (G_OBJECT (button->priv->label_widget));
 496
 497   if (button->priv->icon_widget)
 498     g_object_unref (G_OBJECT (button->priv->icon_widget));
 499
 500   parent_class->finalize (object);
 501 }
 502
 503 static GtkWidget *
 504 clone_image_menu_size (GtkImage *image, GtkSettings *settings)
 505 {
 506   GtkImageType storage_type = gtk_image_get_storage_type (image);
 507
 508   if (storage_type == GTK_IMAGE_STOCK)
 509     {
 510       gchar *stock_id;
 511       gtk_image_get_stock (image, &stock_id, NULL);
 512       return gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_MENU);
 513     }
 514   else if (storage_type == GTK_IMAGE_ICON_SET)
 515     {
 516       GtkIconSet *icon_set;
 517       gtk_image_get_icon_set (image, &icon_set, NULL);
 518       return gtk_image_new_from_icon_set (icon_set, GTK_ICON_SIZE_MENU);
 519     }
 520   else if (storage_type == GTK_IMAGE_PIXBUF)
 521     {
 522       gint width, height;
 523
 524       if (settings &&
 525           gtk_icon_size_lookup_for_settings (settings, GTK_ICON_SIZE_MENU,
 526                                              &width, &height))
 527         {
 528           GdkPixbuf *src_pixbuf, *dest_pixbuf;
 529
 530           src_pixbuf = gtk_image_get_pixbuf (image);
 531           dest_pixbuf = gdk_pixbuf_scale_simple (src_pixbuf, width, height,
 532                                                  GDK_INTERP_BILINEAR);
 533
 534           return gtk_image_new_from_pixbuf (dest_pixbuf);
 535         }
 536     }
 537
 538   return NULL;
 539 }
 540
 541 static gboolean
 542 gtk_tool_button_create_menu_proxy (GtkToolItem *item)
 543 {
 544   GtkToolButton *button = GTK_TOOL_BUTTON (item);
 545   GtkWidget *menu_item;
 546   GtkWidget *menu_image = NULL;
 547   GtkStockItem stock_item;
 548   gboolean use_mnemonic = TRUE;
 549   const char *label;
 550
 551   if (button->priv->label_widget && GTK_IS_LABEL (button->priv->label_widget))
 552     {
 553       label = gtk_label_get_label (GTK_LABEL (button->priv->label_widget));
 554       use_mnemonic = gtk_label_get_use_underline (GTK_LABEL (button->priv->label_widget));
 555     }
 556   else if (button->priv->label_text)
 557     {
 558       label = button->priv->label_text;
 559       use_mnemonic = button->priv->use_underline;
 560     }
 561   else if (button->priv->stock_id && gtk_stock_lookup (button->priv->stock_id, &stock_item))
 562     {
 563       label = stock_item.label;
 564     }
 565   else
 566     {
 567       label = "";
 568     }
 569
 570   if (use_mnemonic)
 571     menu_item = gtk_image_menu_item_new_with_mnemonic (label);
 572   else
 573     menu_item = gtk_image_menu_item_new_with_label (label);
 574
 575   if (button->priv->icon_widget && GTK_IS_IMAGE (button->priv->icon_widget))
 576     {
 577       menu_image = clone_image_menu_size (GTK_IMAGE (button->priv->icon_widget),
 578                                           gtk_widget_get_settings (GTK_WIDGET (button)));
 579     }
 580   else if (button->priv->stock_id)
 581     {
 582       menu_image = gtk_image_new_from_stock (button->priv->stock_id, GTK_ICON_SIZE_MENU);
 583     }
 584
 585   if (menu_image)
 586     gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), menu_image);
 587
 588   g_signal_connect_closure_by_id (menu_item,
 589                                   g_signal_lookup ("activate", G_OBJECT_TYPE (menu_item)), 0,
 590                                   g_cclosure_new_object_swap (G_CALLBACK (gtk_button_clicked),
 591                                                               G_OBJECT (GTK_TOOL_BUTTON (button)->priv->button)),
 592                                   FALSE);
 593
 594   gtk_tool_item_set_proxy_menu_item (GTK_TOOL_ITEM (button), MENU_ID, menu_item);
 595
 596   return TRUE;
 597 }
 598
 599 static void
 600 button_clicked (GtkWidget     *widget,
 601                 GtkToolButton *button)
 602 {
 603   g_signal_emit_by_name (button, "clicked");
 604 }
 605
 606 static void
 607 gtk_tool_button_toolbar_reconfigured (GtkToolItem *tool_item)
 608 {
 609   gtk_tool_button_construct_contents (tool_item);
 610 }
 611
 612 /**
 613  * gtk_tool_button_new_from_stock:
 614  * @stock_id: the name of the stock item
 615  *
 616  * Creates a new #GtkToolButton containing the image and text from a
 617  * stock item. Some stock ids have preprocessor macros like #GTK_STOCK_OK
 618  * and #GTK_STOCK_APPLY.
 619  *
 620  * It is an error if @stock_id is not a name of a stock item.
 621  *
 622  * Return value: A new #GtkToolButton
 623  *
 624  * Since: 2.4
 625  **/
 626 GtkToolItem *
 627 gtk_tool_button_new_from_stock (const gchar *stock_id)
 628 {
 629   GtkToolButton *button;
 630
 631   g_return_val_if_fail (stock_id != NULL, NULL);
 632
 633   button = g_object_new (GTK_TYPE_TOOL_BUTTON,
 634                          "stock_id", stock_id,
 635                          NULL);
 636
 637   return GTK_TOOL_ITEM (button);
 638 }
 639
 640 /**
 641  * gtk_tool_button_new:
 642  * @label: a string that will be used as label, or %NULL
 643  * @icon_widget: a widget that will be used as icon widget, or %NULL
 644  *
 645  * Creates a new %GtkToolButton using @icon_widget as icon and @label as
 646  * label.
 647  *
 648  * Return value: A new #GtkToolButton
 649  *
 650  * Since: 2.4
 651  **/
 652 GtkToolItem *
 653 gtk_tool_button_new (GtkWidget   *icon_widget,
 654                      const gchar *label)
 655 {
 656   GtkToolButton *button;
 657
 658   button = g_object_new (GTK_TYPE_TOOL_BUTTON,
 659                          NULL);
 660
 661   if (label)
 662     gtk_tool_button_set_label (button, label);
 663
 664   if (icon_widget)
 665     gtk_tool_button_set_icon_widget (button, icon_widget);
 666
 667   return GTK_TOOL_ITEM (button);
 668 }
 669
 670 /**
 671  * gtk_tool_button_set_label:
 672  * @button: a #GtkToolButton
 673  * @label: a string that will be used as label, or %NULL.
 674  *
 675  * Sets @label as the label used for the tool button. The "label" property
 676  * only has an effect if not overridden by a non-%NULL "label_widget" property.
 677  * If both the "label_widget" and "label" properties are %NULL, the label
 678  * is determined by the "stock_id" property. If the "stock_id" property is also
 679  * %NULL, @button will not have a label.
 680  *
 681  * Since: 2.4
 682  **/
 683 void
 684 gtk_tool_button_set_label (GtkToolButton *button,
 685                            const gchar   *label)
 686 {
 687   gchar *old_label;
 688
 689   g_return_if_fail (GTK_IS_TOOL_BUTTON (button));
 690
 691   old_label = button->priv->label_text;
 692
 693   button->priv->label_text = g_strdup (label);
 694   gtk_tool_button_construct_contents (GTK_TOOL_ITEM (button));
 695
 696   g_object_notify (G_OBJECT (button), "label");
 697
 698   if (old_label)
 699     g_free (old_label);
 700 }
 701
 702 /**
 703  * gtk_tool_button_get_label:
 704  * @button: a #GtkToolButton
 705  *
 706  * Returns the label used by the tool button, or %NULL if the tool button
 707  * doesn't have a label. or uses a the label from a stock item. The returned
 708  * string is owned by GTK+, and must not be modified or freed.
 709  *
 710  * Return value: The label, or %NULL
 711  *
 712  * Since: 2.4
 713  **/
 714 G_CONST_RETURN gchar *
 715 gtk_tool_button_get_label (GtkToolButton *button)
 716 {
 717   g_return_val_if_fail (GTK_IS_TOOL_BUTTON (button), NULL);
 718
 719   return button->priv->label_text;
 720 }
 721
 722 /**
 723  * gtk_tool_button_set_use_underline:
 724  * @button: a #GtkToolButton
 725  * @use_underline: whether the button label has the form "_Open"
 726  *
 727  * If set, an underline in the label property indicates that the next character
 728  * should be used for the mnemonic accelerator key in the overflow menu. For
 729  * example, if the label property is "_Open" and @use_underline is %TRUE,
 730  * the label on the tool button will be "Open" and the item on the overflow
 731  * menu will have an underlined 'O'.
 732  *
 733  * Labels shown on tool buttons never have mnemonics on them; this property
 734  * only affects the menu item on the overflow menu.
 735  *
 736  * Since: 2.4
 737  **/
 738 void
 739 gtk_tool_button_set_use_underline (GtkToolButton *button,
 740                                    gboolean       use_underline)
 741 {
 742   g_return_if_fail (GTK_IS_TOOL_BUTTON (button));
 743
 744   use_underline = use_underline != FALSE;
 745
 746   if (use_underline != button->priv->use_underline)
 747     {
 748       button->priv->use_underline = use_underline;
 749
 750       gtk_tool_button_construct_contents (GTK_TOOL_ITEM (button));
 751
 752       g_object_notify (G_OBJECT (button), "use_underline");
 753     }
 754 }
 755
 756 /**
 757  * gtk_tool_button_get_use_underline:
 758  * @button: a #GtkToolButton
 759  *
 760  * Returns whether underscores in the label property are used as mnemonics
 761  * on menu items on the overflow menu. See gtk_tool_button_set_use_underline().
 762  *
 763  * Return value: %TRUE if underscores in the label property are used as
 764  * mnemonics on menu items on the overflow menu.
 765  *
 766  * Since: 2.4
 767  **/
 768 gboolean
 769 gtk_tool_button_get_use_underline (GtkToolButton *button)
 770 {
 771   g_return_val_if_fail (GTK_IS_TOOL_BUTTON (button), FALSE);
 772
 773   return button->priv->use_underline;
 774 }
 775
 776 /**
 777  * gtk_tool_button_set_stock_id:
 778  * @button: a #GtkToolButton
 779  * @stock_id: a name of a stock item, or %NULL
 780  *
 781  * Sets the name of the stock item. See gtk_tool_button_new_from_stock().
 782  * The stock_id property only has an effect if not
 783  * overridden by non-%NULL "label" and "icon_widget" properties.
 784  *
 785  * Since: 2.4
 786  **/
 787 void
 788 gtk_tool_button_set_stock_id (GtkToolButton *button,
 789                               const gchar   *stock_id)
 790 {
 791   gchar *old_stock_id;
 792
 793   g_return_if_fail (GTK_IS_TOOL_BUTTON (button));
 794
 795   old_stock_id = button->priv->stock_id;
 796
 797   button->priv->stock_id = g_strdup (stock_id);
 798   gtk_tool_button_construct_contents (GTK_TOOL_ITEM (button));
 799
 800   g_object_notify (G_OBJECT (button), "stock_id");
 801
 802   g_free (old_stock_id);
 803 }
 804
 805 /**
 806  * gtk_tool_button_get_stock_id:
 807  * @button: a #GtkToolButton
 808  *
 809  * Returns the name of the stock item. See gtk_tool_button_set_stock_id().
 810  * The returned string is owned by GTK+ and must not be freed or modifed.
 811  *
 812  * Return value: the name of the stock item for @button.
 813  *
 814  * Since: 2.4
 815  **/
 816 G_CONST_RETURN gchar *
 817 gtk_tool_button_get_stock_id (GtkToolButton *button)
 818 {
 819   g_return_val_if_fail (GTK_IS_TOOL_BUTTON (button), NULL);
 820
 821   return button->priv->stock_id;
 822 }
 823
 824 /**
 825  * gtk_tool_button_set_icon_widget:
 826  * @button: a #GtkToolButton
 827  * @icon_widget: the widget used as icon, or %NULL
 828  *
 829  * Sets @icon as the widget used as icon on @button. If @icon_widget is
 830  * %NULL the icon is determined by the "stock_id" property. If the
 831  * "stock_id" property is also %NULL, @button will not have an icon.
 832  *
 833  * Since: 2.4
 834  **/
 835 void
 836 gtk_tool_button_set_icon_widget (GtkToolButton *button,
 837                                  GtkWidget     *icon_widget)
 838 {
 839   g_return_if_fail (GTK_IS_TOOL_BUTTON (button));
 840   g_return_if_fail (icon_widget == NULL || GTK_IS_WIDGET (icon_widget));
 841
 842   if (icon_widget != button->priv->icon_widget)
 843     {
 844       if (button->priv->icon_widget)
 845         {
 846           if (button->priv->icon_widget->parent)
 847             {
 848               gtk_container_remove (GTK_CONTAINER (button->priv->icon_widget->parent),
 849                                     button->priv->icon_widget);
 850             }
 851
 852           g_object_unref (G_OBJECT (button->priv->icon_widget));
 853         }
 854
 855       if (icon_widget)
 856         {
 857           g_object_ref (icon_widget);
 858           gtk_object_sink (GTK_OBJECT (icon_widget));
 859         }
 860
 861       button->priv->icon_widget = icon_widget;
 862
 863       gtk_tool_button_construct_contents (GTK_TOOL_ITEM (button));
 864
 865       g_object_notify (G_OBJECT (button), "icon_widget");
 866     }
 867 }
 868
 869 /**
 870  * gtk_tool_button_set_label_widget:
 871  * @button: a #GtkToolButton
 872  * @label_widget: the widget used as label, or %NULL
 873  *
 874  * Sets @label_widget as the widget that will be used as the label
 875  * for @button. If @label_widget is %NULL the "label" property is used
 876  * as label. If "label" is also %NULL, the label in the stock item
 877  * determined by the "stock_id" property is used as label. If
 878  * "stock_id" is also %NULL, @button does not have a label.
 879  *
 880  * Since: 2.4
 881  **/
 882 void
 883 gtk_tool_button_set_label_widget (GtkToolButton *button,
 884                                   GtkWidget     *label_widget)
 885 {
 886   g_return_if_fail (GTK_IS_TOOL_BUTTON (button));
 887   g_return_if_fail (label_widget == NULL || GTK_IS_WIDGET (label_widget));
 888
 889   if (label_widget != button->priv->label_widget)
 890     {
 891       if (button->priv->label_widget)
 892         {
 893           if (button->priv->label_widget->parent)
 894             {
 895               gtk_container_remove (GTK_CONTAINER (button->priv->label_widget->parent),
 896                                     button->priv->label_widget);
 897             }
 898
 899           g_object_unref (button->priv->label_widget);
 900         }
 901
 902       if (label_widget)
 903         {
 904           g_object_ref (label_widget);
 905           gtk_object_sink (GTK_OBJECT (label_widget));
 906         }
 907
 908       button->priv->label_widget = label_widget;
 909
 910       gtk_tool_button_construct_contents (GTK_TOOL_ITEM (button));
 911
 912       g_object_notify (G_OBJECT (button), "label_widget");
 913     }
 914 }
 915
 916 /**
 917  * gtk_tool_button_get_label_widget:
 918  * @button: a #GtkToolButton
 919  *
 920  * Returns the widget used as label on @button. See
 921  * gtk_tool_button_set_label_widget().
 922  *
 923  * Return value: The widget used as label on @button, or %NULL.
 924  *
 925  * Since: 2.4
 926  **/
 927 GtkWidget *
 928 gtk_tool_button_get_label_widget (GtkToolButton *button)
 929 {
 930   g_return_val_if_fail (GTK_IS_TOOL_BUTTON (button), NULL);
 931
 932   return button->priv->label_widget;
 933 }
 934
 935 /**
 936  * gtk_tool_button_get_icon_widget:
 937  * @button: a #GtkToolButton
 938  *
 939  * Return the widget used as icon widget on @button. See
 940  * gtk_tool_button_set_icon_widget().
 941  *
 942  * Return value: The widget used as icon on @button, or %NULL.
 943  *
 944  * Since: 2.4
 945  **/
 946 GtkWidget *
 947 gtk_tool_button_get_icon_widget (GtkToolButton *button)
 948 {
 949   g_return_val_if_fail (GTK_IS_TOOL_BUTTON (button), NULL);
 950
 951   return button->priv->icon_widget;
 952 }
 953
 954 GtkWidget *
 955 _gtk_tool_button_get_button (GtkToolButton *button)
 956 {
 957   g_return_val_if_fail (GTK_IS_TOOL_BUTTON (button), NULL);
 958
 959   return button->priv->button;
 960 }
 961