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 "config.h"
  28 #include <string.h>
  29 #include "gtkalignment.h"
  30 #include "gtkbutton.h"
  31 #include "gtklabel.h"
  32 #include "gtkmain.h"
  33 #include "gtkmarshalers.h"
  34 #include "gtkimage.h"
  35 #include "gtkhbox.h"
  36 #include "gtkvbox.h"
  37 #include "gtkstock.h"
  38 #include "gtkiconfactory.h"
  39 #include "gtkactivatable.h"
  40 #include "gtkprivate.h"
  41 #include "gtkintl.h"
  42 #include "gtkalias.h"
  43
  44 static const GtkBorder default_default_border = { 1, 1, 1, 1 };
  45 static const GtkBorder default_default_outside_border = { 0, 0, 0, 0 };
  46 static const GtkBorder default_inner_border = { 1, 1, 1, 1 };
  47
  48 /* Time out before giving up on getting a key release when animating
  49  * the close button.
  50  */
  51 #define ACTIVATE_TIMEOUT 250
  52
  53 enum {
  54   PRESSED,
  55   RELEASED,
  56   CLICKED,
  57   ENTER,
  58   LEAVE,
  59   ACTIVATE,
  60   LAST_SIGNAL
  61 };
  62
  63 enum {
  64   PROP_0,
  65   PROP_LABEL,
  66   PROP_IMAGE,
  67   PROP_RELIEF,
  68   PROP_USE_UNDERLINE,
  69   PROP_USE_STOCK,
  70   PROP_FOCUS_ON_CLICK,
  71   PROP_XALIGN,
  72   PROP_YALIGN,
  73   PROP_IMAGE_POSITION,
  74
  75   /* activatable properties */
  76   PROP_ACTIVATABLE_RELATED_ACTION,
  77   PROP_ACTIVATABLE_USE_ACTION_APPEARANCE
  78 };
  79
  80 #define GTK_BUTTON_GET_PRIVATE(o)       (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_BUTTON, GtkButtonPrivate))
  81 typedef struct _GtkButtonPrivate GtkButtonPrivate;
  82
  83 struct _GtkButtonPrivate
  84 {
  85   gfloat          xalign;
  86   gfloat          yalign;
  87   GtkWidget      *image;
  88   guint           align_set             : 1;
  89   guint           image_is_stock        : 1;
  90   guint           has_grab              : 1;
  91   guint           use_action_appearance : 1;
  92   guint32         grab_time;
  93   GtkPositionType image_position;
  94   GtkAction      *action;
  95 };
  96
  97 static void gtk_button_destroy        (GtkObject          *object);
  98 static void gtk_button_dispose        (GObject            *object);
  99 static void gtk_button_set_property   (GObject            *object,
 100                                        guint               prop_id,
 101                                        const GValue       *value,
 102                                        GParamSpec         *pspec);
 103 static void gtk_button_get_property   (GObject            *object,
 104                                        guint               prop_id,
 105                                        GValue             *value,
 106                                        GParamSpec         *pspec);
 107 static void gtk_button_screen_changed (GtkWidget          *widget,
 108                                        GdkScreen          *previous_screen);
 109 static void gtk_button_realize (GtkWidget * widget);
 110 static void gtk_button_unrealize (GtkWidget * widget);
 111 static void gtk_button_map (GtkWidget * widget);
 112 static void gtk_button_unmap (GtkWidget * widget);
 113 static void gtk_button_style_set (GtkWidget * widget, GtkStyle * prev_style);
 114 static void gtk_button_size_request (GtkWidget * widget,
 115                                      GtkRequisition * requisition);
 116 static void gtk_button_size_allocate (GtkWidget * widget,
 117                                       GtkAllocation * allocation);
 118 static gint gtk_button_expose (GtkWidget * widget, GdkEventExpose * event);
 119 static gint gtk_button_button_press (GtkWidget * widget,
 120                                      GdkEventButton * event);
 121 static gint gtk_button_button_release (GtkWidget * widget,
 122                                        GdkEventButton * event);
 123 static gint gtk_button_grab_broken (GtkWidget * widget,
 124                                     GdkEventGrabBroken * event);
 125 static gint gtk_button_key_release (GtkWidget * widget, GdkEventKey * event);
 126 static gint gtk_button_enter_notify (GtkWidget * widget,
 127                                      GdkEventCrossing * event);
 128 static gint gtk_button_leave_notify (GtkWidget * widget,
 129                                      GdkEventCrossing * event);
 130 static void gtk_real_button_pressed (GtkButton * button);
 131 static void gtk_real_button_released (GtkButton * button);
 132 static void gtk_real_button_clicked (GtkButton * button);
 133 static void gtk_real_button_activate  (GtkButton          *button);
 134 static void gtk_button_update_state   (GtkButton          *button);
 135 static void gtk_button_add            (GtkContainer       *container,
 136                                        GtkWidget          *widget);
 137 static GType gtk_button_child_type    (GtkContainer       *container);
 138 static void gtk_button_finish_activate (GtkButton         *button,
 139                                         gboolean           do_it);
 140
 141 static GObject* gtk_button_constructor (GType                  type,
 142                                         guint                  n_construct_properties,
 143                                         GObjectConstructParam *construct_params);
 144 static void gtk_button_construct_child (GtkButton             *button);
 145 static void gtk_button_state_changed   (GtkWidget             *widget,
 146                                         GtkStateType           previous_state);
 147 static void gtk_button_grab_notify     (GtkWidget             *widget,
 148                                         gboolean               was_grabbed);
 149
 150
 151 static void gtk_button_activatable_interface_init         (GtkActivatableIface  *iface);
 152 static void gtk_button_update                    (GtkActivatable       *activatable,
 153                                                   GtkAction            *action,
 154                                                   const gchar          *property_name);
 155 static void gtk_button_sync_action_properties    (GtkActivatable       *activatable,
 156                                                   GtkAction            *action);
 157 static void gtk_button_set_related_action        (GtkButton            *button,
 158                                                   GtkAction            *action);
 159 static void gtk_button_set_use_action_appearance (GtkButton            *button,
 160                                                   gboolean              use_appearance);
 161
 162 static guint button_signals[LAST_SIGNAL] = { 0 };
 163
 164 G_DEFINE_TYPE_WITH_CODE (GtkButton, gtk_button, GTK_TYPE_BIN,
 165                          G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTIVATABLE,
 166                                                 gtk_button_activatable_interface_init))
 167
 168 static void
 169 gtk_button_class_init (GtkButtonClass *klass)
 170 {
 171   GObjectClass *gobject_class;
 172   GtkObjectClass *object_class;
 173   GtkWidgetClass *widget_class;
 174   GtkContainerClass *container_class;
 175
 176   gobject_class = G_OBJECT_CLASS (klass);
 177   object_class = (GtkObjectClass*) klass;
 178   widget_class = (GtkWidgetClass*) klass;
 179   container_class = (GtkContainerClass*) klass;
 180
 181   gobject_class->constructor  = gtk_button_constructor;
 182   gobject_class->dispose      = gtk_button_dispose;
 183   gobject_class->set_property = gtk_button_set_property;
 184   gobject_class->get_property = gtk_button_get_property;
 185
 186   object_class->destroy = gtk_button_destroy;
 187
 188   widget_class->screen_changed = gtk_button_screen_changed;
 189   widget_class->realize = gtk_button_realize;
 190   widget_class->unrealize = gtk_button_unrealize;
 191   widget_class->map = gtk_button_map;
 192   widget_class->unmap = gtk_button_unmap;
 193   widget_class->style_set = gtk_button_style_set;
 194   widget_class->size_request = gtk_button_size_request;
 195   widget_class->size_allocate = gtk_button_size_allocate;
 196   widget_class->expose_event = gtk_button_expose;
 197   widget_class->button_press_event = gtk_button_button_press;
 198   widget_class->button_release_event = gtk_button_button_release;
 199   widget_class->grab_broken_event = gtk_button_grab_broken;
 200   widget_class->key_release_event = gtk_button_key_release;
 201   widget_class->enter_notify_event = gtk_button_enter_notify;
 202   widget_class->leave_notify_event = gtk_button_leave_notify;
 203   widget_class->state_changed = gtk_button_state_changed;
 204   widget_class->grab_notify = gtk_button_grab_notify;
 205
 206   container_class->child_type = gtk_button_child_type;
 207   container_class->add = gtk_button_add;
 208
 209   klass->pressed = gtk_real_button_pressed;
 210   klass->released = gtk_real_button_released;
 211   klass->clicked = NULL;
 212   klass->enter = gtk_button_update_state;
 213   klass->leave = gtk_button_update_state;
 214   klass->activate = gtk_real_button_activate;
 215
 216   g_object_class_install_property (gobject_class,
 217                                    PROP_LABEL,
 218                                    g_param_spec_string ("label",
 219                                                         P_("Label"),
 220                                                         P_("Text of the label widget inside the button, if the button contains a label widget"),
 221                                                         NULL,
 222                                                         GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 223
 224   g_object_class_install_property (gobject_class,
 225                                    PROP_USE_UNDERLINE,
 226                                    g_param_spec_boolean ("use-underline",
 227                                                          P_("Use underline"),
 228                                                          P_("If set, an underline in the text indicates the next character should be used for the mnemonic accelerator key"),
 229                                                         FALSE,
 230                                                         GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 231
 232   g_object_class_install_property (gobject_class,
 233                                    PROP_USE_STOCK,
 234                                    g_param_spec_boolean ("use-stock",
 235                                                          P_("Use stock"),
 236                                                          P_("If set, the label is used to pick a stock item instead of being displayed"),
 237                                                         FALSE,
 238                                                         GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 239
 240   g_object_class_install_property (gobject_class,
 241                                    PROP_FOCUS_ON_CLICK,
 242                                    g_param_spec_boolean ("focus-on-click",
 243                                                          P_("Focus on click"),
 244                                                          P_("Whether the button grabs focus when it is clicked with the mouse"),
 245                                                          TRUE,
 246                                                          GTK_PARAM_READWRITE));
 247
 248   g_object_class_install_property (gobject_class,
 249                                    PROP_RELIEF,
 250                                    g_param_spec_enum ("relief",
 251                                                       P_("Border relief"),
 252                                                       P_("The border relief style"),
 253                                                       GTK_TYPE_RELIEF_STYLE,
 254                                                       GTK_RELIEF_NORMAL,
 255                                                       GTK_PARAM_READWRITE));
 256
 257   /**
 258    * GtkButton:xalign:
 259    *
 260    * If the child of the button is a #GtkMisc or #GtkAlignment, this property
 261    * can be used to control it's horizontal alignment. 0.0 is left aligned,
 262    * 1.0 is right aligned.
 263    *
 264    * Since: 2.4
 265    */
 266   g_object_class_install_property (gobject_class,
 267                                    PROP_XALIGN,
 268                                    g_param_spec_float("xalign",
 269                                                       P_("Horizontal alignment for child"),
 270                                                       P_("Horizontal position of child in available space. 0.0 is left aligned, 1.0 is right aligned"),
 271                                                       0.0,
 272                                                       1.0,
 273                                                       0.5,
 274                                                       GTK_PARAM_READWRITE));
 275
 276   /**
 277    * GtkButton:yalign:
 278    *
 279    * If the child of the button is a #GtkMisc or #GtkAlignment, this property
 280    * can be used to control it's vertical alignment. 0.0 is top aligned,
 281    * 1.0 is bottom aligned.
 282    *
 283    * Since: 2.4
 284    */
 285   g_object_class_install_property (gobject_class,
 286                                    PROP_YALIGN,
 287                                    g_param_spec_float("yalign",
 288                                                       P_("Vertical alignment for child"),
 289                                                       P_("Vertical position of child in available space. 0.0 is top aligned, 1.0 is bottom aligned"),
 290                                                       0.0,
 291                                                       1.0,
 292                                                       0.5,
 293                                                       GTK_PARAM_READWRITE));
 294
 295   /**
 296    * GtkButton::image:
 297    *
 298    * The child widget to appear next to the button text.
 299    *
 300    * Since: 2.6
 301    */
 302   g_object_class_install_property (gobject_class,
 303                                    PROP_IMAGE,
 304                                    g_param_spec_object ("image",
 305                                                         P_("Image widget"),
 306                                                         P_("Child widget to appear next to the button text"),
 307                                                         GTK_TYPE_WIDGET,
 308                                                         GTK_PARAM_READWRITE));
 309
 310   /**
 311    * GtkButton:image-position:
 312    *
 313    * The position of the image relative to the text inside the button.
 314    *
 315    * Since: 2.10
 316    */
 317   g_object_class_install_property (gobject_class,
 318                                    PROP_IMAGE_POSITION,
 319                                    g_param_spec_enum ("image-position",
 320                                             P_("Image position"),
 321                                                       P_("The position of the image relative to the text"),
 322                                                       GTK_TYPE_POSITION_TYPE,
 323                                                       GTK_POS_LEFT,
 324                                                       GTK_PARAM_READWRITE));
 325
 326   g_object_class_override_property (gobject_class, PROP_ACTIVATABLE_RELATED_ACTION, "related-action");
 327   g_object_class_override_property (gobject_class, PROP_ACTIVATABLE_USE_ACTION_APPEARANCE, "use-action-appearance");
 328
 329   /**
 330    * GtkButton::pressed:
 331    * @button: the object that received the signal
 332    *
 333    * Emitted when the button is pressed.
 334    *
 335    * Deprecated: 2.8: Use the #GtkWidget::button-press-event signal.
 336    */
 337   button_signals[PRESSED] =
 338     g_signal_new (I_("pressed"),
 339                   G_OBJECT_CLASS_TYPE (object_class),
 340                   G_SIGNAL_RUN_FIRST,
 341                   G_STRUCT_OFFSET (GtkButtonClass, pressed),
 342                   NULL, NULL,
 343                   _gtk_marshal_VOID__VOID,
 344                   G_TYPE_NONE, 0);
 345
 346   /**
 347    * GtkButton::released:
 348    * @button: the object that received the signal
 349    *
 350    * Emitted when the button is released.
 351    *
 352    * Deprecated: 2.8: Use the #GtkWidget::button-release-event signal.
 353    */
 354   button_signals[RELEASED] =
 355     g_signal_new (I_("released"),
 356                   G_OBJECT_CLASS_TYPE (object_class),
 357                   G_SIGNAL_RUN_FIRST,
 358                   G_STRUCT_OFFSET (GtkButtonClass, released),
 359                   NULL, NULL,
 360                   _gtk_marshal_VOID__VOID,
 361                   G_TYPE_NONE, 0);
 362
 363   /**
 364    * GtkButton::clicked:
 365    * @button: the object that received the signal
 366    *
 367    * Emitted when the button has been activated (pressed and released).
 368    */
 369   button_signals[CLICKED] =
 370     g_signal_new (I_("clicked"),
 371                   G_OBJECT_CLASS_TYPE (object_class),
 372                   G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 373                   G_STRUCT_OFFSET (GtkButtonClass, clicked),
 374                   NULL, NULL,
 375                   _gtk_marshal_VOID__VOID,
 376                   G_TYPE_NONE, 0);
 377
 378   /**
 379    * GtkButton::enter:
 380    * @button: the object that received the signal
 381    *
 382    * Emitted when the pointer enters the button.
 383    *
 384    * Deprecated: 2.8: Use the #GtkWidget::enter-notify-event signal.
 385    */
 386   button_signals[ENTER] =
 387     g_signal_new (I_("enter"),
 388                   G_OBJECT_CLASS_TYPE (object_class),
 389                   G_SIGNAL_RUN_FIRST,
 390                   G_STRUCT_OFFSET (GtkButtonClass, enter),
 391                   NULL, NULL,
 392                   _gtk_marshal_VOID__VOID,
 393                   G_TYPE_NONE, 0);
 394
 395   /**
 396    * GtkButton::leave:
 397    * @button: the object that received the signal
 398    *
 399    * Emitted when the pointer leaves the button.
 400    *
 401    * Deprecated: 2.8: Use the #GtkWidget::leave-notify-event signal.
 402    */
 403   button_signals[LEAVE] =
 404     g_signal_new (I_("leave"),
 405                   G_OBJECT_CLASS_TYPE (object_class),
 406                   G_SIGNAL_RUN_FIRST,
 407                   G_STRUCT_OFFSET (GtkButtonClass, leave),
 408                   NULL, NULL,
 409                   _gtk_marshal_VOID__VOID,
 410                   G_TYPE_NONE, 0);
 411
 412   /**
 413    * GtkButton::activate:
 414    * @widget: the object which received the signal.
 415    *
 416    * The ::activate signal on GtkButton is an action signal and
 417    * emitting it causes the button to animate press then release.
 418    * Applications should never connect to this signal, but use the
 419    * #GtkButton::clicked signal.
 420    */
 421   button_signals[ACTIVATE] =
 422     g_signal_new (I_("activate"),
 423                   G_OBJECT_CLASS_TYPE (object_class),
 424                   G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
 425                   G_STRUCT_OFFSET (GtkButtonClass, activate),
 426                   NULL, NULL,
 427                   _gtk_marshal_VOID__VOID,
 428                   G_TYPE_NONE, 0);
 429   widget_class->activate_signal = button_signals[ACTIVATE];
 430
 431   gtk_widget_class_install_style_property (widget_class,
 432                                            g_param_spec_boxed ("default-border",
 433                                                                P_("Default Spacing"),
 434                                                                P_("Extra space to add for CAN_DEFAULT buttons"),
 435                                                                GTK_TYPE_BORDER,
 436                                                                GTK_PARAM_READABLE));
 437
 438   gtk_widget_class_install_style_property (widget_class,
 439                                            g_param_spec_boxed ("default-outside-border",
 440                                                                P_("Default Outside Spacing"),
 441                                                                P_("Extra space to add for CAN_DEFAULT buttons that is always drawn outside the border"),
 442                                                                GTK_TYPE_BORDER,
 443                                                                GTK_PARAM_READABLE));
 444   gtk_widget_class_install_style_property (widget_class,
 445                                            g_param_spec_int ("child-displacement-x",
 446                                                              P_("Child X Displacement"),
 447                                                              P_("How far in the x direction to move the child when the button is depressed"),
 448                                                              G_MININT,
 449                                                              G_MAXINT,
 450                                                              0,
 451                                                              GTK_PARAM_READABLE));
 452   gtk_widget_class_install_style_property (widget_class,
 453                                            g_param_spec_int ("child-displacement-y",
 454                                                              P_("Child Y Displacement"),
 455                                                              P_("How far in the y direction to move the child when the button is depressed"),
 456                                                              G_MININT,
 457                                                              G_MAXINT,
 458                                                              0,
 459                                                              GTK_PARAM_READABLE));
 460
 461   /**
 462    * GtkButton:displace-focus:
 463    *
 464    * Whether the child_displacement_x/child_displacement_y properties
 465    * should also affect the focus rectangle.
 466    *
 467    * Since: 2.6
 468    */
 469   gtk_widget_class_install_style_property (widget_class,
 470                                            g_param_spec_boolean ("displace-focus",
 471                                                                  P_("Displace focus"),
 472                                                                  P_("Whether the child_displacement_x/_y properties should also affect the focus rectangle"),
 473                                                                  FALSE,
 474                                                                  GTK_PARAM_READABLE));
 475
 476   /**
 477    * GtkButton:inner-border:
 478    *
 479    * Sets the border between the button edges and child.
 480    *
 481    * Since: 2.10
 482    */
 483   gtk_widget_class_install_style_property (widget_class,
 484                                            g_param_spec_boxed ("inner-border",
 485                                                                P_("Inner Border"),
 486                                                                P_("Border between button edges and child."),
 487                                                                GTK_TYPE_BORDER,
 488                                                                GTK_PARAM_READABLE));
 489
 490   /**
 491    * GtkButton::image-spacing:
 492    *
 493    * Spacing in pixels between the image and label.
 494    *
 495    * Since: 2.10
 496    */
 497   gtk_widget_class_install_style_property (widget_class,
 498                                            g_param_spec_int ("image-spacing",
 499                                                              P_("Image spacing"),
 500                                                              P_("Spacing in pixels between the image and label"),
 501                                                              0,
 502                                                              G_MAXINT,
 503                                                              2,
 504                                                              GTK_PARAM_READABLE));
 505
 506   /**
 507    * GtkSettings::gtk-button-images:
 508    *
 509    * Whether images should be shown on buttons
 510    *
 511    * Since: 2.4
 512    */
 513   gtk_settings_install_property (g_param_spec_boolean ("gtk-button-images",
 514                                                        P_("Show button images"),
 515                                                        P_("Whether images should be shown on buttons"),
 516                                                        TRUE,
 517                                                        GTK_PARAM_READWRITE));
 518
 519   g_type_class_add_private (gobject_class, sizeof (GtkButtonPrivate));
 520 }
 521
 522 static void
 523 gtk_button_init (GtkButton *button)
 524 {
 525   GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (button);
 526
 527   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_FOCUS | GTK_RECEIVES_DEFAULT);
 528   GTK_WIDGET_SET_FLAGS (button, GTK_NO_WINDOW);
 529
 530   button->label_text = NULL;
 531
 532   button->constructed = FALSE;
 533   button->in_button = FALSE;
 534   button->button_down = FALSE;
 535   button->relief = GTK_RELIEF_NORMAL;
 536   button->use_stock = FALSE;
 537   button->use_underline = FALSE;
 538   button->depressed = FALSE;
 539   button->depress_on_activate = TRUE;
 540   button->focus_on_click = TRUE;
 541
 542   priv->xalign = 0.5;
 543   priv->yalign = 0.5;
 544   priv->align_set = 0;
 545   priv->image_is_stock = TRUE;
 546   priv->image_position = GTK_POS_LEFT;
 547   priv->use_action_appearance = TRUE;
 548 }
 549
 550 static void
 551 gtk_button_destroy (GtkObject *object)
 552 {
 553   GtkButton *button = GTK_BUTTON (object);
 554
 555   if (button->label_text)
 556     {
 557       g_free (button->label_text);
 558       button->label_text = NULL;
 559     }
 560
 561   GTK_OBJECT_CLASS (gtk_button_parent_class)->destroy (object);
 562 }
 563
 564 static GObject*
 565 gtk_button_constructor (GType                  type,
 566                         guint                  n_construct_properties,
 567                         GObjectConstructParam *construct_params)
 568 {
 569   GObject *object;
 570   GtkButton *button;
 571
 572   object = G_OBJECT_CLASS (gtk_button_parent_class)->constructor (type,
 573                                                                   n_construct_properties,
 574                                                                   construct_params);
 575
 576   button = GTK_BUTTON (object);
 577   button->constructed = TRUE;
 578
 579   if (button->label_text != NULL)
 580     gtk_button_construct_child (button);
 581
 582   return object;
 583 }
 584
 585
 586 static GType
 587 gtk_button_child_type  (GtkContainer     *container)
 588 {
 589   if (!GTK_BIN (container)->child)
 590     return GTK_TYPE_WIDGET;
 591   else
 592     return G_TYPE_NONE;
 593 }
 594
 595 static void
 596 maybe_set_alignment (GtkButton *button,
 597                      GtkWidget *widget)
 598 {
 599   GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (button);
 600
 601   if (GTK_IS_MISC (widget))
 602     {
 603       GtkMisc *misc = GTK_MISC (widget);
 604
 605       if (priv->align_set)
 606         gtk_misc_set_alignment (misc, priv->xalign, priv->yalign);
 607     }
 608   else if (GTK_IS_ALIGNMENT (widget))
 609     {
 610       GtkAlignment *alignment = GTK_ALIGNMENT (widget);
 611
 612       if (priv->align_set)
 613         gtk_alignment_set (alignment, priv->xalign, priv->yalign,
 614                            alignment->xscale, alignment->yscale);
 615     }
 616 }
 617
 618 static void
 619 gtk_button_add (GtkContainer *container,
 620                 GtkWidget    *widget)
 621 {
 622   maybe_set_alignment (GTK_BUTTON (container), widget);
 623
 624   GTK_CONTAINER_CLASS (gtk_button_parent_class)->add (container, widget);
 625 }
 626
 627 static void
 628 gtk_button_dispose (GObject *object)
 629 {
 630   GtkButton *button = GTK_BUTTON (object);
 631   GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (button);
 632
 633   if (priv->action)
 634     {
 635       gtk_activatable_do_set_related_action (GTK_ACTIVATABLE (button), NULL);
 636       priv->action = NULL;
 637     }
 638   G_OBJECT_CLASS (gtk_button_parent_class)->dispose (object);
 639 }
 640
 641 static void
 642 gtk_button_set_property (GObject         *object,
 643                          guint            prop_id,
 644                          const GValue    *value,
 645                          GParamSpec      *pspec)
 646 {
 647   GtkButton *button = GTK_BUTTON (object);
 648   GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (button);
 649
 650   switch (prop_id)
 651     {
 652     case PROP_LABEL:
 653       gtk_button_set_label (button, g_value_get_string (value));
 654       break;
 655     case PROP_IMAGE:
 656       gtk_button_set_image (button, (GtkWidget *) g_value_get_object (value));
 657       break;
 658     case PROP_RELIEF:
 659       gtk_button_set_relief (button, g_value_get_enum (value));
 660       break;
 661     case PROP_USE_UNDERLINE:
 662       gtk_button_set_use_underline (button, g_value_get_boolean (value));
 663       break;
 664     case PROP_USE_STOCK:
 665       gtk_button_set_use_stock (button, g_value_get_boolean (value));
 666       break;
 667     case PROP_FOCUS_ON_CLICK:
 668       gtk_button_set_focus_on_click (button, g_value_get_boolean (value));
 669       break;
 670     case PROP_XALIGN:
 671       gtk_button_set_alignment (button, g_value_get_float (value), priv->yalign);
 672       break;
 673     case PROP_YALIGN:
 674       gtk_button_set_alignment (button, priv->xalign, g_value_get_float (value));
 675       break;
 676     case PROP_IMAGE_POSITION:
 677       gtk_button_set_image_position (button, g_value_get_enum (value));
 678       break;
 679     case PROP_ACTIVATABLE_RELATED_ACTION:
 680       gtk_button_set_related_action (button, g_value_get_object (value));
 681       break;
 682     case PROP_ACTIVATABLE_USE_ACTION_APPEARANCE:
 683       gtk_button_set_use_action_appearance (button, g_value_get_boolean (value));
 684       break;
 685     default:
 686       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 687       break;
 688     }
 689 }
 690
 691 static void
 692 gtk_button_get_property (GObject         *object,
 693                          guint            prop_id,
 694                          GValue          *value,
 695                          GParamSpec      *pspec)
 696 {
 697   GtkButton *button = GTK_BUTTON (object);
 698   GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (button);
 699
 700   switch (prop_id)
 701     {
 702     case PROP_LABEL:
 703       g_value_set_string (value, button->label_text);
 704       break;
 705     case PROP_IMAGE:
 706       g_value_set_object (value, (GObject *)priv->image);
 707       break;
 708     case PROP_RELIEF:
 709       g_value_set_enum (value, gtk_button_get_relief (button));
 710       break;
 711     case PROP_USE_UNDERLINE:
 712       g_value_set_boolean (value, button->use_underline);
 713       break;
 714     case PROP_USE_STOCK:
 715       g_value_set_boolean (value, button->use_stock);
 716       break;
 717     case PROP_FOCUS_ON_CLICK:
 718       g_value_set_boolean (value, button->focus_on_click);
 719       break;
 720     case PROP_XALIGN:
 721       g_value_set_float (value, priv->xalign);
 722       break;
 723     case PROP_YALIGN:
 724       g_value_set_float (value, priv->yalign);
 725       break;
 726     case PROP_IMAGE_POSITION:
 727       g_value_set_enum (value, priv->image_position);
 728       break;
 729     case PROP_ACTIVATABLE_RELATED_ACTION:
 730       g_value_set_object (value, priv->action);
 731       break;
 732     case PROP_ACTIVATABLE_USE_ACTION_APPEARANCE:
 733       g_value_set_boolean (value, priv->use_action_appearance);
 734       break;
 735     default:
 736       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 737       break;
 738     }
 739 }
 740
 741 static void
 742 gtk_button_activatable_interface_init (GtkActivatableIface  *iface)
 743 {
 744   iface->update = gtk_button_update;
 745   iface->sync_action_properties = gtk_button_sync_action_properties;
 746 }
 747
 748 static void
 749 activatable_update_stock_id (GtkButton *button,
 750                              GtkAction *action)
 751 {
 752   if (!gtk_button_get_use_stock (button))
 753     return;
 754
 755   gtk_button_set_label (button, gtk_action_get_stock_id (action));
 756 }
 757
 758 static void
 759 activatable_update_short_label (GtkButton *button,
 760                                 GtkAction *action)
 761 {
 762   GtkWidget *image;
 763
 764   if (gtk_button_get_use_stock (button))
 765     return;
 766
 767   image = gtk_button_get_image (button);
 768
 769   /* Dont touch custom child... */
 770   if (GTK_IS_IMAGE (image) ||
 771       GTK_BIN (button)->child == NULL ||
 772       GTK_IS_LABEL (GTK_BIN (button)->child))
 773     {
 774       gtk_button_set_label (button, gtk_action_get_short_label (action));
 775       gtk_button_set_use_underline (button, TRUE);
 776     }
 777 }
 778
 779 static void
 780 activatable_update_icon_name (GtkButton *button,
 781                               GtkAction *action)
 782 {
 783   GtkWidget *image;
 784
 785   if (gtk_button_get_use_stock (button))
 786     return;
 787
 788   image = gtk_button_get_image (button);
 789
 790   if (GTK_IS_IMAGE (image) &&
 791       (gtk_image_get_storage_type (GTK_IMAGE (image)) == GTK_IMAGE_EMPTY ||
 792        gtk_image_get_storage_type (GTK_IMAGE (image)) == GTK_IMAGE_ICON_NAME))
 793     gtk_image_set_from_icon_name (GTK_IMAGE (image),
 794                                   gtk_action_get_icon_name (action), GTK_ICON_SIZE_MENU);
 795 }
 796
 797 static void
 798 activatable_update_gicon (GtkButton *button,
 799                           GtkAction *action)
 800 {
 801   GtkWidget *image = gtk_button_get_image (button);
 802   GIcon *icon = gtk_action_get_gicon (action);
 803
 804   if (GTK_IS_IMAGE (image) &&
 805       (gtk_image_get_storage_type (GTK_IMAGE (image)) == GTK_IMAGE_EMPTY ||
 806        gtk_image_get_storage_type (GTK_IMAGE (image)) == GTK_IMAGE_GICON))
 807     gtk_image_set_from_gicon (GTK_IMAGE (image), icon, GTK_ICON_SIZE_BUTTON);
 808 }
 809
 810 static void
 811 gtk_button_update (GtkActivatable *activatable,
 812                    GtkAction      *action,
 813                    const gchar    *property_name)
 814 {
 815   GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (activatable);
 816
 817   if (strcmp (property_name, "visible") == 0)
 818     {
 819       if (gtk_action_is_visible (action))
 820         gtk_widget_show (GTK_WIDGET (activatable));
 821       else
 822         gtk_widget_hide (GTK_WIDGET (activatable));
 823     }
 824   else if (strcmp (property_name, "sensitive") == 0)
 825     gtk_widget_set_sensitive (GTK_WIDGET (activatable), gtk_action_is_sensitive (action));
 826
 827   if (!priv->use_action_appearance)
 828     return;
 829
 830   if (strcmp (property_name, "stock-id") == 0)
 831     activatable_update_stock_id (GTK_BUTTON (activatable), action);
 832   else if (strcmp (property_name, "gicon") == 0)
 833     activatable_update_gicon (GTK_BUTTON (activatable), action);
 834   else if (strcmp (property_name, "short-label") == 0)
 835     activatable_update_short_label (GTK_BUTTON (activatable), action);
 836   else if (strcmp (property_name, "icon-name") == 0)
 837     activatable_update_icon_name (GTK_BUTTON (activatable), action);
 838 }
 839
 840 static void
 841 gtk_button_sync_action_properties (GtkActivatable *activatable,
 842                                    GtkAction      *action)
 843 {
 844   GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (activatable);
 845
 846   if (!action)
 847     return;
 848
 849   if (gtk_action_is_visible (action))
 850     gtk_widget_show (GTK_WIDGET (activatable));
 851   else
 852     gtk_widget_hide (GTK_WIDGET (activatable));
 853
 854   gtk_widget_set_sensitive (GTK_WIDGET (activatable), gtk_action_is_sensitive (action));
 855
 856   if (priv->use_action_appearance)
 857     {
 858       activatable_update_stock_id (GTK_BUTTON (activatable), action);
 859       activatable_update_short_label (GTK_BUTTON (activatable), action);
 860       activatable_update_gicon (GTK_BUTTON (activatable), action);
 861       activatable_update_icon_name (GTK_BUTTON (activatable), action);
 862     }
 863 }
 864
 865 static void
 866 gtk_button_set_related_action (GtkButton *button,
 867                                GtkAction *action)
 868 {
 869   GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (button);
 870
 871   if (priv->action == action)
 872     return;
 873
 874   /* This should be a default handler, but for compatibility reasons
 875    * we need to support derived classes that don't chain up their
 876    * clicked handler.
 877    */
 878   g_signal_handlers_disconnect_by_func (button, gtk_real_button_clicked, NULL);
 879   if (action)
 880     g_signal_connect_after (button, "clicked",
 881                             G_CALLBACK (gtk_real_button_clicked), NULL);
 882
 883   gtk_activatable_do_set_related_action (GTK_ACTIVATABLE (button), action);
 884
 885   priv->action = action;
 886 }
 887
 888 static void
 889 gtk_button_set_use_action_appearance (GtkButton *button,
 890                                       gboolean   use_appearance)
 891 {
 892   GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (button);
 893
 894   if (priv->use_action_appearance != use_appearance)
 895     {
 896       priv->use_action_appearance = use_appearance;
 897
 898       gtk_activatable_sync_action_properties (GTK_ACTIVATABLE (button), priv->action);
 899     }
 900 }
 901
 902 GtkWidget*
 903 gtk_button_new (void)
 904 {
 905   return g_object_new (GTK_TYPE_BUTTON, NULL);
 906 }
 907
 908 static gboolean
 909 show_image (GtkButton *button)
 910 {
 911   gboolean show;
 912
 913   if (button->label_text)
 914     {
 915       GtkSettings *settings;
 916
 917       settings = gtk_widget_get_settings (GTK_WIDGET (button));
 918       g_object_get (settings, "gtk-button-images", &show, NULL);
 919     }
 920   else
 921     show = TRUE;
 922
 923   return show;
 924 }
 925
 926 static void
 927 gtk_button_construct_child (GtkButton *button)
 928 {
 929   GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (button);
 930   GtkStockItem item;
 931   GtkWidget *label;
 932   GtkWidget *box;
 933   GtkWidget *align;
 934   GtkWidget *image = NULL;
 935   gchar *label_text = NULL;
 936   gint image_spacing;
 937
 938   if (!button->constructed)
 939     return;
 940
 941   if (!button->label_text && !priv->image)
 942     return;
 943
 944   gtk_widget_style_get (GTK_WIDGET (button),
 945                         "image-spacing", &image_spacing,
 946                         NULL);
 947
 948   if (priv->image && !priv->image_is_stock)
 949     {
 950       image = g_object_ref (priv->image);
 951       if (image->parent)
 952         gtk_container_remove (GTK_CONTAINER (image->parent), image);
 953     }
 954
 955   priv->image = NULL;
 956
 957   if (GTK_BIN (button)->child)
 958     gtk_container_remove (GTK_CONTAINER (button),
 959                           GTK_BIN (button)->child);
 960
 961   if (button->use_stock &&
 962       button->label_text &&
 963       gtk_stock_lookup (button->label_text, &item))
 964     {
 965       if (!image)
 966         image = g_object_ref (gtk_image_new_from_stock (button->label_text, GTK_ICON_SIZE_BUTTON));
 967
 968       label_text = item.label;
 969     }
 970   else
 971     label_text = button->label_text;
 972
 973   if (image)
 974     {
 975       priv->image = image;
 976       g_object_set (priv->image,
 977                     "visible", show_image (button),
 978                     "no-show-all", TRUE,
 979                     NULL);
 980
 981       if (priv->image_position == GTK_POS_LEFT ||
 982           priv->image_position == GTK_POS_RIGHT)
 983         box = gtk_hbox_new (FALSE, image_spacing);
 984       else
 985         box = gtk_vbox_new (FALSE, image_spacing);
 986
 987       if (priv->align_set)
 988         align = gtk_alignment_new (priv->xalign, priv->yalign, 0.0, 0.0);
 989       else
 990         align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
 991
 992       if (priv->image_position == GTK_POS_LEFT ||
 993           priv->image_position == GTK_POS_TOP)
 994         gtk_box_pack_start (GTK_BOX (box), priv->image, FALSE, FALSE, 0);
 995       else
 996         gtk_box_pack_end (GTK_BOX (box), priv->image, FALSE, FALSE, 0);
 997
 998       if (label_text)
 999         {
1000           label = gtk_label_new_with_mnemonic (label_text);
1001           gtk_label_set_mnemonic_widget (GTK_LABEL (label),
1002                                          GTK_WIDGET (button));
1003
1004           if (priv->image_position == GTK_POS_RIGHT ||
1005               priv->image_position == GTK_POS_BOTTOM)
1006             gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
1007           else
1008             gtk_box_pack_end (GTK_BOX (box), label, FALSE, FALSE, 0);
1009         }
1010
1011       gtk_container_add (GTK_CONTAINER (button), align);
1012       gtk_container_add (GTK_CONTAINER (align), box);
1013       gtk_widget_show_all (align);
1014
1015       g_object_unref (image);
1016
1017       return;
1018     }
1019
1020   if (button->use_underline)
1021     {
1022       label = gtk_label_new_with_mnemonic (button->label_text);
1023       gtk_label_set_mnemonic_widget (GTK_LABEL (label), GTK_WIDGET (button));
1024     }
1025   else
1026     label = gtk_label_new (button->label_text);
1027
1028   if (priv->align_set)
1029     gtk_misc_set_alignment (GTK_MISC (label), priv->xalign, priv->yalign);
1030
1031   gtk_widget_show (label);
1032   gtk_container_add (GTK_CONTAINER (button), label);
1033 }
1034
1035
1036 GtkWidget*
1037 gtk_button_new_with_label (const gchar *label)
1038 {
1039   return g_object_new (GTK_TYPE_BUTTON, "label", label, NULL);
1040 }
1041
1042 /**
1043  * gtk_button_new_from_stock:
1044  * @stock_id: the name of the stock item
1045  *
1046  * Creates a new #GtkButton containing the image and text from a stock item.
1047  * Some stock ids have preprocessor macros like #GTK_STOCK_OK and
1048  * #GTK_STOCK_APPLY.
1049  *
1050  * If @stock_id is unknown, then it will be treated as a mnemonic
1051  * label (as for gtk_button_new_with_mnemonic()).
1052  *
1053  * Returns: a new #GtkButton
1054  **/
1055 GtkWidget*
1056 gtk_button_new_from_stock (const gchar *stock_id)
1057 {
1058   return g_object_new (GTK_TYPE_BUTTON,
1059                        "label", stock_id,
1060                        "use-stock", TRUE,
1061                        "use-underline", TRUE,
1062                        NULL);
1063 }
1064
1065 /**
1066  * gtk_button_new_with_mnemonic:
1067  * @label: The text of the button, with an underscore in front of the
1068  *         mnemonic character
1069  * @returns: a new #GtkButton
1070  *
1071  * Creates a new #GtkButton containing a label.
1072  * If characters in @label are preceded by an underscore, they are underlined.
1073  * If you need a literal underscore character in a label, use '__' (two
1074  * underscores). The first underlined character represents a keyboard
1075  * accelerator called a mnemonic.
1076  * Pressing Alt and that key activates the button.
1077  **/
1078 GtkWidget*
1079 gtk_button_new_with_mnemonic (const gchar *label)
1080 {
1081   return g_object_new (GTK_TYPE_BUTTON, "label", label, "use-underline", TRUE,  NULL);
1082 }
1083
1084 void
1085 gtk_button_pressed (GtkButton *button)
1086 {
1087   g_return_if_fail (GTK_IS_BUTTON (button));
1088
1089
1090   g_signal_emit (button, button_signals[PRESSED], 0);
1091 }
1092
1093 void
1094 gtk_button_released (GtkButton *button)
1095 {
1096   g_return_if_fail (GTK_IS_BUTTON (button));
1097
1098   g_signal_emit (button, button_signals[RELEASED], 0);
1099 }
1100
1101 void
1102 gtk_button_clicked (GtkButton *button)
1103 {
1104   g_return_if_fail (GTK_IS_BUTTON (button));
1105
1106   g_signal_emit (button, button_signals[CLICKED], 0);
1107 }
1108
1109 void
1110 gtk_button_enter (GtkButton *button)
1111 {
1112   g_return_if_fail (GTK_IS_BUTTON (button));
1113
1114   g_signal_emit (button, button_signals[ENTER], 0);
1115 }
1116
1117 void
1118 gtk_button_leave (GtkButton *button)
1119 {
1120   g_return_if_fail (GTK_IS_BUTTON (button));
1121
1122   g_signal_emit (button, button_signals[LEAVE], 0);
1123 }
1124
1125 void
1126 gtk_button_set_relief (GtkButton *button,
1127                        GtkReliefStyle newrelief)
1128 {
1129   g_return_if_fail (GTK_IS_BUTTON (button));
1130
1131   if (newrelief != button->relief)
1132     {
1133        button->relief = newrelief;
1134        g_object_notify (G_OBJECT (button), "relief");
1135        gtk_widget_queue_draw (GTK_WIDGET (button));
1136     }
1137 }
1138
1139 GtkReliefStyle
1140 gtk_button_get_relief (GtkButton *button)
1141 {
1142   g_return_val_if_fail (GTK_IS_BUTTON (button), GTK_RELIEF_NORMAL);
1143
1144   return button->relief;
1145 }
1146
1147 static void
1148 gtk_button_realize (GtkWidget *widget)
1149 {
1150   GtkButton *button;
1151   GdkWindowAttr attributes;
1152   gint attributes_mask;
1153   gint border_width;
1154
1155   button = GTK_BUTTON (widget);
1156   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
1157
1158   border_width = GTK_CONTAINER (widget)->border_width;
1159
1160   attributes.window_type = GDK_WINDOW_CHILD;
1161   attributes.x = widget->allocation.x + border_width;
1162   attributes.y = widget->allocation.y + border_width;
1163   attributes.width = widget->allocation.width - border_width * 2;
1164   attributes.height = widget->allocation.height - border_width * 2;
1165   attributes.wclass = GDK_INPUT_ONLY;
1166   attributes.event_mask = gtk_widget_get_events (widget);
1167   attributes.event_mask |= (GDK_BUTTON_PRESS_MASK |
1168                             GDK_BUTTON_RELEASE_MASK |
1169                             GDK_ENTER_NOTIFY_MASK |
1170                             GDK_LEAVE_NOTIFY_MASK);
1171
1172   attributes_mask = GDK_WA_X | GDK_WA_Y;
1173
1174   widget->window = gtk_widget_get_parent_window (widget);
1175   g_object_ref (widget->window);
1176
1177   button->event_window = gdk_window_new (gtk_widget_get_parent_window (widget),
1178                                          &attributes, attributes_mask);
1179   gdk_window_set_user_data (button->event_window, button);
1180
1181   widget->style = gtk_style_attach (widget->style, widget->window);
1182 }
1183
1184 static void
1185 gtk_button_unrealize (GtkWidget *widget)
1186 {
1187   GtkButton *button = GTK_BUTTON (widget);
1188
1189   if (button->activate_timeout)
1190     gtk_button_finish_activate (button, FALSE);
1191
1192   if (button->event_window)
1193     {
1194       gdk_window_set_user_data (button->event_window, NULL);
1195       gdk_window_destroy (button->event_window);
1196       button->event_window = NULL;
1197     }
1198
1199   GTK_WIDGET_CLASS (gtk_button_parent_class)->unrealize (widget);
1200 }
1201
1202 static void
1203 gtk_button_map (GtkWidget *widget)
1204 {
1205   GtkButton *button = GTK_BUTTON (widget);
1206
1207   GTK_WIDGET_CLASS (gtk_button_parent_class)->map (widget);
1208
1209   if (button->event_window)
1210     gdk_window_show (button->event_window);
1211 }
1212
1213 static void
1214 gtk_button_unmap (GtkWidget *widget)
1215 {
1216   GtkButton *button = GTK_BUTTON (widget);
1217
1218   if (button->event_window)
1219     gdk_window_hide (button->event_window);
1220
1221   GTK_WIDGET_CLASS (gtk_button_parent_class)->unmap (widget);
1222 }
1223
1224 static void
1225 gtk_button_update_image_spacing (GtkButton *button)
1226 {
1227   GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (button);
1228   GtkWidget *child;
1229   gint spacing;
1230
1231   /* Keep in sync with gtk_button_construct_child,
1232    * we only want to update the spacing if the box
1233    * was constructed there.
1234    */
1235   if (!button->constructed || !priv->image)
1236     return;
1237
1238   child = GTK_BIN (button)->child;
1239   if (GTK_IS_ALIGNMENT (child))
1240     {
1241       child = GTK_BIN (child)->child;
1242       if (GTK_IS_BOX (child))
1243         {
1244           gtk_widget_style_get (GTK_WIDGET (button),
1245                                 "image-spacing", &spacing,
1246                                 NULL);
1247
1248           gtk_box_set_spacing (GTK_BOX (child), spacing);
1249         }
1250     }
1251 }
1252
1253 static void
1254 gtk_button_style_set (GtkWidget *widget,
1255                       GtkStyle  *prev_style)
1256 {
1257   gtk_button_update_image_spacing (GTK_BUTTON (widget));
1258 }
1259
1260 static void
1261 gtk_button_get_props (GtkButton *button,
1262                       GtkBorder *default_border,
1263                       GtkBorder *default_outside_border,
1264                       GtkBorder *inner_border,
1265                       gboolean  *interior_focus)
1266 {
1267   GtkWidget *widget =  GTK_WIDGET (button);
1268   GtkBorder *tmp_border;
1269
1270   if (default_border)
1271     {
1272       gtk_widget_style_get (widget, "default-border", &tmp_border, NULL);
1273
1274       if (tmp_border)
1275         {
1276           *default_border = *tmp_border;
1277           gtk_border_free (tmp_border);
1278         }
1279       else
1280         *default_border = default_default_border;
1281     }
1282
1283   if (default_outside_border)
1284     {
1285       gtk_widget_style_get (widget, "default-outside-border", &tmp_border, NULL);
1286
1287       if (tmp_border)
1288         {
1289           *default_outside_border = *tmp_border;
1290           gtk_border_free (tmp_border);
1291         }
1292       else
1293         *default_outside_border = default_default_outside_border;
1294     }
1295
1296   if (inner_border)
1297     {
1298       gtk_widget_style_get (widget, "inner-border", &tmp_border, NULL);
1299
1300       if (tmp_border)
1301         {
1302           *inner_border = *tmp_border;
1303           gtk_border_free (tmp_border);
1304         }
1305       else
1306         *inner_border = default_inner_border;
1307     }
1308
1309   if (interior_focus)
1310     gtk_widget_style_get (widget, "interior-focus", interior_focus, NULL);
1311 }
1312
1313 static void
1314 gtk_button_size_request (GtkWidget      *widget,
1315                          GtkRequisition *requisition)
1316 {
1317   GtkButton *button = GTK_BUTTON (widget);
1318   GtkBorder default_border;
1319   GtkBorder inner_border;
1320   gint focus_width;
1321   gint focus_pad;
1322
1323   gtk_button_get_props (button, &default_border, NULL, &inner_border, NULL);
1324   gtk_widget_style_get (GTK_WIDGET (widget),
1325                         "focus-line-width", &focus_width,
1326                         "focus-padding", &focus_pad,
1327                         NULL);
1328
1329   requisition->width = ((GTK_CONTAINER (widget)->border_width +
1330                          GTK_WIDGET (widget)->style->xthickness) * 2 +
1331                         inner_border.left + inner_border.right);
1332   requisition->height = ((GTK_CONTAINER (widget)->border_width +
1333                           GTK_WIDGET (widget)->style->ythickness) * 2 +
1334                          inner_border.top + inner_border.bottom);
1335
1336   if (GTK_WIDGET_CAN_DEFAULT (widget))
1337     {
1338       requisition->width += default_border.left + default_border.right;
1339       requisition->height += default_border.top + default_border.bottom;
1340     }
1341
1342   if (GTK_BIN (button)->child && GTK_WIDGET_VISIBLE (GTK_BIN (button)->child))
1343     {
1344       GtkRequisition child_requisition;
1345
1346       gtk_widget_size_request (GTK_BIN (button)->child, &child_requisition);
1347
1348       requisition->width += child_requisition.width;
1349       requisition->height += child_requisition.height;
1350     }
1351
1352   requisition->width += 2 * (focus_width + focus_pad);
1353   requisition->height += 2 * (focus_width + focus_pad);
1354 }
1355
1356 static void
1357 gtk_button_size_allocate (GtkWidget     *widget,
1358                           GtkAllocation *allocation)
1359 {
1360   GtkButton *button = GTK_BUTTON (widget);
1361   GtkAllocation child_allocation;
1362
1363   gint border_width = GTK_CONTAINER (widget)->border_width;
1364   gint xthickness = GTK_WIDGET (widget)->style->xthickness;
1365   gint ythickness = GTK_WIDGET (widget)->style->ythickness;
1366   GtkBorder default_border;
1367   GtkBorder inner_border;
1368   gint focus_width;
1369   gint focus_pad;
1370
1371   gtk_button_get_props (button, &default_border, NULL, &inner_border, NULL);
1372   gtk_widget_style_get (GTK_WIDGET (widget),
1373                         "focus-line-width", &focus_width,
1374                         "focus-padding", &focus_pad,
1375                         NULL);
1376
1377
1378   widget->allocation = *allocation;
1379
1380   if (GTK_WIDGET_REALIZED (widget))
1381     gdk_window_move_resize (button->event_window,
1382                             widget->allocation.x + border_width,
1383                             widget->allocation.y + border_width,
1384                             widget->allocation.width - border_width * 2,
1385                             widget->allocation.height - border_width * 2);
1386
1387   if (GTK_BIN (button)->child && GTK_WIDGET_VISIBLE (GTK_BIN (button)->child))
1388     {
1389       child_allocation.x = widget->allocation.x + border_width + inner_border.left + xthickness;
1390       child_allocation.y = widget->allocation.y + border_width + inner_border.top + ythickness;
1391
1392       child_allocation.width = MAX (1, widget->allocation.width -
1393                                     xthickness * 2 -
1394                                     inner_border.left -
1395                                     inner_border.right -
1396                                     border_width * 2);
1397       child_allocation.height = MAX (1, widget->allocation.height -
1398                                      ythickness * 2 -
1399                                      inner_border.top -
1400                                      inner_border.bottom -
1401                                      border_width * 2);
1402
1403       if (GTK_WIDGET_CAN_DEFAULT (button))
1404         {
1405           child_allocation.x += default_border.left;
1406           child_allocation.y += default_border.top;
1407           child_allocation.width =  MAX (1, child_allocation.width - default_border.left - default_border.right);
1408           child_allocation.height = MAX (1, child_allocation.height - default_border.top - default_border.bottom);
1409         }
1410
1411       if (GTK_WIDGET_CAN_FOCUS (button))
1412         {
1413           child_allocation.x += focus_width + focus_pad;
1414           child_allocation.y += focus_width + focus_pad;
1415           child_allocation.width =  MAX (1, child_allocation.width - (focus_width + focus_pad) * 2);
1416           child_allocation.height = MAX (1, child_allocation.height - (focus_width + focus_pad) * 2);
1417         }
1418
1419       if (button->depressed)
1420         {
1421           gint child_displacement_x;
1422           gint child_displacement_y;
1423
1424           gtk_widget_style_get (widget,
1425                                 "child-displacement-x", &child_displacement_x,
1426                                 "child-displacement-y", &child_displacement_y,
1427                                 NULL);
1428           child_allocation.x += child_displacement_x;
1429           child_allocation.y += child_displacement_y;
1430         }
1431
1432       gtk_widget_size_allocate (GTK_BIN (button)->child, &child_allocation);
1433     }
1434 }
1435
1436 void
1437 _gtk_button_paint (GtkButton          *button,
1438                    const GdkRectangle *area,
1439                    GtkStateType        state_type,
1440                    GtkShadowType       shadow_type,
1441                    const gchar        *main_detail,
1442                    const gchar        *default_detail)
1443 {
1444   GtkWidget *widget;
1445   gint width, height;
1446   gint x, y;
1447   gint border_width;
1448   GtkBorder default_border;
1449   GtkBorder default_outside_border;
1450   gboolean interior_focus;
1451   gint focus_width;
1452   gint focus_pad;
1453
1454   if (GTK_WIDGET_DRAWABLE (button))
1455     {
1456       widget = GTK_WIDGET (button);
1457       border_width = GTK_CONTAINER (widget)->border_width;
1458
1459       gtk_button_get_props (button, &default_border, &default_outside_border, NULL, &interior_focus);
1460       gtk_widget_style_get (GTK_WIDGET (widget),
1461                             "focus-line-width", &focus_width,
1462                             "focus-padding", &focus_pad,
1463                             NULL);
1464
1465       x = widget->allocation.x + border_width;
1466       y = widget->allocation.y + border_width;
1467       width = widget->allocation.width - border_width * 2;
1468       height = widget->allocation.height - border_width * 2;
1469
1470       if (GTK_WIDGET_HAS_DEFAULT (widget) &&
1471           GTK_BUTTON (widget)->relief == GTK_RELIEF_NORMAL)
1472         {
1473           gtk_paint_box (widget->style, widget->window,
1474                          GTK_STATE_NORMAL, GTK_SHADOW_IN,
1475                          area, widget, "buttondefault",
1476                          x, y, width, height);
1477
1478           x += default_border.left;
1479           y += default_border.top;
1480           width -= default_border.left + default_border.right;
1481           height -= default_border.top + default_border.bottom;
1482         }
1483       else if (GTK_WIDGET_CAN_DEFAULT (widget))
1484         {
1485           x += default_outside_border.left;
1486           y += default_outside_border.top;
1487           width -= default_outside_border.left + default_outside_border.right;
1488           height -= default_outside_border.top + default_outside_border.bottom;
1489         }
1490
1491       if (!interior_focus && GTK_WIDGET_HAS_FOCUS (widget))
1492         {
1493           x += focus_width + focus_pad;
1494           y += focus_width + focus_pad;
1495           width -= 2 * (focus_width + focus_pad);
1496           height -= 2 * (focus_width + focus_pad);
1497         }
1498
1499       if (button->relief != GTK_RELIEF_NONE || button->depressed ||
1500           GTK_WIDGET_STATE(widget) == GTK_STATE_PRELIGHT)
1501         gtk_paint_box (widget->style, widget->window,
1502                        state_type,
1503                        shadow_type, area, widget, "button",
1504                        x, y, width, height);
1505
1506       if (GTK_WIDGET_HAS_FOCUS (widget))
1507         {
1508           gint child_displacement_x;
1509           gint child_displacement_y;
1510           gboolean displace_focus;
1511
1512           gtk_widget_style_get (GTK_WIDGET (widget),
1513                                 "child-displacement-y", &child_displacement_y,
1514                                 "child-displacement-x", &child_displacement_x,
1515                                 "displace-focus", &displace_focus,
1516                                 NULL);
1517
1518           if (interior_focus)
1519             {
1520               x += widget->style->xthickness + focus_pad;
1521               y += widget->style->ythickness + focus_pad;
1522               width -= 2 * (widget->style->xthickness + focus_pad);
1523               height -=  2 * (widget->style->ythickness + focus_pad);
1524             }
1525           else
1526             {
1527               x -= focus_width + focus_pad;
1528               y -= focus_width + focus_pad;
1529               width += 2 * (focus_width + focus_pad);
1530               height += 2 * (focus_width + focus_pad);
1531             }
1532
1533           if (button->depressed && displace_focus)
1534             {
1535               x += child_displacement_x;
1536               y += child_displacement_y;
1537             }
1538
1539           gtk_paint_focus (widget->style, widget->window, GTK_WIDGET_STATE (widget),
1540                            area, widget, "button",
1541                            x, y, width, height);
1542         }
1543     }
1544 }
1545
1546 static gboolean
1547 gtk_button_expose (GtkWidget      *widget,
1548                    GdkEventExpose *event)
1549 {
1550   if (GTK_WIDGET_DRAWABLE (widget))
1551     {
1552       GtkButton *button = GTK_BUTTON (widget);
1553
1554       _gtk_button_paint (button, &event->area,
1555                          GTK_WIDGET_STATE (widget),
1556                          button->depressed ? GTK_SHADOW_IN : GTK_SHADOW_OUT,
1557                          "button", "buttondefault");
1558
1559       GTK_WIDGET_CLASS (gtk_button_parent_class)->expose_event (widget, event);
1560     }
1561
1562   return FALSE;
1563 }
1564
1565 static gboolean
1566 gtk_button_button_press (GtkWidget      *widget,
1567                          GdkEventButton *event)
1568 {
1569   GtkButton *button;
1570
1571   if (event->type == GDK_BUTTON_PRESS)
1572     {
1573       button = GTK_BUTTON (widget);
1574
1575       if (button->focus_on_click && !GTK_WIDGET_HAS_FOCUS (widget))
1576         gtk_widget_grab_focus (widget);
1577
1578       if (event->button == 1)
1579         gtk_button_pressed (button);
1580     }
1581
1582   return TRUE;
1583 }
1584
1585 static gboolean
1586 gtk_button_button_release (GtkWidget      *widget,
1587                            GdkEventButton *event)
1588 {
1589   GtkButton *button;
1590
1591   if (event->button == 1)
1592     {
1593       button = GTK_BUTTON (widget);
1594       gtk_button_released (button);
1595     }
1596
1597   return TRUE;
1598 }
1599
1600 static gboolean
1601 gtk_button_grab_broken (GtkWidget          *widget,
1602                         GdkEventGrabBroken *event)
1603 {
1604   GtkButton *button = GTK_BUTTON (widget);
1605   gboolean save_in;
1606
1607   /* Simulate a button release without the pointer in the button */
1608   if (button->button_down)
1609     {
1610       save_in = button->in_button;
1611       button->in_button = FALSE;
1612       gtk_button_released (button);
1613       if (save_in != button->in_button)
1614         {
1615           button->in_button = save_in;
1616           gtk_button_update_state (button);
1617         }
1618     }
1619
1620   return TRUE;
1621 }
1622
1623 static gboolean
1624 gtk_button_key_release (GtkWidget   *widget,
1625                         GdkEventKey *event)
1626 {
1627   GtkButton *button = GTK_BUTTON (widget);
1628
1629   if (button->activate_timeout)
1630     {
1631       gtk_button_finish_activate (button, TRUE);
1632       return TRUE;
1633     }
1634   else if (GTK_WIDGET_CLASS (gtk_button_parent_class)->key_release_event)
1635     return GTK_WIDGET_CLASS (gtk_button_parent_class)->key_release_event (widget, event);
1636   else
1637     return FALSE;
1638 }
1639
1640 static gboolean
1641 gtk_button_enter_notify (GtkWidget        *widget,
1642                          GdkEventCrossing *event)
1643 {
1644   GtkButton *button;
1645   GtkWidget *event_widget;
1646
1647   button = GTK_BUTTON (widget);
1648   event_widget = gtk_get_event_widget ((GdkEvent*) event);
1649
1650   if ((event_widget == widget) &&
1651       (event->detail != GDK_NOTIFY_INFERIOR))
1652     {
1653       button->in_button = TRUE;
1654       gtk_button_enter (button);
1655     }
1656
1657   return FALSE;
1658 }
1659
1660 static gboolean
1661 gtk_button_leave_notify (GtkWidget        *widget,
1662                          GdkEventCrossing *event)
1663 {
1664   GtkButton *button;
1665   GtkWidget *event_widget;
1666
1667   button = GTK_BUTTON (widget);
1668   event_widget = gtk_get_event_widget ((GdkEvent*) event);
1669
1670   if ((event_widget == widget) &&
1671       (event->detail != GDK_NOTIFY_INFERIOR) &&
1672       (GTK_WIDGET_SENSITIVE (event_widget)))
1673     {
1674       button->in_button = FALSE;
1675       gtk_button_leave (button);
1676     }
1677
1678   return FALSE;
1679 }
1680
1681 static void
1682 gtk_real_button_pressed (GtkButton *button)
1683 {
1684   if (button->activate_timeout)
1685     return;
1686
1687   button->button_down = TRUE;
1688   gtk_button_update_state (button);
1689 }
1690
1691 static void
1692 gtk_real_button_released (GtkButton *button)
1693 {
1694   if (button->button_down)
1695     {
1696       button->button_down = FALSE;
1697
1698       if (button->activate_timeout)
1699         return;
1700
1701       if (button->in_button)
1702         gtk_button_clicked (button);
1703
1704       gtk_button_update_state (button);
1705     }
1706 }
1707
1708 static void
1709 gtk_real_button_clicked (GtkButton *button)
1710 {
1711   GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (button);
1712
1713   if (priv->action)
1714     gtk_action_activate (priv->action);
1715 }
1716
1717 static gboolean
1718 button_activate_timeout (gpointer data)
1719 {
1720   gtk_button_finish_activate (data, TRUE);
1721
1722   return FALSE;
1723 }
1724
1725 static void
1726 gtk_real_button_activate (GtkButton *button)
1727 {
1728   GtkWidget *widget = GTK_WIDGET (button);
1729   GtkButtonPrivate *priv;
1730   guint32 time;
1731
1732   priv = GTK_BUTTON_GET_PRIVATE (button);
1733
1734   if (GTK_WIDGET_REALIZED (button) && !button->activate_timeout)
1735     {
1736       time = gtk_get_current_event_time ();
1737       if (gdk_keyboard_grab (button->event_window, TRUE, time) ==
1738           GDK_GRAB_SUCCESS)
1739         {
1740           priv->has_grab = TRUE;
1741           priv->grab_time = time;
1742         }
1743
1744       gtk_grab_add (widget);
1745
1746       button->activate_timeout = gdk_threads_add_timeout (ACTIVATE_TIMEOUT,
1747                                                 button_activate_timeout,
1748                                                 button);
1749       button->button_down = TRUE;
1750       gtk_button_update_state (button);
1751       gtk_widget_queue_draw (GTK_WIDGET (button));
1752     }
1753 }
1754
1755 static void
1756 gtk_button_finish_activate (GtkButton *button,
1757                             gboolean   do_it)
1758 {
1759   GtkWidget *widget = GTK_WIDGET (button);
1760   GtkButtonPrivate *priv;
1761
1762   priv = GTK_BUTTON_GET_PRIVATE (button);
1763
1764   g_source_remove (button->activate_timeout);
1765   button->activate_timeout = 0;
1766
1767   if (priv->has_grab)
1768     {
1769       gdk_display_keyboard_ungrab (gtk_widget_get_display (widget),
1770                                    priv->grab_time);
1771     }
1772   gtk_grab_remove (widget);
1773
1774   button->button_down = FALSE;
1775
1776   gtk_button_update_state (button);
1777   gtk_widget_queue_draw (GTK_WIDGET (button));
1778
1779   if (do_it)
1780     gtk_button_clicked (button);
1781 }
1782
1783 /**
1784  * gtk_button_set_label:
1785  * @button: a #GtkButton
1786  * @label: a string
1787  *
1788  * Sets the text of the label of the button to @str. This text is
1789  * also used to select the stock item if gtk_button_set_use_stock()
1790  * is used.
1791  *
1792  * This will also clear any previously set labels.
1793  **/
1794 void
1795 gtk_button_set_label (GtkButton   *button,
1796                       const gchar *label)
1797 {
1798   gchar *new_label;
1799
1800   g_return_if_fail (GTK_IS_BUTTON (button));
1801
1802   new_label = g_strdup (label);
1803   g_free (button->label_text);
1804   button->label_text = new_label;
1805
1806   gtk_button_construct_child (button);
1807
1808   g_object_notify (G_OBJECT (button), "label");
1809 }
1810
1811 /**
1812  * gtk_button_get_label:
1813  * @button: a #GtkButton
1814  *
1815  * Fetches the text from the label of the button, as set by
1816  * gtk_button_set_label(). If the label text has not
1817  * been set the return value will be %NULL. This will be the
1818  * case if you create an empty button with gtk_button_new() to
1819  * use as a container.
1820  *
1821  * Return value: The text of the label widget. This string is owned
1822  * by the widget and must not be modified or freed.
1823  **/
1824 G_CONST_RETURN gchar *
1825 gtk_button_get_label (GtkButton *button)
1826 {
1827   g_return_val_if_fail (GTK_IS_BUTTON (button), NULL);
1828
1829   return button->label_text;
1830 }
1831
1832 /**
1833  * gtk_button_set_use_underline:
1834  * @button: a #GtkButton
1835  * @use_underline: %TRUE if underlines in the text indicate mnemonics
1836  *
1837  * If true, an underline in the text of the button label indicates
1838  * the next character should be used for the mnemonic accelerator key.
1839  */
1840 void
1841 gtk_button_set_use_underline (GtkButton *button,
1842                               gboolean   use_underline)
1843 {
1844   g_return_if_fail (GTK_IS_BUTTON (button));
1845
1846   use_underline = use_underline != FALSE;
1847
1848   if (use_underline != button->use_underline)
1849     {
1850       button->use_underline = use_underline;
1851
1852       gtk_button_construct_child (button);
1853
1854       g_object_notify (G_OBJECT (button), "use-underline");
1855     }
1856 }
1857
1858 /**
1859  * gtk_button_get_use_underline:
1860  * @button: a #GtkButton
1861  *
1862  * Returns whether an embedded underline in the button label indicates a
1863  * mnemonic. See gtk_button_set_use_underline ().
1864  *
1865  * Return value: %TRUE if an embedded underline in the button label
1866  *               indicates the mnemonic accelerator keys.
1867  **/
1868 gboolean
1869 gtk_button_get_use_underline (GtkButton *button)
1870 {
1871   g_return_val_if_fail (GTK_IS_BUTTON (button), FALSE);
1872
1873   return button->use_underline;
1874 }
1875
1876 /**
1877  * gtk_button_set_use_stock:
1878  * @button: a #GtkButton
1879  * @use_stock: %TRUE if the button should use a stock item
1880  *
1881  * If %TRUE, the label set on the button is used as a
1882  * stock id to select the stock item for the button.
1883  */
1884 void
1885 gtk_button_set_use_stock (GtkButton *button,
1886                           gboolean   use_stock)
1887 {
1888   g_return_if_fail (GTK_IS_BUTTON (button));
1889
1890   use_stock = use_stock != FALSE;
1891
1892   if (use_stock != button->use_stock)
1893     {
1894       button->use_stock = use_stock;
1895
1896       gtk_button_construct_child (button);
1897
1898       g_object_notify (G_OBJECT (button), "use-stock");
1899     }
1900 }
1901
1902 /**
1903  * gtk_button_get_use_stock:
1904  * @button: a #GtkButton
1905  *
1906  * Returns whether the button label is a stock item.
1907  *
1908  * Return value: %TRUE if the button label is used to
1909  *               select a stock item instead of being
1910  *               used directly as the label text.
1911  */
1912 gboolean
1913 gtk_button_get_use_stock (GtkButton *button)
1914 {
1915   g_return_val_if_fail (GTK_IS_BUTTON (button), FALSE);
1916
1917   return button->use_stock;
1918 }
1919
1920 /**
1921  * gtk_button_set_focus_on_click:
1922  * @button: a #GtkButton
1923  * @focus_on_click: whether the button grabs focus when clicked with the mouse
1924  *
1925  * Sets whether the button will grab focus when it is clicked with the mouse.
1926  * Making mouse clicks not grab focus is useful in places like toolbars where
1927  * you don't want the keyboard focus removed from the main area of the
1928  * application.
1929  *
1930  * Since: 2.4
1931  **/
1932 void
1933 gtk_button_set_focus_on_click (GtkButton *button,
1934                                gboolean   focus_on_click)
1935 {
1936   g_return_if_fail (GTK_IS_BUTTON (button));
1937
1938   focus_on_click = focus_on_click != FALSE;
1939
1940   if (button->focus_on_click != focus_on_click)
1941     {
1942       button->focus_on_click = focus_on_click;
1943
1944       g_object_notify (G_OBJECT (button), "focus-on-click");
1945     }
1946 }
1947
1948 /**
1949  * gtk_button_get_focus_on_click:
1950  * @button: a #GtkButton
1951  *
1952  * Returns whether the button grabs focus when it is clicked with the mouse.
1953  * See gtk_button_set_focus_on_click().
1954  *
1955  * Return value: %TRUE if the button grabs focus when it is clicked with
1956  *               the mouse.
1957  *
1958  * Since: 2.4
1959  **/
1960 gboolean
1961 gtk_button_get_focus_on_click (GtkButton *button)
1962 {
1963   g_return_val_if_fail (GTK_IS_BUTTON (button), FALSE);
1964
1965   return button->focus_on_click;
1966 }
1967
1968 /**
1969  * gtk_button_set_alignment:
1970  * @button: a #GtkButton
1971  * @xalign: the horizontal position of the child, 0.0 is left aligned,
1972  *   1.0 is right aligned
1973  * @yalign: the vertical position of the child, 0.0 is top aligned,
1974  *   1.0 is bottom aligned
1975  *
1976  * Sets the alignment of the child. This property has no effect unless
1977  * the child is a #GtkMisc or a #GtkAligment.
1978  *
1979  * Since: 2.4
1980  */
1981 void
1982 gtk_button_set_alignment (GtkButton *button,
1983                           gfloat     xalign,
1984                           gfloat     yalign)
1985 {
1986   GtkButtonPrivate *priv;
1987
1988   g_return_if_fail (GTK_IS_BUTTON (button));
1989
1990   priv = GTK_BUTTON_GET_PRIVATE (button);
1991
1992   priv->xalign = xalign;
1993   priv->yalign = yalign;
1994   priv->align_set = 1;
1995
1996   maybe_set_alignment (button, GTK_BIN (button)->child);
1997
1998   g_object_freeze_notify (G_OBJECT (button));
1999   g_object_notify (G_OBJECT (button), "xalign");
2000   g_object_notify (G_OBJECT (button), "yalign");
2001   g_object_thaw_notify (G_OBJECT (button));
2002 }
2003
2004 /**
2005  * gtk_button_get_alignment:
2006  * @button: a #GtkButton
2007  * @xalign: return location for horizontal alignment
2008  * @yalign: return location for vertical alignment
2009  *
2010  * Gets the alignment of the child in the button.
2011  *
2012  * Since: 2.4
2013  */
2014 void
2015 gtk_button_get_alignment (GtkButton *button,
2016                           gfloat    *xalign,
2017                           gfloat    *yalign)
2018 {
2019   GtkButtonPrivate *priv;
2020
2021   g_return_if_fail (GTK_IS_BUTTON (button));
2022
2023   priv = GTK_BUTTON_GET_PRIVATE (button);
2024
2025   if (xalign)
2026     *xalign = priv->xalign;
2027
2028   if (yalign)
2029     *yalign = priv->yalign;
2030 }
2031
2032 /**
2033  * _gtk_button_set_depressed:
2034  * @button: a #GtkButton
2035  * @depressed: %TRUE if the button should be drawn with a recessed shadow.
2036  *
2037  * Sets whether the button is currently drawn as down or not. This is
2038  * purely a visual setting, and is meant only for use by derived widgets
2039  * such as #GtkToggleButton.
2040  **/
2041 void
2042 _gtk_button_set_depressed (GtkButton *button,
2043                            gboolean   depressed)
2044 {
2045   GtkWidget *widget = GTK_WIDGET (button);
2046
2047   depressed = depressed != FALSE;
2048
2049   if (depressed != button->depressed)
2050     {
2051       button->depressed = depressed;
2052       gtk_widget_queue_resize (widget);
2053     }
2054 }
2055
2056 static void
2057 gtk_button_update_state (GtkButton *button)
2058 {
2059   gboolean depressed;
2060   GtkStateType new_state;
2061
2062   if (button->activate_timeout)
2063     depressed = button->depress_on_activate;
2064   else
2065     depressed = button->in_button && button->button_down;
2066
2067   if (button->in_button && (!button->button_down || !depressed))
2068     new_state = GTK_STATE_PRELIGHT;
2069   else
2070     new_state = depressed ? GTK_STATE_ACTIVE : GTK_STATE_NORMAL;
2071
2072   _gtk_button_set_depressed (button, depressed);
2073   gtk_widget_set_state (GTK_WIDGET (button), new_state);
2074 }
2075
2076 static void
2077 show_image_change_notify (GtkButton *button)
2078 {
2079   GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (button);
2080
2081   if (priv->image)
2082     {
2083       if (show_image (button))
2084         gtk_widget_show (priv->image);
2085       else
2086         gtk_widget_hide (priv->image);
2087     }
2088 }
2089
2090 static void
2091 traverse_container (GtkWidget *widget,
2092                     gpointer   data)
2093 {
2094   if (GTK_IS_BUTTON (widget))
2095     show_image_change_notify (GTK_BUTTON (widget));
2096   else if (GTK_IS_CONTAINER (widget))
2097     gtk_container_forall (GTK_CONTAINER (widget), traverse_container, NULL);
2098 }
2099
2100 static void
2101 gtk_button_setting_changed (GtkSettings *settings)
2102 {
2103   GList *list, *l;
2104
2105   list = gtk_window_list_toplevels ();
2106
2107   for (l = list; l; l = l->next)
2108     gtk_container_forall (GTK_CONTAINER (l->data),
2109                           traverse_container, NULL);
2110
2111   g_list_free (list);
2112 }
2113
2114
2115 static void
2116 gtk_button_screen_changed (GtkWidget *widget,
2117                            GdkScreen *previous_screen)
2118 {
2119   GtkSettings *settings;
2120   guint show_image_connection;
2121
2122   if (!gtk_widget_has_screen (widget))
2123     return;
2124
2125   settings = gtk_widget_get_settings (widget);
2126
2127   show_image_connection =
2128     GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (settings),
2129                                          "gtk-button-connection"));
2130
2131   if (show_image_connection)
2132     return;
2133
2134   show_image_connection =
2135     g_signal_connect (settings, "notify::gtk-button-images",
2136                       G_CALLBACK (gtk_button_setting_changed), NULL);
2137   g_object_set_data (G_OBJECT (settings),
2138                      I_("gtk-button-connection"),
2139                      GUINT_TO_POINTER (show_image_connection));
2140
2141   show_image_change_notify (GTK_BUTTON (widget));
2142 }
2143
2144 static void
2145 gtk_button_state_changed (GtkWidget    *widget,
2146                           GtkStateType  previous_state)
2147 {
2148   GtkButton *button = GTK_BUTTON (widget);
2149
2150   if (!GTK_WIDGET_IS_SENSITIVE (widget))
2151     {
2152       button->in_button = FALSE;
2153       gtk_real_button_released (button);
2154     }
2155 }
2156
2157 static void
2158 gtk_button_grab_notify (GtkWidget *widget,
2159                         gboolean   was_grabbed)
2160 {
2161   GtkButton *button = GTK_BUTTON (widget);
2162   gboolean save_in;
2163
2164   if (!was_grabbed)
2165     {
2166       save_in = button->in_button;
2167       button->in_button = FALSE;
2168       gtk_real_button_released (button);
2169       if (save_in != button->in_button)
2170         {
2171           button->in_button = save_in;
2172           gtk_button_update_state (button);
2173         }
2174     }
2175 }
2176
2177 /**
2178  * gtk_button_set_image:
2179  * @button: a #GtkButton
2180  * @image: a widget to set as the image for the button
2181  *
2182  * Set the image of @button to the given widget. Note that
2183  * it depends on the #GtkSettings:gtk-button-images setting whether the
2184  * image will be displayed or not, you don't have to call
2185  * gtk_widget_show() on @image yourself.
2186  *
2187  * Since: 2.6
2188  */
2189 void
2190 gtk_button_set_image (GtkButton *button,
2191                       GtkWidget *image)
2192 {
2193   GtkButtonPrivate *priv;
2194
2195   g_return_if_fail (GTK_IS_BUTTON (button));
2196   g_return_if_fail (image == NULL || GTK_IS_WIDGET (image));
2197
2198   priv = GTK_BUTTON_GET_PRIVATE (button);
2199
2200   if (priv->image && priv->image->parent)
2201     gtk_container_remove (GTK_CONTAINER (priv->image->parent), priv->image);
2202
2203   priv->image = image;
2204   priv->image_is_stock = (image == NULL);
2205
2206   gtk_button_construct_child (button);
2207
2208   g_object_notify (G_OBJECT (button), "image");
2209 }
2210
2211 /**
2212  * gtk_button_get_image:
2213  * @button: a #GtkButton
2214  *
2215  * Gets the widget that is currenty set as the image of @button.
2216  * This may have been explicitly set by gtk_button_set_image()
2217  * or constructed by gtk_button_new_from_stock().
2218  *
2219  * Return value: a #GtkWidget or %NULL in case there is no image
2220  *
2221  * Since: 2.6
2222  */
2223 GtkWidget *
2224 gtk_button_get_image (GtkButton *button)
2225 {
2226   GtkButtonPrivate *priv;
2227
2228   g_return_val_if_fail (GTK_IS_BUTTON (button), NULL);
2229
2230   priv = GTK_BUTTON_GET_PRIVATE (button);
2231
2232   return priv->image;
2233 }
2234
2235 /**
2236  * gtk_button_set_image_position:
2237  * @button: a #GtkButton
2238  * @position: the position
2239  *
2240  * Sets the position of the image relative to the text
2241  * inside the button.
2242  *
2243  * Since: 2.10
2244  */
2245 void
2246 gtk_button_set_image_position (GtkButton       *button,
2247                                GtkPositionType  position)
2248 {
2249
2250   GtkButtonPrivate *priv;
2251
2252   g_return_if_fail (GTK_IS_BUTTON (button));
2253   g_return_if_fail (position >= GTK_POS_LEFT && position <= GTK_POS_BOTTOM);
2254
2255   priv = GTK_BUTTON_GET_PRIVATE (button);
2256
2257   if (priv->image_position != position)
2258     {
2259       priv->image_position = position;
2260
2261       gtk_button_construct_child (button);
2262
2263       g_object_notify (G_OBJECT (button), "image-position");
2264     }
2265 }
2266
2267 /**
2268  * gtk_button_get_image_position:
2269  * @button: a #GtkButton
2270  *
2271  * Gets the position of the image relative to the text
2272  * inside the button.
2273  *
2274  * Return value: the position
2275  *
2276  * Since: 2.10
2277  */
2278 GtkPositionType
2279 gtk_button_get_image_position (GtkButton *button)
2280 {
2281   GtkButtonPrivate *priv;
2282
2283   g_return_val_if_fail (GTK_IS_BUTTON (button), GTK_POS_LEFT);
2284
2285   priv = GTK_BUTTON_GET_PRIVATE (button);
2286
2287   return priv->image_position;
2288 }
2289
2290
2291 #define __GTK_BUTTON_C__
2292 #include "gtkaliasdef.c"