/* GTK - The GIMP Toolkit

 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/*

 * Modified by the GTK+ Team and others 1997-2001.  See the AUTHORS

 * file for a list of people on the GTK+ Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 

 */

#include "config.h"

#include <string.h>

#include "gtkalignment.h"

#include "gtkbutton.h"

#include "gtklabel.h"

#include "gtkmain.h"

#include "gtkmarshalers.h"

#include "gtkimage.h"

#include "gtkhbox.h"

#include "gtkvbox.h"

#include "gtkstock.h"

#include "gtkiconfactory.h"

#include "gtkactivatable.h"

#include "gtkprivate.h"

#include "gtkintl.h"

#include "gtkalias.h"

static const GtkBorder default_default_border = { 1, 1, 1, 1 };

static const GtkBorder default_default_outside_border = { 0, 0, 0, 0 };

static const GtkBorder default_inner_border = { 1, 1, 1, 1 };

/* Time out before giving up on getting a key release when animating

 * the close button.

 */

#define ACTIVATE_TIMEOUT 250

enum {

  PRESSED,

  RELEASED,

  CLICKED,

  ENTER,

  LEAVE,

  ACTIVATE,

  LAST_SIGNAL

};

enum {

  PROP_0,

  PROP_LABEL,

  PROP_IMAGE,

  PROP_RELIEF,

  PROP_USE_UNDERLINE,

  PROP_USE_STOCK,

  PROP_FOCUS_ON_CLICK,

  PROP_XALIGN,

  PROP_YALIGN,

  PROP_IMAGE_POSITION,

  /* activatable properties */

  PROP_ACTIVATABLE_RELATED_ACTION,

  PROP_ACTIVATABLE_USE_ACTION_APPEARANCE

};

#define GTK_BUTTON_GET_PRIVATE(o)       (G_TYPE_INSTANCE_GET_PRIVATE ((o), GTK_TYPE_BUTTON, GtkButtonPrivate))

typedef struct _GtkButtonPrivate GtkButtonPrivate;

struct _GtkButtonPrivate

{

  gfloat          xalign;

  gfloat          yalign;

  GtkWidget      *image;

  guint           align_set             : 1;

  guint           image_is_stock        : 1;

  guint           has_grab              : 1;

  guint           use_action_appearance : 1;

  guint32         grab_time;

  GtkPositionType image_position;

  GtkAction      *action;

};

static void gtk_button_destroy        (GtkObject          *object);

static void gtk_button_dispose        (GObject            *object);

static void gtk_button_set_property   (GObject            *object,

                                       guint               prop_id,

                                       const GValue       *value,

                                       GParamSpec         *pspec);

static void gtk_button_get_property   (GObject            *object,

                                       guint               prop_id,

                                       GValue             *value,

                                       GParamSpec         *pspec);

static void gtk_button_screen_changed (GtkWidget          *widget,

				       GdkScreen          *previous_screen);

static void gtk_button_realize (GtkWidget * widget);

static void gtk_button_unrealize (GtkWidget * widget);

static void gtk_button_map (GtkWidget * widget);

static void gtk_button_unmap (GtkWidget * widget);

static void gtk_button_style_set (GtkWidget * widget, GtkStyle * prev_style);

static void gtk_button_size_request (GtkWidget * widget,

				     GtkRequisition * requisition);

static void gtk_button_size_allocate (GtkWidget * widget,

				      GtkAllocation * allocation);

static gint gtk_button_expose (GtkWidget * widget, GdkEventExpose * event);

static gint gtk_button_button_press (GtkWidget * widget,

				     GdkEventButton * event);

static gint gtk_button_button_release (GtkWidget * widget,

				       GdkEventButton * event);

static gint gtk_button_grab_broken (GtkWidget * widget,

				    GdkEventGrabBroken * event);

static gint gtk_button_key_release (GtkWidget * widget, GdkEventKey * event);

static gint gtk_button_enter_notify (GtkWidget * widget,

				     GdkEventCrossing * event);

static gint gtk_button_leave_notify (GtkWidget * widget,

				     GdkEventCrossing * event);

static void gtk_real_button_pressed (GtkButton * button);

static void gtk_real_button_released (GtkButton * button);

static void gtk_real_button_clicked (GtkButton * button);

static void gtk_real_button_activate  (GtkButton          *button);

static void gtk_button_update_state   (GtkButton          *button);

static void gtk_button_add            (GtkContainer       *container,

			               GtkWidget          *widget);

static GType gtk_button_child_type    (GtkContainer       *container);

static void gtk_button_finish_activate (GtkButton         *button,

					gboolean           do_it);

static GObject*	gtk_button_constructor (GType                  type,

					guint                  n_construct_properties,

					GObjectConstructParam *construct_params);

static void gtk_button_construct_child (GtkButton             *button);

static void gtk_button_state_changed   (GtkWidget             *widget,

					GtkStateType           previous_state);

static void gtk_button_grab_notify     (GtkWidget             *widget,

					gboolean               was_grabbed);

static void gtk_button_activatable_interface_init         (GtkActivatableIface  *iface);

static void gtk_button_update                    (GtkActivatable       *activatable,

				                  GtkAction            *action,

			                          const gchar          *property_name);

static void gtk_button_sync_action_properties    (GtkActivatable       *activatable,

                                                  GtkAction            *action);

static void gtk_button_set_related_action        (GtkButton            *button,

					          GtkAction            *action);

static void gtk_button_set_use_action_appearance (GtkButton            *button,

						  gboolean              use_appearance);

static guint button_signals[LAST_SIGNAL] = { 0 };

G_DEFINE_TYPE_WITH_CODE (GtkButton, gtk_button, GTK_TYPE_BIN,

			 G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTIVATABLE,

						gtk_button_activatable_interface_init))

static void

gtk_button_class_init (GtkButtonClass *klass)

{

  GObjectClass *gobject_class;

  GtkObjectClass *object_class;

  GtkWidgetClass *widget_class;

  GtkContainerClass *container_class;

  gobject_class = G_OBJECT_CLASS (klass);

  object_class = (GtkObjectClass*) klass;

  widget_class = (GtkWidgetClass*) klass;

  container_class = (GtkContainerClass*) klass;

  gobject_class->constructor  = gtk_button_constructor;

  gobject_class->dispose      = gtk_button_dispose;

  gobject_class->set_property = gtk_button_set_property;

  gobject_class->get_property = gtk_button_get_property;

  object_class->destroy = gtk_button_destroy;

  widget_class->screen_changed = gtk_button_screen_changed;

  widget_class->realize = gtk_button_realize;

  widget_class->unrealize = gtk_button_unrealize;

  widget_class->map = gtk_button_map;

  widget_class->unmap = gtk_button_unmap;

  widget_class->style_set = gtk_button_style_set;

  widget_class->size_request = gtk_button_size_request;

  widget_class->size_allocate = gtk_button_size_allocate;

  widget_class->expose_event = gtk_button_expose;

  widget_class->button_press_event = gtk_button_button_press;

  widget_class->button_release_event = gtk_button_button_release;

  widget_class->grab_broken_event = gtk_button_grab_broken;

  widget_class->key_release_event = gtk_button_key_release;

  widget_class->enter_notify_event = gtk_button_enter_notify;

  widget_class->leave_notify_event = gtk_button_leave_notify;

  widget_class->state_changed = gtk_button_state_changed;

  widget_class->grab_notify = gtk_button_grab_notify;

  container_class->child_type = gtk_button_child_type;

  container_class->add = gtk_button_add;

  klass->pressed = gtk_real_button_pressed;

  klass->released = gtk_real_button_released;

  klass->clicked = NULL;

  klass->enter = gtk_button_update_state;

  klass->leave = gtk_button_update_state;

  klass->activate = gtk_real_button_activate;

  g_object_class_install_property (gobject_class,

                                   PROP_LABEL,

                                   g_param_spec_string ("label",

                                                        P_("Label"),

                                                        P_("Text of the label widget inside the button, if the button contains a label widget"),

                                                        NULL,

                                                        GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));

  g_object_class_install_property (gobject_class,

                                   PROP_USE_UNDERLINE,

                                   g_param_spec_boolean ("use-underline",

							 P_("Use underline"),

							 P_("If set, an underline in the text indicates the next character should be used for the mnemonic accelerator key"),

                                                        FALSE,

                                                        GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));

  g_object_class_install_property (gobject_class,

                                   PROP_USE_STOCK,

                                   g_param_spec_boolean ("use-stock",

							 P_("Use stock"),

							 P_("If set, the label is used to pick a stock item instead of being displayed"),

                                                        FALSE,

                                                        GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));

  g_object_class_install_property (gobject_class,

                                   PROP_FOCUS_ON_CLICK,

                                   g_param_spec_boolean ("focus-on-click",

							 P_("Focus on click"),

							 P_("Whether the button grabs focus when it is clicked with the mouse"),

							 TRUE,

							 GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_RELIEF,

                                   g_param_spec_enum ("relief",

                                                      P_("Border relief"),

                                                      P_("The border relief style"),

                                                      GTK_TYPE_RELIEF_STYLE,

                                                      GTK_RELIEF_NORMAL,

                                                      GTK_PARAM_READWRITE));

  /**

   * GtkButton:xalign:

   *

   * If the child of the button is a #GtkMisc or #GtkAlignment, this property 

   * can be used to control it's horizontal alignment. 0.0 is left aligned, 

   * 1.0 is right aligned.

   * 

   * Since: 2.4

   */

  g_object_class_install_property (gobject_class,

                                   PROP_XALIGN,

                                   g_param_spec_float("xalign",

                                                      P_("Horizontal alignment for child"),

                                                      P_("Horizontal position of child in available space. 0.0 is left aligned, 1.0 is right aligned"),

                                                      0.0,

                                                      1.0,

                                                      0.5,

                                                      GTK_PARAM_READWRITE));

  /**

   * GtkButton:yalign:

   *

   * If the child of the button is a #GtkMisc or #GtkAlignment, this property 

   * can be used to control it's vertical alignment. 0.0 is top aligned, 

   * 1.0 is bottom aligned.

   * 

   * Since: 2.4

   */

  g_object_class_install_property (gobject_class,

                                   PROP_YALIGN,

                                   g_param_spec_float("yalign",

                                                      P_("Vertical alignment for child"),

                                                      P_("Vertical position of child in available space. 0.0 is top aligned, 1.0 is bottom aligned"),

                                                      0.0,

                                                      1.0,

                                                      0.5,

                                                      GTK_PARAM_READWRITE));

  /**

   * GtkButton::image:

   * 

   * The child widget to appear next to the button text.

   * 

   * Since: 2.6

   */

  g_object_class_install_property (gobject_class,

                                   PROP_IMAGE,

                                   g_param_spec_object ("image",

                                                        P_("Image widget"),

                                                        P_("Child widget to appear next to the button text"),

                                                        GTK_TYPE_WIDGET,

                                                        GTK_PARAM_READWRITE));

  /**

   * GtkButton:image-position:

   *

   * The position of the image relative to the text inside the button.

   * 

   * Since: 2.10

   */

  g_object_class_install_property (gobject_class,

                                   PROP_IMAGE_POSITION,

                                   g_param_spec_enum ("image-position",

                                            P_("Image position"),

                                                      P_("The position of the image relative to the text"),

                                                      GTK_TYPE_POSITION_TYPE,

                                                      GTK_POS_LEFT,

                                                      GTK_PARAM_READWRITE));

  g_object_class_override_property (gobject_class, PROP_ACTIVATABLE_RELATED_ACTION, "related-action");

  g_object_class_override_property (gobject_class, PROP_ACTIVATABLE_USE_ACTION_APPEARANCE, "use-action-appearance");

  /**

   * GtkButton::pressed:

   * @button: the object that received the signal

   *

   * Emitted when the button is pressed.

   * 

   * Deprecated: 2.8: Use the #GtkWidget::button-press-event signal.

   */ 

  button_signals[PRESSED] =

    g_signal_new (I_("pressed"),

		  G_OBJECT_CLASS_TYPE (object_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkButtonClass, pressed),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  /**

   * GtkButton::released:

   * @button: the object that received the signal

   *

   * Emitted when the button is released.

   * 

   * Deprecated: 2.8: Use the #GtkWidget::button-release-event signal.

   */ 

  button_signals[RELEASED] =

    g_signal_new (I_("released"),

		  G_OBJECT_CLASS_TYPE (object_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkButtonClass, released),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  /**

   * GtkButton::clicked:

   * @button: the object that received the signal

   *

   * Emitted when the button has been activated (pressed and released).

   */ 

  button_signals[CLICKED] =

    g_signal_new (I_("clicked"),

		  G_OBJECT_CLASS_TYPE (object_class),

		  G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,

		  G_STRUCT_OFFSET (GtkButtonClass, clicked),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  /**

   * GtkButton::enter:

   * @button: the object that received the signal

   *

   * Emitted when the pointer enters the button.

   * 

   * Deprecated: 2.8: Use the #GtkWidget::enter-notify-event signal.

   */ 

  button_signals[ENTER] =

    g_signal_new (I_("enter"),

		  G_OBJECT_CLASS_TYPE (object_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkButtonClass, enter),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  /**

   * GtkButton::leave:

   * @button: the object that received the signal

   *

   * Emitted when the pointer leaves the button.

   * 

   * Deprecated: 2.8: Use the #GtkWidget::leave-notify-event signal.

   */ 

  button_signals[LEAVE] =

    g_signal_new (I_("leave"),

		  G_OBJECT_CLASS_TYPE (object_class),

		  G_SIGNAL_RUN_FIRST,

		  G_STRUCT_OFFSET (GtkButtonClass, leave),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  /**

   * GtkButton::activate:

   * @widget: the object which received the signal.

   *

   * The ::activate signal on GtkButton is an action signal and

   * emitting it causes the button to animate press then release. 

   * Applications should never connect to this signal, but use the

   * #GtkButton::clicked signal.

   */

  button_signals[ACTIVATE] =

    g_signal_new (I_("activate"),

		  G_OBJECT_CLASS_TYPE (object_class),

		  G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,

		  G_STRUCT_OFFSET (GtkButtonClass, activate),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  widget_class->activate_signal = button_signals[ACTIVATE];

  /**

   * GtkButton:default-border:

   *

   * The "default-border" style property defines the extra space to add

   * around a button that can become the default widget of its window.

   * For more information about default widgets, see gtk_widget_grab_default().

   */

  gtk_widget_class_install_style_property (widget_class,

					   g_param_spec_boxed ("default-border",

							       P_("Default Spacing"),

							       P_("Extra space to add for GTK_CAN_DEFAULT buttons"),

							       GTK_TYPE_BORDER,

							       GTK_PARAM_READABLE));

  /**

   * GtkButton:default-outside-border:

   *

   * The "default-outside-border" style property defines the extra outside

   * space to add around a button that can become the default widget of its

   * window. Extra outside space is always drawn outside the button border.

   * For more information about default widgets, see gtk_widget_grab_default().

   */

  gtk_widget_class_install_style_property (widget_class,

					   g_param_spec_boxed ("default-outside-border",

							       P_("Default Outside Spacing"),

							       P_("Extra space to add for GTK_CAN_DEFAULT buttons that is always drawn outside the border"),

							       GTK_TYPE_BORDER,

							       GTK_PARAM_READABLE));

  gtk_widget_class_install_style_property (widget_class,

					   g_param_spec_int ("child-displacement-x",

							     P_("Child X Displacement"),

							     P_("How far in the x direction to move the child when the button is depressed"),

							     G_MININT,

							     G_MAXINT,

							     0,

							     GTK_PARAM_READABLE));

  gtk_widget_class_install_style_property (widget_class,

					   g_param_spec_int ("child-displacement-y",

							     P_("Child Y Displacement"),

							     P_("How far in the y direction to move the child when the button is depressed"),

							     G_MININT,

							     G_MAXINT,

							     0,

							     GTK_PARAM_READABLE));

  /**

   * GtkButton:displace-focus:

   *

   * Whether the child_displacement_x/child_displacement_y properties 

   * should also affect the focus rectangle.

   *

   * Since: 2.6

   */

  gtk_widget_class_install_style_property (widget_class,

					   g_param_spec_boolean ("displace-focus",

								 P_("Displace focus"),

								 P_("Whether the child_displacement_x/_y properties should also affect the focus rectangle"),

								 FALSE,

								 GTK_PARAM_READABLE));

  /**

   * GtkButton:inner-border:

   *

   * Sets the border between the button edges and child.

   *

   * Since: 2.10

   */

  gtk_widget_class_install_style_property (widget_class,

					   g_param_spec_boxed ("inner-border",

                                                               P_("Inner Border"),

                                                               P_("Border between button edges and child."),

                                                               GTK_TYPE_BORDER,

                                                               GTK_PARAM_READABLE));

  /**

   * GtkButton::image-spacing:

   * 

   * Spacing in pixels between the image and label.

   * 

   * Since: 2.10

   */

  gtk_widget_class_install_style_property (widget_class,

					   g_param_spec_int ("image-spacing",

							     P_("Image spacing"),

							     P_("Spacing in pixels between the image and label"),

							     0,

							     G_MAXINT,

							     2,

							     GTK_PARAM_READABLE));

  g_type_class_add_private (gobject_class, sizeof (GtkButtonPrivate));

}

static void

gtk_button_init (GtkButton *button)

{

  GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (button);

  gtk_widget_set_can_focus (GTK_WIDGET (button), TRUE);

  gtk_widget_set_receives_default (GTK_WIDGET (button), TRUE);

  gtk_widget_set_has_window (GTK_WIDGET (button), FALSE);

  button->label_text = NULL;

  button->constructed = FALSE;

  button->in_button = FALSE;

  button->button_down = FALSE;

  button->relief = GTK_RELIEF_NORMAL;

  button->use_stock = FALSE;

  button->use_underline = FALSE;

  button->depressed = FALSE;

  button->depress_on_activate = TRUE;

  button->focus_on_click = TRUE;

  priv->xalign = 0.5;

  priv->yalign = 0.5;

  priv->align_set = 0;

  priv->image_is_stock = TRUE;

  priv->image_position = GTK_POS_LEFT;

  priv->use_action_appearance = TRUE;

}

static void

gtk_button_destroy (GtkObject *object)

{

  GtkButton *button = GTK_BUTTON (object);

  if (button->label_text)

    {

      g_free (button->label_text);

      button->label_text = NULL;

    }

  GTK_OBJECT_CLASS (gtk_button_parent_class)->destroy (object);

}

static GObject*

gtk_button_constructor (GType                  type,

			guint                  n_construct_properties,

			GObjectConstructParam *construct_params)

{

  GObject *object;

  GtkButton *button;

  object = G_OBJECT_CLASS (gtk_button_parent_class)->constructor (type,

                                                                  n_construct_properties,

                                                                  construct_params);

  button = GTK_BUTTON (object);

  button->constructed = TRUE;

  if (button->label_text != NULL)

    gtk_button_construct_child (button);

  return object;

}

static GType

gtk_button_child_type  (GtkContainer     *container)

{

  if (!GTK_BIN (container)->child)

    return GTK_TYPE_WIDGET;

  else

    return G_TYPE_NONE;

}

static void

maybe_set_alignment (GtkButton *button,

		     GtkWidget *widget)

{

  GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (button);

  if (GTK_IS_MISC (widget))

    {

      GtkMisc *misc = GTK_MISC (widget);

      if (priv->align_set)

	gtk_misc_set_alignment (misc, priv->xalign, priv->yalign);

    }

  else if (GTK_IS_ALIGNMENT (widget))

    {

      GtkAlignment *alignment = GTK_ALIGNMENT (widget);

      if (priv->align_set)

	gtk_alignment_set (alignment, priv->xalign, priv->yalign, 

			   alignment->xscale, alignment->yscale);

    }

}

static void

gtk_button_add (GtkContainer *container,

		GtkWidget    *widget)

{

  maybe_set_alignment (GTK_BUTTON (container), widget);

  GTK_CONTAINER_CLASS (gtk_button_parent_class)->add (container, widget);

}

static void 

gtk_button_dispose (GObject *object)

{

  GtkButton *button = GTK_BUTTON (object);

  GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (button);

  if (priv->action)

    {

      gtk_activatable_do_set_related_action (GTK_ACTIVATABLE (button), NULL);

      priv->action = NULL;

    }

  G_OBJECT_CLASS (gtk_button_parent_class)->dispose (object);

}

static void

gtk_button_set_property (GObject         *object,

                         guint            prop_id,

                         const GValue    *value,

                         GParamSpec      *pspec)

{

  GtkButton *button = GTK_BUTTON (object);

  GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (button);

  switch (prop_id)

    {

    case PROP_LABEL:

      gtk_button_set_label (button, g_value_get_string (value));

      break;

    case PROP_IMAGE:

      gtk_button_set_image (button, (GtkWidget *) g_value_get_object (value));

      break;

    case PROP_RELIEF:

      gtk_button_set_relief (button, g_value_get_enum (value));

      break;

    case PROP_USE_UNDERLINE:

      gtk_button_set_use_underline (button, g_value_get_boolean (value));

      break;

    case PROP_USE_STOCK:

      gtk_button_set_use_stock (button, g_value_get_boolean (value));

      break;

    case PROP_FOCUS_ON_CLICK:

      gtk_button_set_focus_on_click (button, g_value_get_boolean (value));

      break;

    case PROP_XALIGN:

      gtk_button_set_alignment (button, g_value_get_float (value), priv->yalign);

      break;

    case PROP_YALIGN:

      gtk_button_set_alignment (button, priv->xalign, g_value_get_float (value));

      break;

    case PROP_IMAGE_POSITION:

      gtk_button_set_image_position (button, g_value_get_enum (value));

      break;

    case PROP_ACTIVATABLE_RELATED_ACTION:

      gtk_button_set_related_action (button, g_value_get_object (value));

      break;

    case PROP_ACTIVATABLE_USE_ACTION_APPEARANCE:

      gtk_button_set_use_action_appearance (button, g_value_get_boolean (value));

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

static void

gtk_button_get_property (GObject         *object,

                         guint            prop_id,

                         GValue          *value,

                         GParamSpec      *pspec)

{

  GtkButton *button = GTK_BUTTON (object);

  GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (button);

  switch (prop_id)

    {

    case PROP_LABEL:

      g_value_set_string (value, button->label_text);

      break;

    case PROP_IMAGE:

      g_value_set_object (value, (GObject *)priv->image);

      break;

    case PROP_RELIEF:

      g_value_set_enum (value, gtk_button_get_relief (button));

      break;

    case PROP_USE_UNDERLINE:

      g_value_set_boolean (value, button->use_underline);

      break;

    case PROP_USE_STOCK:

      g_value_set_boolean (value, button->use_stock);

      break;

    case PROP_FOCUS_ON_CLICK:

      g_value_set_boolean (value, button->focus_on_click);

      break;

    case PROP_XALIGN:

      g_value_set_float (value, priv->xalign);

      break;

    case PROP_YALIGN:

      g_value_set_float (value, priv->yalign);

      break;

    case PROP_IMAGE_POSITION:

      g_value_set_enum (value, priv->image_position);

      break;

    case PROP_ACTIVATABLE_RELATED_ACTION:

      g_value_set_object (value, priv->action);

      break;

    case PROP_ACTIVATABLE_USE_ACTION_APPEARANCE:

      g_value_set_boolean (value, priv->use_action_appearance);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

static void 

gtk_button_activatable_interface_init (GtkActivatableIface  *iface)

{

  iface->update = gtk_button_update;

  iface->sync_action_properties = gtk_button_sync_action_properties;

}

static void

activatable_update_stock_id (GtkButton *button,

			     GtkAction *action)

{

  if (!gtk_button_get_use_stock (button))

    return;

  gtk_button_set_label (button, gtk_action_get_stock_id (action));

}

static void

activatable_update_short_label (GtkButton *button,

				GtkAction *action)

{

  GtkWidget *image;

  if (gtk_button_get_use_stock (button))

    return;

  image = gtk_button_get_image (button);

  /* Dont touch custom child... */

  if (GTK_IS_IMAGE (image) ||

      GTK_BIN (button)->child == NULL || 

      GTK_IS_LABEL (GTK_BIN (button)->child))

    {

      gtk_button_set_label (button, gtk_action_get_short_label (action));

      gtk_button_set_use_underline (button, TRUE);

    }

}

static void

activatable_update_icon_name (GtkButton *button,

			      GtkAction *action)

{

  GtkWidget *image;

  if (gtk_button_get_use_stock (button))

    return;

  image = gtk_button_get_image (button);

  if (GTK_IS_IMAGE (image) &&

      (gtk_image_get_storage_type (GTK_IMAGE (image)) == GTK_IMAGE_EMPTY ||

       gtk_image_get_storage_type (GTK_IMAGE (image)) == GTK_IMAGE_ICON_NAME))

    gtk_image_set_from_icon_name (GTK_IMAGE (image),

				  gtk_action_get_icon_name (action), GTK_ICON_SIZE_MENU);

}

static void

activatable_update_gicon (GtkButton *button,

			  GtkAction *action)

{

  GtkWidget *image = gtk_button_get_image (button);

  GIcon *icon = gtk_action_get_gicon (action);

  if (GTK_IS_IMAGE (image) &&

      (gtk_image_get_storage_type (GTK_IMAGE (image)) == GTK_IMAGE_EMPTY ||

       gtk_image_get_storage_type (GTK_IMAGE (image)) == GTK_IMAGE_GICON))

    gtk_image_set_from_gicon (GTK_IMAGE (image), icon, GTK_ICON_SIZE_BUTTON);

}

static void 

gtk_button_update (GtkActivatable *activatable,

		   GtkAction      *action,

	           const gchar    *property_name)

{

  GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (activatable);

  if (strcmp (property_name, "visible") == 0)

    {

      if (gtk_action_is_visible (action))

	gtk_widget_show (GTK_WIDGET (activatable));

      else

	gtk_widget_hide (GTK_WIDGET (activatable));

    }

  else if (strcmp (property_name, "sensitive") == 0)

    gtk_widget_set_sensitive (GTK_WIDGET (activatable), gtk_action_is_sensitive (action));

  if (!priv->use_action_appearance)

    return;

  if (strcmp (property_name, "stock-id") == 0)

    activatable_update_stock_id (GTK_BUTTON (activatable), action);

  else if (strcmp (property_name, "gicon") == 0)

    activatable_update_gicon (GTK_BUTTON (activatable), action);

  else if (strcmp (property_name, "short-label") == 0)

    activatable_update_short_label (GTK_BUTTON (activatable), action);

  else if (strcmp (property_name, "icon-name") == 0)

    activatable_update_icon_name (GTK_BUTTON (activatable), action);

}

static void

gtk_button_sync_action_properties (GtkActivatable *activatable,

			           GtkAction      *action)

{

  GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (activatable);

  if (!action)

    return;

  if (gtk_action_is_visible (action))

    gtk_widget_show (GTK_WIDGET (activatable));

  else

    gtk_widget_hide (GTK_WIDGET (activatable));

  gtk_widget_set_sensitive (GTK_WIDGET (activatable), gtk_action_is_sensitive (action));

  if (priv->use_action_appearance)

    {

      activatable_update_stock_id (GTK_BUTTON (activatable), action);

      activatable_update_short_label (GTK_BUTTON (activatable), action);

      activatable_update_gicon (GTK_BUTTON (activatable), action);

      activatable_update_icon_name (GTK_BUTTON (activatable), action);

    }

}

static void

gtk_button_set_related_action (GtkButton *button,

			       GtkAction *action)

{

  GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (button);

  if (priv->action == action)

    return;

  /* This should be a default handler, but for compatibility reasons

   * we need to support derived classes that don't chain up their

   * clicked handler.