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

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-2001.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #include <string.h>
  28 #include "gtkalignment.h"
  29 #include "gtkbutton.h"
  30 #include "gtklabel.h"
  31 #include "gtkmain.h"
  32 #include "gtkmarshalers.h"
  33 #include "gtkimage.h"
  34 #include "gtkhbox.h"
  35 #include "gtkstock.h"
  36 #include "gtkiconfactory.h"
  37 #include "gtkintl.h"
  38
  39 #define CHILD_SPACING     1
  40
  41 static GtkBorder default_default_border = { 1, 1, 1, 1 };
  42 static GtkBorder default_default_outside_border = { 0, 0, 0, 0 };
  43
  44 /* Time out before giving up on getting a key release when animatng
  45  * the close button.
  46  */
  47 #define ACTIVATE_TIMEOUT 250
  48
  49 enum {
  50   PRESSED,
  51   RELEASED,
  52   CLICKED,
  53   ENTER,
  54   LEAVE,
  55   ACTIVATE,
  56   LAST_SIGNAL
  57 };
  58
  59 enum {
  60   PROP_0,
  61   PROP_LABEL,
  62   PROP_RELIEF,
  63   PROP_USE_UNDERLINE,
  64   PROP_USE_STOCK
  65 };
  66
  67 static void gtk_button_class_init     (GtkButtonClass   *klass);
  68 static void gtk_button_init           (GtkButton        *button);
  69 static void gtk_button_destroy        (GtkObject        *object);
  70 static void gtk_button_set_property   (GObject         *object,
  71                                        guint            prop_id,
  72                                        const GValue    *value,
  73                                        GParamSpec      *pspec);
  74 static void gtk_button_get_property   (GObject         *object,
  75                                        guint            prop_id,
  76                                        GValue          *value,
  77                                        GParamSpec      *pspec);
  78 static void gtk_button_realize        (GtkWidget        *widget);
  79 static void gtk_button_unrealize      (GtkWidget        *widget);
  80 static void gtk_button_map            (GtkWidget        *widget);
  81 static void gtk_button_unmap          (GtkWidget        *widget);
  82 static void gtk_button_size_request   (GtkWidget        *widget,
  83                                        GtkRequisition   *requisition);
  84 static void gtk_button_size_allocate  (GtkWidget        *widget,
  85                                        GtkAllocation    *allocation);
  86 static gint gtk_button_expose         (GtkWidget        *widget,
  87                                        GdkEventExpose   *event);
  88 static gint gtk_button_button_press   (GtkWidget        *widget,
  89                                        GdkEventButton   *event);
  90 static gint gtk_button_button_release (GtkWidget        *widget,
  91                                        GdkEventButton   *event);
  92 static gint gtk_button_key_release    (GtkWidget        *widget,
  93                                        GdkEventKey      *event);
  94 static gint gtk_button_enter_notify   (GtkWidget        *widget,
  95                                        GdkEventCrossing *event);
  96 static gint gtk_button_leave_notify   (GtkWidget        *widget,
  97                                        GdkEventCrossing *event);
  98 static void gtk_real_button_pressed   (GtkButton        *button);
  99 static void gtk_real_button_released  (GtkButton        *button);
 100 static void gtk_real_button_activate  (GtkButton         *button);
 101 static void gtk_button_update_state   (GtkButton        *button);
 102 static GType gtk_button_child_type    (GtkContainer     *container);
 103 static void gtk_button_finish_activate (GtkButton *button,
 104                                         gboolean   do_it);
 105
 106 static GObject* gtk_button_constructor     (GType                  type,
 107                                             guint                  n_construct_properties,
 108                                             GObjectConstructParam *construct_params);
 109 static void     gtk_button_construct_child (GtkButton             *button);
 110
 111
 112 static GtkBinClass *parent_class = NULL;
 113 static guint button_signals[LAST_SIGNAL] = { 0 };
 114
 115
 116 GType
 117 gtk_button_get_type (void)
 118 {
 119   static GType button_type = 0;
 120
 121   if (!button_type)
 122     {
 123       static const GTypeInfo button_info =
 124       {
 125         sizeof (GtkButtonClass),
 126         NULL,           /* base_init */
 127         NULL,           /* base_finalize */
 128         (GClassInitFunc) gtk_button_class_init,
 129         NULL,           /* class_finalize */
 130         NULL,           /* class_data */
 131         sizeof (GtkButton),
 132         16,             /* n_preallocs */
 133         (GInstanceInitFunc) gtk_button_init,
 134       };
 135
 136       button_type = g_type_register_static (GTK_TYPE_BIN, "GtkButton",
 137                                             &button_info, 0);
 138     }
 139
 140   return button_type;
 141 }
 142
 143 static void
 144 gtk_button_class_init (GtkButtonClass *klass)
 145 {
 146   GObjectClass *gobject_class;
 147   GtkObjectClass *object_class;
 148   GtkWidgetClass *widget_class;
 149   GtkContainerClass *container_class;
 150
 151   gobject_class = G_OBJECT_CLASS (klass);
 152   object_class = (GtkObjectClass*) klass;
 153   widget_class = (GtkWidgetClass*) klass;
 154   container_class = (GtkContainerClass*) klass;
 155
 156   parent_class = g_type_class_peek_parent (klass);
 157
 158   gobject_class->constructor = gtk_button_constructor;
 159   gobject_class->set_property = gtk_button_set_property;
 160   gobject_class->get_property = gtk_button_get_property;
 161
 162   object_class->destroy = gtk_button_destroy;
 163
 164   widget_class->realize = gtk_button_realize;
 165   widget_class->unrealize = gtk_button_unrealize;
 166   widget_class->map = gtk_button_map;
 167   widget_class->unmap = gtk_button_unmap;
 168   widget_class->size_request = gtk_button_size_request;
 169   widget_class->size_allocate = gtk_button_size_allocate;
 170   widget_class->expose_event = gtk_button_expose;
 171   widget_class->button_press_event = gtk_button_button_press;
 172   widget_class->button_release_event = gtk_button_button_release;
 173   widget_class->key_release_event = gtk_button_key_release;
 174   widget_class->enter_notify_event = gtk_button_enter_notify;
 175   widget_class->leave_notify_event = gtk_button_leave_notify;
 176
 177   container_class->child_type = gtk_button_child_type;
 178
 179   klass->pressed = gtk_real_button_pressed;
 180   klass->released = gtk_real_button_released;
 181   klass->clicked = NULL;
 182   klass->enter = gtk_button_update_state;
 183   klass->leave = gtk_button_update_state;
 184   klass->activate = gtk_real_button_activate;
 185
 186   g_object_class_install_property (gobject_class,
 187                                    PROP_LABEL,
 188                                    g_param_spec_string ("label",
 189                                                         _("Label"),
 190                                                         _("Text of the label widget inside the button, if the button contains a label widget"),
 191                                                         NULL,
 192                                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 193
 194   g_object_class_install_property (gobject_class,
 195                                    PROP_USE_UNDERLINE,
 196                                    g_param_spec_boolean ("use_underline",
 197                                                          _("Use underline"),
 198                                                          _("If set, an underline in the text indicates the next character should be used for the mnemonic accelerator key"),
 199                                                         FALSE,
 200                                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 201
 202   g_object_class_install_property (gobject_class,
 203                                    PROP_USE_STOCK,
 204                                    g_param_spec_boolean ("use_stock",
 205                                                          _("Use stock"),
 206                                                          _("If set, the label is used to pick a stock item instead of being displayed"),
 207                                                         FALSE,
 208                                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 209
 210   g_object_class_install_property (gobject_class,
 211                                    PROP_RELIEF,
 212                                    g_param_spec_enum ("relief",
 213                                                       _("Border relief"),
 214                                                       _("The border relief style"),
 215                                                       GTK_TYPE_RELIEF_STYLE,
 216                                                       GTK_RELIEF_NORMAL,
 217                                                       G_PARAM_READABLE | G_PARAM_WRITABLE));
 218
 219   button_signals[PRESSED] =
 220     g_signal_new ("pressed",
 221                   G_OBJECT_CLASS_TYPE (object_class),
 222                   G_SIGNAL_RUN_FIRST,
 223                   G_STRUCT_OFFSET (GtkButtonClass, pressed),
 224                   NULL, NULL,
 225                   _gtk_marshal_VOID__VOID,
 226                   G_TYPE_NONE, 0);
 227   button_signals[RELEASED] =
 228     g_signal_new ("released",
 229                   G_OBJECT_CLASS_TYPE (object_class),
 230                   G_SIGNAL_RUN_FIRST,
 231                   G_STRUCT_OFFSET (GtkButtonClass, released),
 232                   NULL, NULL,
 233                   _gtk_marshal_VOID__VOID,
 234                   G_TYPE_NONE, 0);
 235   button_signals[CLICKED] =
 236     g_signal_new ("clicked",
 237                   G_OBJECT_CLASS_TYPE (object_class),
 238                   G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 239                   G_STRUCT_OFFSET (GtkButtonClass, clicked),
 240                   NULL, NULL,
 241                   _gtk_marshal_VOID__VOID,
 242                   G_TYPE_NONE, 0);
 243   button_signals[ENTER] =
 244     g_signal_new ("enter",
 245                   G_OBJECT_CLASS_TYPE (object_class),
 246                   G_SIGNAL_RUN_FIRST,
 247                   G_STRUCT_OFFSET (GtkButtonClass, enter),
 248                   NULL, NULL,
 249                   _gtk_marshal_VOID__VOID,
 250                   G_TYPE_NONE, 0);
 251   button_signals[LEAVE] =
 252     g_signal_new ("leave",
 253                   G_OBJECT_CLASS_TYPE (object_class),
 254                   G_SIGNAL_RUN_FIRST,
 255                   G_STRUCT_OFFSET (GtkButtonClass, leave),
 256                   NULL, NULL,
 257                   _gtk_marshal_VOID__VOID,
 258                   G_TYPE_NONE, 0);
 259   button_signals[ACTIVATE] =
 260     g_signal_new ("activate",
 261                   G_OBJECT_CLASS_TYPE (object_class),
 262                   G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 263                   G_STRUCT_OFFSET (GtkButtonClass, activate),
 264                   NULL, NULL,
 265                   _gtk_marshal_VOID__VOID,
 266                   G_TYPE_NONE, 0);
 267   widget_class->activate_signal = button_signals[ACTIVATE];
 268
 269   gtk_widget_class_install_style_property (widget_class,
 270                                            g_param_spec_boxed ("default_border",
 271                                                                _("Default Spacing"),
 272                                                                _("Extra space to add for CAN_DEFAULT buttons"),
 273                                                                GTK_TYPE_BORDER,
 274                                                                G_PARAM_READABLE));
 275
 276   gtk_widget_class_install_style_property (widget_class,
 277                                            g_param_spec_boxed ("default_outside_border",
 278                                                                _("Default Outside Spacing"),
 279                                                                _("Extra space to add for CAN_DEFAULT buttons that is always drawn outside the border"),
 280                                                                GTK_TYPE_BORDER,
 281                                                                G_PARAM_READABLE));
 282   gtk_widget_class_install_style_property (widget_class,
 283                                            g_param_spec_int ("child_displacement_x",
 284                                                              _("Child X Displacement"),
 285                                                              _("How far in the x direction to move the child when the button is depressed"),
 286                                                              G_MININT,
 287                                                              G_MAXINT,
 288                                                              0,
 289                                                              G_PARAM_READABLE));
 290   gtk_widget_class_install_style_property (widget_class,
 291                                            g_param_spec_int ("child_displacement_y",
 292                                                              _("Child Y Displacement"),
 293                                                              _("How far in the y direction to move the child when the button is depressed"),
 294                                                              G_MININT,
 295                                                              G_MAXINT,
 296                                                              0,
 297                                                              G_PARAM_READABLE));
 298 }
 299
 300 static void
 301 gtk_button_init (GtkButton *button)
 302 {
 303   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_FOCUS | GTK_RECEIVES_DEFAULT);
 304   GTK_WIDGET_SET_FLAGS (button, GTK_NO_WINDOW);
 305
 306   button->label_text = NULL;
 307
 308   button->constructed = FALSE;
 309   button->in_button = FALSE;
 310   button->button_down = FALSE;
 311   button->relief = GTK_RELIEF_NORMAL;
 312   button->use_stock = FALSE;
 313   button->use_underline = FALSE;
 314   button->depressed = FALSE;
 315   button->depress_on_activate = TRUE;
 316 }
 317
 318 static void
 319 gtk_button_destroy (GtkObject *object)
 320 {
 321   GtkButton *button = GTK_BUTTON (object);
 322
 323   if (button->label_text)
 324     {
 325       g_free (button->label_text);
 326       button->label_text = NULL;
 327     }
 328
 329   (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
 330 }
 331
 332 static GObject*
 333 gtk_button_constructor (GType                  type,
 334                         guint                  n_construct_properties,
 335                         GObjectConstructParam *construct_params)
 336 {
 337   GObject *object;
 338   GtkButton *button;
 339
 340   object = (* G_OBJECT_CLASS (parent_class)->constructor) (type,
 341                                                            n_construct_properties,
 342                                                            construct_params);
 343
 344   button = GTK_BUTTON (object);
 345   button->constructed = TRUE;
 346
 347   if (button->label_text != NULL)
 348     gtk_button_construct_child (button);
 349
 350   return object;
 351 }
 352
 353
 354 static GType
 355 gtk_button_child_type  (GtkContainer     *container)
 356 {
 357   if (!GTK_BIN (container)->child)
 358     return GTK_TYPE_WIDGET;
 359   else
 360     return G_TYPE_NONE;
 361 }
 362
 363 static void
 364 gtk_button_set_property (GObject         *object,
 365                          guint            prop_id,
 366                          const GValue    *value,
 367                          GParamSpec      *pspec)
 368 {
 369   GtkButton *button;
 370
 371   button = GTK_BUTTON (object);
 372
 373   switch (prop_id)
 374     {
 375     case PROP_LABEL:
 376       gtk_button_set_label (button, g_value_get_string (value));
 377       break;
 378     case PROP_RELIEF:
 379       gtk_button_set_relief (button, g_value_get_enum (value));
 380       break;
 381     case PROP_USE_UNDERLINE:
 382       gtk_button_set_use_underline (button, g_value_get_boolean (value));
 383       break;
 384     case PROP_USE_STOCK:
 385       gtk_button_set_use_stock (button, g_value_get_boolean (value));
 386       break;
 387     default:
 388       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 389       break;
 390     }
 391 }
 392
 393 static void
 394 gtk_button_get_property (GObject         *object,
 395                          guint            prop_id,
 396                          GValue          *value,
 397                          GParamSpec      *pspec)
 398 {
 399   GtkButton *button;
 400
 401   button = GTK_BUTTON (object);
 402
 403   switch (prop_id)
 404     {
 405     case PROP_LABEL:
 406       g_value_set_string (value, button->label_text);
 407       break;
 408     case PROP_RELIEF:
 409       g_value_set_enum (value, gtk_button_get_relief (button));
 410       break;
 411     case PROP_USE_UNDERLINE:
 412       g_value_set_boolean (value, button->use_underline);
 413       break;
 414     case PROP_USE_STOCK:
 415       g_value_set_boolean (value, button->use_stock);
 416       break;
 417     default:
 418       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 419       break;
 420     }
 421 }
 422
 423 GtkWidget*
 424 gtk_button_new (void)
 425 {
 426   return g_object_new (GTK_TYPE_BUTTON, NULL);
 427 }
 428
 429 static void
 430 gtk_button_construct_child (GtkButton *button)
 431 {
 432   GtkStockItem item;
 433   GtkWidget *label;
 434   GtkWidget *image;
 435   GtkWidget *hbox;
 436   GtkWidget *align;
 437
 438   if (!button->constructed)
 439     return;
 440
 441   if (button->label_text == NULL)
 442     return;
 443
 444   if (GTK_BIN (button)->child)
 445     gtk_container_remove (GTK_CONTAINER (button),
 446                           GTK_BIN (button)->child);
 447
 448
 449   if (button->use_stock &&
 450       gtk_stock_lookup (button->label_text, &item))
 451     {
 452       label = gtk_label_new_with_mnemonic (item.label);
 453
 454       gtk_label_set_mnemonic_widget (GTK_LABEL (label), GTK_WIDGET (button));
 455
 456       image = gtk_image_new_from_stock (button->label_text, GTK_ICON_SIZE_BUTTON);
 457       hbox = gtk_hbox_new (FALSE, 2);
 458
 459       align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
 460
 461       gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
 462       gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 463
 464       gtk_container_add (GTK_CONTAINER (button), align);
 465       gtk_container_add (GTK_CONTAINER (align), hbox);
 466       gtk_widget_show_all (align);
 467
 468       return;
 469     }
 470
 471   if (button->use_underline)
 472     {
 473       label = gtk_label_new_with_mnemonic (button->label_text);
 474       gtk_label_set_mnemonic_widget (GTK_LABEL (label), GTK_WIDGET (button));
 475     }
 476   else
 477     label = gtk_label_new (button->label_text);
 478
 479   gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
 480
 481   gtk_widget_show (label);
 482   gtk_container_add (GTK_CONTAINER (button), label);
 483 }
 484
 485
 486 GtkWidget*
 487 gtk_button_new_with_label (const gchar *label)
 488 {
 489   return g_object_new (GTK_TYPE_BUTTON, "label", label, NULL);
 490 }
 491
 492 /**
 493  * gtk_button_new_from_stock:
 494  * @stock_id: the name of the stock item
 495  *
 496  * Creates a new #GtkButton containing the image and text from a stock item.
 497  * Some stock ids have preprocessor macros like #GTK_STOCK_OK and
 498  * #GTK_STOCK_APPLY.
 499  *
 500  * If @stock_id is unknown, then it will be treated as a mnemonic
 501  * label (as for gtk_button_new_with_mnemonic()).
 502  *
 503  * Returns: a new #GtkButton
 504  **/
 505 GtkWidget*
 506 gtk_button_new_from_stock (const gchar *stock_id)
 507 {
 508   return g_object_new (GTK_TYPE_BUTTON,
 509                        "label", stock_id,
 510                        "use_stock", TRUE,
 511                        "use_underline", TRUE,
 512                        NULL);
 513 }
 514
 515 /**
 516  * gtk_button_new_with_mnemonic:
 517  * @label: The text of the button, with an underscore in front of the
 518  *         mnemonic character
 519  * @returns: a new #GtkButton
 520  *
 521  * Creates a new #GtkButton containing a label.
 522  * If characters in @label are preceded by an underscore, they are underlined.
 523  * If you need a literal underscore character in a label, use '__' (two
 524  * underscores). The first underlined character represents a keyboard
 525  * accelerator called a mnemonic.
 526  * Pressing Alt and that key activates the button.
 527  **/
 528 GtkWidget*
 529 gtk_button_new_with_mnemonic (const gchar *label)
 530 {
 531   return g_object_new (GTK_TYPE_BUTTON, "label", label, "use_underline", TRUE,  NULL);
 532 }
 533
 534 void
 535 gtk_button_pressed (GtkButton *button)
 536 {
 537   g_return_if_fail (GTK_IS_BUTTON (button));
 538
 539   g_signal_emit (button, button_signals[PRESSED], 0);
 540 }
 541
 542 void
 543 gtk_button_released (GtkButton *button)
 544 {
 545   g_return_if_fail (GTK_IS_BUTTON (button));
 546
 547   g_signal_emit (button, button_signals[RELEASED], 0);
 548 }
 549
 550 void
 551 gtk_button_clicked (GtkButton *button)
 552 {
 553   g_return_if_fail (GTK_IS_BUTTON (button));
 554
 555   g_signal_emit (button, button_signals[CLICKED], 0);
 556 }
 557
 558 void
 559 gtk_button_enter (GtkButton *button)
 560 {
 561   g_return_if_fail (GTK_IS_BUTTON (button));
 562
 563   g_signal_emit (button, button_signals[ENTER], 0);
 564 }
 565
 566 void
 567 gtk_button_leave (GtkButton *button)
 568 {
 569   g_return_if_fail (GTK_IS_BUTTON (button));
 570
 571   g_signal_emit (button, button_signals[LEAVE], 0);
 572 }
 573
 574 void
 575 gtk_button_set_relief (GtkButton *button,
 576                        GtkReliefStyle newrelief)
 577 {
 578   g_return_if_fail (GTK_IS_BUTTON (button));
 579
 580   if (newrelief != button->relief)
 581     {
 582        button->relief = newrelief;
 583        g_object_notify (G_OBJECT (button), "relief");
 584        gtk_widget_queue_draw (GTK_WIDGET (button));
 585     }
 586 }
 587
 588 GtkReliefStyle
 589 gtk_button_get_relief (GtkButton *button)
 590 {
 591   g_return_val_if_fail (button != NULL, GTK_RELIEF_NORMAL);
 592   g_return_val_if_fail (GTK_IS_BUTTON (button), GTK_RELIEF_NORMAL);
 593
 594   return button->relief;
 595 }
 596
 597 static void
 598 gtk_button_realize (GtkWidget *widget)
 599 {
 600   GtkButton *button;
 601   GdkWindowAttr attributes;
 602   gint attributes_mask;
 603   gint border_width;
 604
 605   button = GTK_BUTTON (widget);
 606   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 607
 608   border_width = GTK_CONTAINER (widget)->border_width;
 609
 610   attributes.window_type = GDK_WINDOW_CHILD;
 611   attributes.x = widget->allocation.x + border_width;
 612   attributes.y = widget->allocation.y + border_width;
 613   attributes.width = widget->allocation.width - border_width * 2;
 614   attributes.height = widget->allocation.height - border_width * 2;
 615   attributes.wclass = GDK_INPUT_ONLY;
 616   attributes.event_mask = gtk_widget_get_events (widget);
 617   attributes.event_mask |= (GDK_EXPOSURE_MASK |
 618                             GDK_BUTTON_PRESS_MASK |
 619                             GDK_BUTTON_RELEASE_MASK |
 620                             GDK_ENTER_NOTIFY_MASK |
 621                             GDK_LEAVE_NOTIFY_MASK);
 622
 623   attributes_mask = GDK_WA_X | GDK_WA_Y;
 624
 625   widget->window = gtk_widget_get_parent_window (widget);
 626   g_object_ref (widget->window);
 627
 628   button->event_window = gdk_window_new (gtk_widget_get_parent_window (widget),
 629                                          &attributes, attributes_mask);
 630   gdk_window_set_user_data (button->event_window, button);
 631
 632   widget->style = gtk_style_attach (widget->style, widget->window);
 633 }
 634
 635 static void
 636 gtk_button_unrealize (GtkWidget *widget)
 637 {
 638   GtkButton *button = GTK_BUTTON (widget);
 639
 640   if (button->activate_timeout)
 641     gtk_button_finish_activate (button, FALSE);
 642
 643   if (button->event_window)
 644     {
 645       gdk_window_set_user_data (button->event_window, NULL);
 646       gdk_window_destroy (button->event_window);
 647       button->event_window = NULL;
 648     }
 649
 650   GTK_WIDGET_CLASS (parent_class)->unrealize (widget);
 651 }
 652
 653 static void
 654 gtk_button_map (GtkWidget *widget)
 655 {
 656   GtkButton *button = GTK_BUTTON (widget);
 657
 658   g_return_if_fail (GTK_IS_BUTTON (widget));
 659
 660   GTK_WIDGET_CLASS (parent_class)->map (widget);
 661
 662   if (button->event_window)
 663     gdk_window_show (button->event_window);
 664 }
 665
 666 static void
 667 gtk_button_unmap (GtkWidget *widget)
 668 {
 669   GtkButton *button = GTK_BUTTON (widget);
 670
 671   g_return_if_fail (GTK_IS_BUTTON (widget));
 672
 673   if (button->event_window)
 674     gdk_window_hide (button->event_window);
 675
 676   GTK_WIDGET_CLASS (parent_class)->unmap (widget);
 677 }
 678
 679 static void
 680 gtk_button_get_props (GtkButton *button,
 681                       GtkBorder *default_border,
 682                       GtkBorder *default_outside_border,
 683                       gboolean  *interior_focus)
 684 {
 685   GtkWidget *widget =  GTK_WIDGET (button);
 686   GtkBorder *tmp_border;
 687
 688   if (default_border)
 689     {
 690       gtk_widget_style_get (widget, "default_border", &tmp_border, NULL);
 691
 692       if (tmp_border)
 693         {
 694           *default_border = *tmp_border;
 695           g_free (tmp_border);
 696         }
 697       else
 698         *default_border = default_default_border;
 699     }
 700
 701   if (default_outside_border)
 702     {
 703       gtk_widget_style_get (widget, "default_outside_border", &tmp_border, NULL);
 704
 705       if (tmp_border)
 706         {
 707           *default_outside_border = *tmp_border;
 708           g_free (tmp_border);
 709         }
 710       else
 711         *default_outside_border = default_default_outside_border;
 712     }
 713
 714   if (interior_focus)
 715     gtk_widget_style_get (widget, "interior_focus", interior_focus, NULL);
 716 }
 717
 718 static void
 719 gtk_button_size_request (GtkWidget      *widget,
 720                          GtkRequisition *requisition)
 721 {
 722   GtkButton *button = GTK_BUTTON (widget);
 723   GtkBorder default_border;
 724   gboolean interior_focus;
 725   gint focus_width;
 726   gint focus_pad;
 727
 728   gtk_button_get_props (button, &default_border, NULL, &interior_focus);
 729   gtk_widget_style_get (GTK_WIDGET (widget),
 730                         "focus-line-width", &focus_width,
 731                         "focus-padding", &focus_pad,
 732                         NULL);
 733
 734   requisition->width = (GTK_CONTAINER (widget)->border_width + CHILD_SPACING +
 735                         GTK_WIDGET (widget)->style->xthickness) * 2;
 736   requisition->height = (GTK_CONTAINER (widget)->border_width + CHILD_SPACING +
 737                          GTK_WIDGET (widget)->style->ythickness) * 2;
 738
 739   if (GTK_WIDGET_CAN_DEFAULT (widget))
 740     {
 741       requisition->width += default_border.left + default_border.right;
 742       requisition->height += default_border.top + default_border.bottom;
 743     }
 744
 745   if (GTK_BIN (button)->child && GTK_WIDGET_VISIBLE (GTK_BIN (button)->child))
 746     {
 747       GtkRequisition child_requisition;
 748
 749       gtk_widget_size_request (GTK_BIN (button)->child, &child_requisition);
 750
 751       requisition->width += child_requisition.width;
 752       requisition->height += child_requisition.height;
 753     }
 754
 755   requisition->width += 2 * (focus_width + focus_pad);
 756   requisition->height += 2 * (focus_width + focus_pad);
 757 }
 758
 759 static void
 760 gtk_button_size_allocate (GtkWidget     *widget,
 761                           GtkAllocation *allocation)
 762 {
 763   GtkButton *button = GTK_BUTTON (widget);
 764   GtkAllocation child_allocation;
 765
 766   gint border_width = GTK_CONTAINER (widget)->border_width;
 767   gint xthickness = GTK_WIDGET (widget)->style->xthickness;
 768   gint ythickness = GTK_WIDGET (widget)->style->ythickness;
 769   GtkBorder default_border;
 770
 771   gtk_button_get_props (button, &default_border, NULL, NULL);
 772
 773   widget->allocation = *allocation;
 774
 775   if (GTK_WIDGET_REALIZED (widget))
 776     gdk_window_move_resize (button->event_window,
 777                             widget->allocation.x + border_width,
 778                             widget->allocation.y + border_width,
 779                             widget->allocation.width - border_width * 2,
 780                             widget->allocation.height - border_width * 2);
 781
 782   if (GTK_BIN (button)->child && GTK_WIDGET_VISIBLE (GTK_BIN (button)->child))
 783     {
 784       child_allocation.x = widget->allocation.x + border_width + CHILD_SPACING + xthickness;
 785       child_allocation.y = widget->allocation.y + border_width + CHILD_SPACING + ythickness;
 786
 787       child_allocation.width = MAX (1, widget->allocation.width - (CHILD_SPACING + xthickness) * 2 -
 788                                     border_width * 2);
 789       child_allocation.height = MAX (1, widget->allocation.height - (CHILD_SPACING + ythickness) * 2 -
 790                                      border_width * 2);
 791
 792       if (GTK_WIDGET_CAN_DEFAULT (button))
 793         {
 794           child_allocation.x += default_border.left;
 795           child_allocation.y += default_border.top;
 796           child_allocation.width =  MAX (1, child_allocation.width - default_border.left - default_border.right);
 797           child_allocation.height = MAX (1, child_allocation.height - default_border.top - default_border.bottom);
 798         }
 799
 800       if (button->depressed)
 801         {
 802           gint child_displacement_x;
 803           gint child_displacement_y;
 804
 805           gtk_widget_style_get (widget,
 806                                 "child_displacement_x", &child_displacement_x,
 807                                 "child_displacement_y", &child_displacement_y,
 808                                 NULL);
 809           child_allocation.x += child_displacement_x;
 810           child_allocation.y += child_displacement_y;
 811         }
 812
 813       gtk_widget_size_allocate (GTK_BIN (button)->child, &child_allocation);
 814     }
 815 }
 816
 817 void
 818 _gtk_button_paint (GtkButton    *button,
 819                    GdkRectangle *area,
 820                    GtkStateType  state_type,
 821                    GtkShadowType shadow_type,
 822                    const gchar  *main_detail,
 823                    const gchar  *default_detail)
 824 {
 825   GtkWidget *widget;
 826   gint width, height;
 827   gint x, y;
 828   gint border_width;
 829   GtkBorder default_border;
 830   GtkBorder default_outside_border;
 831   gboolean interior_focus;
 832   gint focus_width;
 833   gint focus_pad;
 834
 835   if (GTK_WIDGET_DRAWABLE (button))
 836     {
 837       widget = GTK_WIDGET (button);
 838       border_width = GTK_CONTAINER (widget)->border_width;
 839
 840       gtk_button_get_props (button, &default_border, &default_outside_border, &interior_focus);
 841       gtk_widget_style_get (GTK_WIDGET (widget),
 842                             "focus-line-width", &focus_width,
 843                             "focus-padding", &focus_pad,
 844                             NULL);
 845
 846       x = widget->allocation.x + border_width;
 847       y = widget->allocation.y + border_width;
 848       width = widget->allocation.width - border_width * 2;
 849       height = widget->allocation.height - border_width * 2;
 850
 851       if (GTK_WIDGET_HAS_DEFAULT (widget) &&
 852           GTK_BUTTON (widget)->relief == GTK_RELIEF_NORMAL)
 853         {
 854           gtk_paint_box (widget->style, widget->window,
 855                          GTK_STATE_NORMAL, GTK_SHADOW_IN,
 856                          area, widget, "buttondefault",
 857                          x, y, width, height);
 858
 859           x += default_border.left;
 860           y += default_border.top;
 861           width -= default_border.left + default_border.right;
 862           height -= default_border.top + default_border.bottom;
 863         }
 864       else if (GTK_WIDGET_CAN_DEFAULT (widget))
 865         {
 866           x += default_outside_border.left;
 867           y += default_outside_border.top;
 868           width -= default_outside_border.left + default_outside_border.right;
 869           height -= default_outside_border.top + default_outside_border.bottom;
 870         }
 871
 872       if (!interior_focus && GTK_WIDGET_HAS_FOCUS (widget))
 873         {
 874           x += focus_width + focus_pad;
 875           y += focus_width + focus_pad;
 876           width -= 2 * (focus_width + focus_pad);
 877           height -= 2 * (focus_width + focus_pad);
 878         }
 879
 880       if ((button->relief != GTK_RELIEF_NONE) ||
 881           ((GTK_WIDGET_STATE(widget) != GTK_STATE_NORMAL) &&
 882            (GTK_WIDGET_STATE(widget) != GTK_STATE_INSENSITIVE)))
 883         gtk_paint_box (widget->style, widget->window,
 884                        state_type,
 885                        shadow_type, area, widget, "button",
 886                        x, y, width, height);
 887
 888       if (GTK_WIDGET_HAS_FOCUS (widget))
 889         {
 890           if (interior_focus)
 891             {
 892               x += widget->style->xthickness + focus_pad;
 893               y += widget->style->ythickness + focus_pad;
 894               width -= 2 * (widget->style->xthickness + focus_pad);
 895               height -=  2 * (widget->style->xthickness + focus_pad);
 896             }
 897           else
 898             {
 899               x -= focus_width + focus_pad;
 900               y -= focus_width + focus_pad;
 901               width += 2 * (focus_width + focus_pad);
 902               height += 2 * (focus_width + focus_pad);
 903             }
 904
 905           gtk_paint_focus (widget->style, widget->window, GTK_WIDGET_STATE (widget),
 906                            area, widget, "button",
 907                            x, y, width, height);
 908         }
 909     }
 910 }
 911
 912 static gboolean
 913 gtk_button_expose (GtkWidget      *widget,
 914                    GdkEventExpose *event)
 915 {
 916   if (GTK_WIDGET_DRAWABLE (widget))
 917     {
 918       GtkButton *button = GTK_BUTTON (widget);
 919
 920       _gtk_button_paint (button, &event->area,
 921                          GTK_WIDGET_STATE (widget),
 922                          button->depressed ? GTK_SHADOW_IN : GTK_SHADOW_OUT,
 923                          "button", "buttondefault");
 924
 925       (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
 926     }
 927
 928   return FALSE;
 929 }
 930
 931 static gboolean
 932 gtk_button_button_press (GtkWidget      *widget,
 933                          GdkEventButton *event)
 934 {
 935   GtkButton *button;
 936
 937   if (event->type == GDK_BUTTON_PRESS)
 938     {
 939       button = GTK_BUTTON (widget);
 940
 941       if (!GTK_WIDGET_HAS_FOCUS (widget))
 942         gtk_widget_grab_focus (widget);
 943
 944       if (event->button == 1)
 945         gtk_button_pressed (button);
 946     }
 947
 948   return TRUE;
 949 }
 950
 951 static gboolean
 952 gtk_button_button_release (GtkWidget      *widget,
 953                            GdkEventButton *event)
 954 {
 955   GtkButton *button;
 956
 957   if (event->button == 1)
 958     {
 959       button = GTK_BUTTON (widget);
 960       gtk_button_released (button);
 961     }
 962
 963   return TRUE;
 964 }
 965
 966 static gboolean
 967 gtk_button_key_release (GtkWidget   *widget,
 968                         GdkEventKey *event)
 969 {
 970   GtkButton *button = GTK_BUTTON (widget);
 971
 972   if (button->activate_timeout)
 973     {
 974       gtk_button_finish_activate (button, TRUE);
 975       return TRUE;
 976     }
 977   else if (GTK_WIDGET_CLASS (parent_class)->key_release_event)
 978     return GTK_WIDGET_CLASS (parent_class)->key_release_event (widget, event);
 979   else
 980     return FALSE;
 981 }
 982
 983 static gboolean
 984 gtk_button_enter_notify (GtkWidget        *widget,
 985                          GdkEventCrossing *event)
 986 {
 987   GtkButton *button;
 988   GtkWidget *event_widget;
 989
 990   button = GTK_BUTTON (widget);
 991   event_widget = gtk_get_event_widget ((GdkEvent*) event);
 992
 993   if ((event_widget == widget) &&
 994       (event->detail != GDK_NOTIFY_INFERIOR))
 995     {
 996       button->in_button = TRUE;
 997       gtk_button_enter (button);
 998     }
 999
1000   return FALSE;
1001 }
1002
1003 static gboolean
1004 gtk_button_leave_notify (GtkWidget        *widget,
1005                          GdkEventCrossing *event)
1006 {
1007   GtkButton *button;
1008   GtkWidget *event_widget;
1009
1010   button = GTK_BUTTON (widget);
1011   event_widget = gtk_get_event_widget ((GdkEvent*) event);
1012
1013   if ((event_widget == widget) &&
1014       (event->detail != GDK_NOTIFY_INFERIOR))
1015     {
1016       button->in_button = FALSE;
1017       gtk_button_leave (button);
1018     }
1019
1020   return FALSE;
1021 }
1022
1023 static void
1024 gtk_real_button_pressed (GtkButton *button)
1025 {
1026   if (button->activate_timeout)
1027     return;
1028
1029   button->button_down = TRUE;
1030   gtk_button_update_state (button);
1031 }
1032
1033 static void
1034 gtk_real_button_released (GtkButton *button)
1035 {
1036   if (button->button_down)
1037     {
1038       button->button_down = FALSE;
1039
1040       if (button->activate_timeout)
1041         return;
1042
1043       if (button->in_button)
1044         gtk_button_clicked (button);
1045
1046       gtk_button_update_state (button);
1047     }
1048 }
1049
1050 static gboolean
1051 button_activate_timeout (gpointer data)
1052 {
1053   GDK_THREADS_ENTER ();
1054
1055   gtk_button_finish_activate (data, TRUE);
1056
1057   GDK_THREADS_LEAVE ();
1058
1059   return FALSE;
1060 }
1061
1062 static void
1063 gtk_real_button_activate (GtkButton *button)
1064 {
1065   GtkWidget *widget = GTK_WIDGET (button);
1066
1067   if (GTK_WIDGET_REALIZED (button) && !button->activate_timeout)
1068     {
1069       if (gdk_keyboard_grab (button->event_window, TRUE,
1070                              gtk_get_current_event_time ()) == 0)
1071         {
1072           gtk_grab_add (widget);
1073
1074           button->activate_timeout = g_timeout_add (ACTIVATE_TIMEOUT,
1075                                                     button_activate_timeout,
1076                                                     button);
1077           button->button_down = TRUE;
1078           gtk_button_update_state (button);
1079           gtk_widget_queue_draw (GTK_WIDGET (button));
1080         }
1081     }
1082 }
1083
1084 static void
1085 gtk_button_finish_activate (GtkButton *button,
1086                             gboolean   do_it)
1087 {
1088   GtkWidget *widget = GTK_WIDGET (button);
1089
1090   g_source_remove (button->activate_timeout);
1091   button->activate_timeout = 0;
1092
1093   gdk_display_keyboard_ungrab (gtk_widget_get_display (widget),
1094                                gtk_get_current_event_time ());
1095   gtk_grab_remove (widget);
1096
1097   button->button_down = FALSE;
1098
1099   gtk_button_update_state (button);
1100   gtk_widget_queue_draw (GTK_WIDGET (button));
1101
1102   if (do_it)
1103     gtk_button_clicked (button);
1104 }
1105
1106 /**
1107  * gtk_button_set_label:
1108  * @button: a #GtkButton
1109  * @label: a string
1110  *
1111  * Sets the text of the label of the button to @str. This text is
1112  * also used to select the stock item if gtk_button_set_use_stock()
1113  * is used.
1114  *
1115  * This will also clear any previously set labels.
1116  **/
1117 void
1118 gtk_button_set_label (GtkButton   *button,
1119                       const gchar *label)
1120 {
1121   g_return_if_fail (GTK_IS_BUTTON (button));
1122
1123   g_free (button->label_text);
1124   button->label_text = g_strdup (label);
1125
1126   gtk_button_construct_child (button);
1127
1128   g_object_notify (G_OBJECT (button), "label");
1129 }
1130
1131 /**
1132  * gtk_button_get_label:
1133  * @button: a #GtkButton
1134  *
1135  * Fetches the text from the label of the button, as set by
1136  * gtk_button_set_label(). If the label text has not
1137  * been set the return value will be %NULL. This will be the
1138  * case if you create an empty button with gtk_button_new() to
1139  * use as a container.
1140  *
1141  * Return value: The text of the label widget. This string is owned
1142  * by the widget and must not be modified or freed.
1143  **/
1144 G_CONST_RETURN gchar *
1145 gtk_button_get_label (GtkButton *button)
1146 {
1147   g_return_val_if_fail (GTK_IS_BUTTON (button), NULL);
1148
1149   return button->label_text;
1150 }
1151
1152 /**
1153  * gtk_button_set_use_underline:
1154  * @button: a #GtkButton
1155  * @use_underline: %TRUE if underlines in the text indicate mnemonics
1156  *
1157  * If true, an underline in the text of the button label indicates
1158  * the next character should be used for the mnemonic accelerator key.
1159  */
1160 void
1161 gtk_button_set_use_underline (GtkButton *button,
1162                               gboolean   use_underline)
1163 {
1164   g_return_if_fail (GTK_IS_BUTTON (button));
1165
1166   use_underline = use_underline != FALSE;
1167
1168   if (use_underline != button->use_underline)
1169     {
1170       button->use_underline = use_underline;
1171
1172       gtk_button_construct_child (button);
1173
1174       g_object_notify (G_OBJECT (button), "use_underline");
1175     }
1176 }
1177
1178 /**
1179  * gtk_button_get_use_underline:
1180  * @button: a #GtkButton
1181  *
1182  * Returns whether an embedded underline in the button label indicates a
1183  * mnemonic. See gtk_button_set_use_underline ().
1184  *
1185  * Return value: %TRUE if an embedded underline in the button label
1186  *               indicates the mnemonic accelerator keys.
1187  **/
1188 gboolean
1189 gtk_button_get_use_underline (GtkButton *button)
1190 {
1191   g_return_val_if_fail (GTK_IS_BUTTON (button), FALSE);
1192
1193   return button->use_underline;
1194 }
1195
1196 /**
1197  * gtk_button_set_use_stock:
1198  * @button: a #GtkButton
1199  * @use_stock: %TRUE if the button should use a stock item
1200  *
1201  * If true, the label set on the button is used as a
1202  * stock id to select the stock item for the button.
1203  */
1204 void
1205 gtk_button_set_use_stock (GtkButton *button,
1206                           gboolean   use_stock)
1207 {
1208   g_return_if_fail (GTK_IS_BUTTON (button));
1209
1210   use_stock = use_stock != FALSE;
1211
1212   if (use_stock != button->use_stock)
1213     {
1214       button->use_stock = use_stock;
1215
1216       gtk_button_construct_child (button);
1217
1218       g_object_notify (G_OBJECT (button), "use_stock");
1219     }
1220 }
1221
1222 /**
1223  * gtk_button_get_use_stock:
1224  * @button: a #GtkButton
1225  *
1226  * Returns whether the button label is a stock item.
1227  *
1228  * Return value: %TRUE if the button label is used to
1229  *               select a stock item instead of being
1230  *               used directly as the label text.
1231  */
1232 gboolean
1233 gtk_button_get_use_stock (GtkButton *button)
1234 {
1235   g_return_val_if_fail (GTK_IS_BUTTON (button), FALSE);
1236
1237   return button->use_stock;
1238 }
1239
1240 /**
1241  * _gtk_button_set_depressed:
1242  * @button: a #GtkButton
1243  * @depressed: %TRUE if the button should be drawn with a recessed shadow.
1244  *
1245  * Sets whether the button is currently drawn as down or not. This is
1246  * purely a visual setting, and is meant only for use by derived widgets
1247  * such as #GtkToggleButton.
1248  **/
1249 void
1250 _gtk_button_set_depressed (GtkButton *button,
1251                            gboolean   depressed)
1252 {
1253   GtkWidget *widget = GTK_WIDGET (button);
1254
1255   depressed = depressed != FALSE;
1256
1257   if (depressed != button->depressed)
1258     {
1259       button->depressed = depressed;
1260       gtk_widget_queue_resize (widget);
1261     }
1262 }
1263
1264 static void
1265 gtk_button_update_state (GtkButton *button)
1266 {
1267   gboolean depressed;
1268   GtkStateType new_state;
1269
1270   if (button->activate_timeout)
1271     depressed = button->depress_on_activate;
1272   else
1273     depressed = button->in_button && button->button_down;
1274
1275   if (button->in_button && (!button->button_down || !depressed))
1276     new_state = GTK_STATE_PRELIGHT;
1277   else
1278     new_state = depressed ? GTK_STATE_ACTIVE : GTK_STATE_NORMAL;
1279
1280   _gtk_button_set_depressed (button, depressed);
1281   gtk_widget_set_state (GTK_WIDGET (button), new_state);
1282 }