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