/* GTK - The GIMP Toolkit

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

 *

 * GtkSpinButton widget for GTK+

 * Copyright (C) 1998 Lars Hamann and Stefan Jeske

 *

 * 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-2000.  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 <stdio.h>

#include <stdlib.h>

#include <math.h>

#include <string.h>

#include <locale.h>

#include "gdk/gdkkeysyms.h"

#include "gtkbindings.h"

#include "gtkspinbutton.h"

#include "gtkentryprivate.h"

#include "gtkmain.h"

#include "gtkmarshalers.h"

#include "gtksettings.h"

#include "gtkprivate.h"

#include "gtkintl.h"

#include "gtkalias.h"

#define MIN_SPIN_BUTTON_WIDTH 30

#define MAX_TIMER_CALLS       5

#define EPSILON               1e-10

#define	MAX_DIGITS            20

#define MIN_ARROW_WIDTH       6

enum {

  PROP_0,

  PROP_ADJUSTMENT,

  PROP_CLIMB_RATE,

  PROP_DIGITS,

  PROP_SNAP_TO_TICKS,

  PROP_NUMERIC,

  PROP_WRAP,

  PROP_UPDATE_POLICY,

  PROP_VALUE

};

/* Signals */

enum

{

  INPUT,

  OUTPUT,

  VALUE_CHANGED,

  CHANGE_VALUE,

  WRAPPED,

  LAST_SIGNAL

};

static void gtk_spin_button_editable_init  (GtkEditableClass   *iface);

static void gtk_spin_button_finalize       (GObject            *object);

static void gtk_spin_button_destroy        (GtkObject          *object);

static void gtk_spin_button_set_property   (GObject         *object,

					    guint            prop_id,

					    const GValue    *value,

					    GParamSpec      *pspec);

static void gtk_spin_button_get_property   (GObject         *object,

					    guint            prop_id,

					    GValue          *value,

					    GParamSpec      *pspec);

static void gtk_spin_button_map            (GtkWidget          *widget);

static void gtk_spin_button_unmap          (GtkWidget          *widget);

static void gtk_spin_button_realize        (GtkWidget          *widget);

static void gtk_spin_button_unrealize      (GtkWidget          *widget);

static void gtk_spin_button_size_request   (GtkWidget          *widget,

					    GtkRequisition     *requisition);

static void gtk_spin_button_size_allocate  (GtkWidget          *widget,

					    GtkAllocation      *allocation);

static gint gtk_spin_button_expose         (GtkWidget          *widget,

					    GdkEventExpose     *event);

static gint gtk_spin_button_button_press   (GtkWidget          *widget,

					    GdkEventButton     *event);

static gint gtk_spin_button_button_release (GtkWidget          *widget,

					    GdkEventButton     *event);

static gint gtk_spin_button_motion_notify  (GtkWidget          *widget,

					    GdkEventMotion     *event);

static gint gtk_spin_button_enter_notify   (GtkWidget          *widget,

					    GdkEventCrossing   *event);

static gint gtk_spin_button_leave_notify   (GtkWidget          *widget,

					    GdkEventCrossing   *event);

static gint gtk_spin_button_focus_out      (GtkWidget          *widget,

					    GdkEventFocus      *event);

static void gtk_spin_button_grab_notify    (GtkWidget          *widget,

					    gboolean            was_grabbed);

static void gtk_spin_button_state_changed  (GtkWidget          *widget,

					    GtkStateType        previous_state);

static void gtk_spin_button_style_set      (GtkWidget          *widget,

                                            GtkStyle           *previous_style);

static void gtk_spin_button_draw_arrow     (GtkSpinButton      *spin_button, 

					    GdkRectangle       *area,

					    GtkArrowType        arrow_type);

static gboolean gtk_spin_button_timer          (GtkSpinButton      *spin_button);

static void gtk_spin_button_stop_spinning  (GtkSpinButton      *spin);

static void gtk_spin_button_value_changed  (GtkAdjustment      *adjustment,

					    GtkSpinButton      *spin_button); 

static gint gtk_spin_button_key_release    (GtkWidget          *widget,

					    GdkEventKey        *event);

static gint gtk_spin_button_scroll         (GtkWidget          *widget,

					    GdkEventScroll     *event);

static void gtk_spin_button_activate       (GtkEntry           *entry);

static void gtk_spin_button_get_text_area_size (GtkEntry *entry,

						gint     *x,

						gint     *y,

						gint     *width,

						gint     *height);

static void gtk_spin_button_snap           (GtkSpinButton      *spin_button,

					    gdouble             val);

static void gtk_spin_button_insert_text    (GtkEditable        *editable,

					    const gchar        *new_text,

					    gint                new_text_length,

					    gint               *position);

static void gtk_spin_button_real_spin      (GtkSpinButton      *spin_button,

					    gdouble             step);

static void gtk_spin_button_real_change_value (GtkSpinButton   *spin,

					       GtkScrollType    scroll);

static gint gtk_spin_button_default_input  (GtkSpinButton      *spin_button,

					    gdouble            *new_val);

static gint gtk_spin_button_default_output (GtkSpinButton      *spin_button);

static gint spin_button_get_arrow_size     (GtkSpinButton      *spin_button);

static gint spin_button_get_shadow_type    (GtkSpinButton      *spin_button);

static guint spinbutton_signals[LAST_SIGNAL] = {0};

#define NO_ARROW 2

G_DEFINE_TYPE_WITH_CODE (GtkSpinButton, gtk_spin_button, GTK_TYPE_ENTRY,

			 G_IMPLEMENT_INTERFACE (GTK_TYPE_EDITABLE,

						gtk_spin_button_editable_init))

#define add_spin_binding(binding_set, keyval, mask, scroll)            \

  gtk_binding_entry_add_signal (binding_set, keyval, mask,             \

                                "change_value", 1,                     \

                                GTK_TYPE_SCROLL_TYPE, scroll)

static void

gtk_spin_button_class_init (GtkSpinButtonClass *class)

{

  GObjectClass     *gobject_class = G_OBJECT_CLASS (class);

  GtkObjectClass   *object_class = GTK_OBJECT_CLASS (class);

  GtkWidgetClass   *widget_class = GTK_WIDGET_CLASS (class);

  GtkEntryClass    *entry_class = GTK_ENTRY_CLASS (class);

  GtkBindingSet    *binding_set;

  gobject_class->finalize = gtk_spin_button_finalize;

  gobject_class->set_property = gtk_spin_button_set_property;

  gobject_class->get_property = gtk_spin_button_get_property;

  object_class->destroy = gtk_spin_button_destroy;

  widget_class->map = gtk_spin_button_map;

  widget_class->unmap = gtk_spin_button_unmap;

  widget_class->realize = gtk_spin_button_realize;

  widget_class->unrealize = gtk_spin_button_unrealize;

  widget_class->size_request = gtk_spin_button_size_request;

  widget_class->size_allocate = gtk_spin_button_size_allocate;

  widget_class->expose_event = gtk_spin_button_expose;

  widget_class->scroll_event = gtk_spin_button_scroll;

  widget_class->button_press_event = gtk_spin_button_button_press;

  widget_class->button_release_event = gtk_spin_button_button_release;

  widget_class->motion_notify_event = gtk_spin_button_motion_notify;

  widget_class->key_release_event = gtk_spin_button_key_release;

  widget_class->enter_notify_event = gtk_spin_button_enter_notify;

  widget_class->leave_notify_event = gtk_spin_button_leave_notify;

  widget_class->focus_out_event = gtk_spin_button_focus_out;

  widget_class->grab_notify = gtk_spin_button_grab_notify;

  widget_class->state_changed = gtk_spin_button_state_changed;

  widget_class->style_set = gtk_spin_button_style_set;

  entry_class->activate = gtk_spin_button_activate;

  entry_class->get_text_area_size = gtk_spin_button_get_text_area_size;

  class->input = NULL;

  class->output = NULL;

  class->change_value = gtk_spin_button_real_change_value;

  g_object_class_install_property (gobject_class,

                                   PROP_ADJUSTMENT,

                                   g_param_spec_object ("adjustment",

                                                        P_("Adjustment"),

                                                        P_("The adjustment that holds the value of the spinbutton"),

                                                        GTK_TYPE_ADJUSTMENT,

                                                        GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_CLIMB_RATE,

                                   g_param_spec_double ("climb-rate",

							P_("Climb Rate"),

							P_("The acceleration rate when you hold down a button"),

							0.0,

							G_MAXDOUBLE,

							0.0,

							GTK_PARAM_READWRITE));  

  g_object_class_install_property (gobject_class,

                                   PROP_DIGITS,

                                   g_param_spec_uint ("digits",

						      P_("Digits"),

						      P_("The number of decimal places to display"),

						      0,

						      MAX_DIGITS,

						      0,

						      GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_SNAP_TO_TICKS,

                                   g_param_spec_boolean ("snap-to-ticks",

							 P_("Snap to Ticks"),

							 P_("Whether erroneous values are automatically changed to a spin button's nearest step increment"),

							 FALSE,

							 GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_NUMERIC,

                                   g_param_spec_boolean ("numeric",

							 P_("Numeric"),

							 P_("Whether non-numeric characters should be ignored"),

							 FALSE,

							 GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_WRAP,

                                   g_param_spec_boolean ("wrap",

							 P_("Wrap"),

							 P_("Whether a spin button should wrap upon reaching its limits"),

							 FALSE,

							 GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_UPDATE_POLICY,

                                   g_param_spec_enum ("update-policy",

						      P_("Update Policy"),

						      P_("Whether the spin button should update always, or only when the value is legal"),

						      GTK_TYPE_SPIN_BUTTON_UPDATE_POLICY,

						      GTK_UPDATE_ALWAYS,

						      GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_VALUE,

                                   g_param_spec_double ("value",

							P_("Value"),

							P_("Reads the current value, or sets a new value"),

							-G_MAXDOUBLE,

							G_MAXDOUBLE,

							0.0,

							GTK_PARAM_READWRITE));  

  gtk_widget_class_install_style_property_parser (widget_class,

						  g_param_spec_enum ("shadow-type", 

								     "Shadow Type", 

								     P_("Style of bevel around the spin button"),

								     GTK_TYPE_SHADOW_TYPE,

								     GTK_SHADOW_IN,

								     GTK_PARAM_READABLE),

						  gtk_rc_property_parse_enum);

  spinbutton_signals[INPUT] =

    g_signal_new (I_("input"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_LAST,

		  G_STRUCT_OFFSET (GtkSpinButtonClass, input),

		  NULL, NULL,

		  _gtk_marshal_INT__POINTER,

		  G_TYPE_INT, 1,

		  G_TYPE_POINTER);

  /**

   * GtkSpinButton::output:

   * @spin_button: the object which received the signal

   * 

   * The ::output signal can be used to change to formatting

   * of the value that is displayed in the spin buttons entry.

   * |[

   * /* show leading zeros */

   * static gboolean

   * on_output (GtkSpinButton *spin,

   *            gpointer       data)

   * {

   *    GtkAdjustment *adj;

   *    gchar *text;

   *    int value;

   *    

   *    adj = gtk_spin_button_get_adjustment (spin);

   *    value = (int)gtk_adjustment_get_value (adj);

   *    text = g_strdup_printf ("%02d", value);

   *    gtk_entry_set_text (GTK_ENTRY (spin), text);

   *    g_free (text);

   *    

   *    return TRUE;

   * }

   * ]|

   *

   * Returns: %TRUE if the value has been displayed.

   */

  spinbutton_signals[OUTPUT] =

    g_signal_new (I_("output"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_LAST,

		  G_STRUCT_OFFSET (GtkSpinButtonClass, output),

		  _gtk_boolean_handled_accumulator, NULL,

		  _gtk_marshal_BOOLEAN__VOID,

		  G_TYPE_BOOLEAN, 0);

  spinbutton_signals[VALUE_CHANGED] =

    g_signal_new (I_("value-changed"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_LAST,

		  G_STRUCT_OFFSET (GtkSpinButtonClass, value_changed),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  /**

   * GtkSpinButton::wrapped:

   * @spinbutton: the object which received the signal

   *

   * The wrapped signal is emitted right after the spinbutton wraps

   * from its maximum to minimum value or vice-versa.

   *

   * Since: 2.10

   */

  spinbutton_signals[WRAPPED] =

    g_signal_new (I_("wrapped"),

		  G_TYPE_FROM_CLASS (gobject_class),

		  G_SIGNAL_RUN_LAST,

		  G_STRUCT_OFFSET (GtkSpinButtonClass, wrapped),

		  NULL, NULL,

		  _gtk_marshal_VOID__VOID,

		  G_TYPE_NONE, 0);

  /* Action signals */

  spinbutton_signals[CHANGE_VALUE] =

    g_signal_new (I_("change-value"),

                  G_TYPE_FROM_CLASS (gobject_class),

                  G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,

                  G_STRUCT_OFFSET (GtkSpinButtonClass, change_value),

                  NULL, NULL,

                  _gtk_marshal_VOID__ENUM,

                  G_TYPE_NONE, 1,

                  GTK_TYPE_SCROLL_TYPE);

  binding_set = gtk_binding_set_by_class (class);

  add_spin_binding (binding_set, GDK_Up, 0, GTK_SCROLL_STEP_UP);

  add_spin_binding (binding_set, GDK_KP_Up, 0, GTK_SCROLL_STEP_UP);

  add_spin_binding (binding_set, GDK_Down, 0, GTK_SCROLL_STEP_DOWN);

  add_spin_binding (binding_set, GDK_KP_Down, 0, GTK_SCROLL_STEP_DOWN);

  add_spin_binding (binding_set, GDK_Page_Up, 0, GTK_SCROLL_PAGE_UP);

  add_spin_binding (binding_set, GDK_Page_Down, 0, GTK_SCROLL_PAGE_DOWN);

  add_spin_binding (binding_set, GDK_Page_Up, GDK_CONTROL_MASK, GTK_SCROLL_END);

  add_spin_binding (binding_set, GDK_Page_Down, GDK_CONTROL_MASK, GTK_SCROLL_START);

}

static void

gtk_spin_button_editable_init (GtkEditableClass *iface)

{

  iface->insert_text = gtk_spin_button_insert_text;

}

static void

gtk_spin_button_set_property (GObject      *object,

			      guint         prop_id,

			      const GValue *value,

			      GParamSpec   *pspec)

{

  GtkSpinButton *spin_button = GTK_SPIN_BUTTON (object);

  switch (prop_id)

    {

      GtkAdjustment *adjustment;

    case PROP_ADJUSTMENT:

      adjustment = GTK_ADJUSTMENT (g_value_get_object (value));

      if (!adjustment)

	adjustment = (GtkAdjustment*) gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0);

      gtk_spin_button_set_adjustment (spin_button, adjustment);

      break;

    case PROP_CLIMB_RATE:

      gtk_spin_button_configure (spin_button,

				 spin_button->adjustment,

				 g_value_get_double (value),

				 spin_button->digits);

      break;

    case PROP_DIGITS:

      gtk_spin_button_configure (spin_button,

				 spin_button->adjustment,

				 spin_button->climb_rate,

				 g_value_get_uint (value));

      break;

    case PROP_SNAP_TO_TICKS:

      gtk_spin_button_set_snap_to_ticks (spin_button, g_value_get_boolean (value));

      break;

    case PROP_NUMERIC:

      gtk_spin_button_set_numeric (spin_button, g_value_get_boolean (value));

      break;

    case PROP_WRAP:

      gtk_spin_button_set_wrap (spin_button, g_value_get_boolean (value));

      break;

    case PROP_UPDATE_POLICY:

      gtk_spin_button_set_update_policy (spin_button, g_value_get_enum (value));

      break;

    case PROP_VALUE:

      gtk_spin_button_set_value (spin_button, g_value_get_double (value));

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

static void

gtk_spin_button_get_property (GObject      *object,

			      guint         prop_id,

			      GValue       *value,

			      GParamSpec   *pspec)

{

  GtkSpinButton *spin_button = GTK_SPIN_BUTTON (object);

  switch (prop_id)

    {

    case PROP_ADJUSTMENT:

      g_value_set_object (value, spin_button->adjustment);

      break;

    case PROP_CLIMB_RATE:

      g_value_set_double (value, spin_button->climb_rate);

      break;

    case PROP_DIGITS:

      g_value_set_uint (value, spin_button->digits);

      break;

    case PROP_SNAP_TO_TICKS:

      g_value_set_boolean (value, spin_button->snap_to_ticks);

      break;

    case PROP_NUMERIC:

      g_value_set_boolean (value, spin_button->numeric);

      break;

    case PROP_WRAP:

      g_value_set_boolean (value, spin_button->wrap);

      break;

    case PROP_UPDATE_POLICY:

      g_value_set_enum (value, spin_button->update_policy);

      break;

     case PROP_VALUE:

       g_value_set_double (value, spin_button->adjustment->value);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

static void

gtk_spin_button_init (GtkSpinButton *spin_button)

{

  spin_button->adjustment = NULL;

  spin_button->panel = NULL;

  spin_button->timer = 0;

  spin_button->climb_rate = 0.0;

  spin_button->timer_step = 0.0;

  spin_button->update_policy = GTK_UPDATE_ALWAYS;

  spin_button->in_child = NO_ARROW;

  spin_button->click_child = NO_ARROW;

  spin_button->button = 0;

  spin_button->need_timer = FALSE;

  spin_button->timer_calls = 0;

  spin_button->digits = 0;

  spin_button->numeric = FALSE;

  spin_button->wrap = FALSE;

  spin_button->snap_to_ticks = FALSE;

  gtk_spin_button_set_adjustment (spin_button,

	  (GtkAdjustment*) gtk_adjustment_new (0, 0, 0, 0, 0, 0));

}

static void

gtk_spin_button_finalize (GObject *object)

{

  gtk_spin_button_set_adjustment (GTK_SPIN_BUTTON (object), NULL);

  G_OBJECT_CLASS (gtk_spin_button_parent_class)->finalize (object);

}

static void

gtk_spin_button_destroy (GtkObject *object)

{

  gtk_spin_button_stop_spinning (GTK_SPIN_BUTTON (object));

  GTK_OBJECT_CLASS (gtk_spin_button_parent_class)->destroy (object);

}

static void

gtk_spin_button_map (GtkWidget *widget)

{

  if (gtk_widget_get_realized (widget) && !gtk_widget_get_mapped (widget))

    {

      GTK_WIDGET_CLASS (gtk_spin_button_parent_class)->map (widget);

      gdk_window_show (GTK_SPIN_BUTTON (widget)->panel);

    }

}

static void

gtk_spin_button_unmap (GtkWidget *widget)

{

  if (gtk_widget_get_mapped (widget))

    {

      gtk_spin_button_stop_spinning (GTK_SPIN_BUTTON (widget));

      gdk_window_hide (GTK_SPIN_BUTTON (widget)->panel);

      GTK_WIDGET_CLASS (gtk_spin_button_parent_class)->unmap (widget);

    }

}

static void

gtk_spin_button_realize (GtkWidget *widget)

{

  GtkSpinButton *spin_button = GTK_SPIN_BUTTON (widget);

  GdkWindowAttr attributes;

  gint attributes_mask;

  gboolean return_val;

  gint arrow_size;

  arrow_size = spin_button_get_arrow_size (spin_button);

  gtk_widget_set_events (widget, gtk_widget_get_events (widget) |

			 GDK_KEY_RELEASE_MASK);

  GTK_WIDGET_CLASS (gtk_spin_button_parent_class)->realize (widget);

  attributes.window_type = GDK_WINDOW_CHILD;

  attributes.wclass = GDK_INPUT_OUTPUT;

  attributes.visual = gtk_widget_get_visual (widget);

  attributes.colormap = gtk_widget_get_colormap (widget);

  attributes.event_mask = gtk_widget_get_events (widget);

  attributes.event_mask |= GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK 

    | GDK_BUTTON_RELEASE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_ENTER_NOTIFY_MASK 

    | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK;

  attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;

  attributes.x = (widget->allocation.width - arrow_size -

		  2 * widget->style->xthickness);

  attributes.y = (widget->allocation.height -

					 widget->requisition.height) / 2;

  attributes.width = arrow_size + 2 * widget->style->xthickness;

  attributes.height = widget->requisition.height;

  spin_button->panel = gdk_window_new (widget->window, 

				       &attributes, attributes_mask);

  gdk_window_set_user_data (spin_button->panel, widget);

  gtk_style_set_background (widget->style, spin_button->panel, GTK_STATE_NORMAL);

  return_val = FALSE;

  g_signal_emit (spin_button, spinbutton_signals[OUTPUT], 0, &return_val);

  /* If output wasn't processed explicitly by the method connected to the

   * 'output' signal; and if we don't have any explicit 'text' set initially,

   * fallback to the default output. */

  if (!return_val &&

      (spin_button->numeric || gtk_entry_get_text (GTK_ENTRY (spin_button)) == NULL))

    gtk_spin_button_default_output (spin_button);

  gtk_widget_queue_resize (GTK_WIDGET (spin_button));

}

static void

gtk_spin_button_unrealize (GtkWidget *widget)

{

  GtkSpinButton *spin = GTK_SPIN_BUTTON (widget);

  gtk_spin_button_stop_spinning (GTK_SPIN_BUTTON (widget));

  GTK_WIDGET_CLASS (gtk_spin_button_parent_class)->unrealize (widget);

  if (spin->panel)

    {

      gdk_window_set_user_data (spin->panel, NULL);

      gdk_window_destroy (spin->panel);

      spin->panel = NULL;

    }

}

static int

compute_double_length (double val, int digits)

{

  int a;

  int extra;

  a = 1;

  if (fabs (val) > 1.0)

    a = floor (log10 (fabs (val))) + 1;  

  extra = 0;

  /* The dot: */

  if (digits > 0)

    extra++;

  /* The sign: */

  if (val < 0)

    extra++;

  return a + digits + extra;

}

static void

gtk_spin_button_size_request (GtkWidget      *widget,

			      GtkRequisition *requisition)

{

  GtkSpinButton *spin_button = GTK_SPIN_BUTTON (widget);

  GtkEntry *entry = GTK_ENTRY (widget);

  gint arrow_size;

  arrow_size = spin_button_get_arrow_size (spin_button);

  GTK_WIDGET_CLASS (gtk_spin_button_parent_class)->size_request (widget, requisition);

  if (entry->width_chars < 0)

    {

      PangoContext *context;

      PangoFontMetrics *metrics;

      gint width;

      gint w;

      gint string_len;

      gint max_string_len;

      gint digit_width;

      gboolean interior_focus;

      gint focus_width;

      gint xborder, yborder;

      GtkBorder inner_border;

      gtk_widget_style_get (widget,

			    "interior-focus", &interior_focus,

			    "focus-line-width", &focus_width,

			    NULL);

      context = gtk_widget_get_pango_context (widget);

      metrics = pango_context_get_metrics (context,

					   widget->style->font_desc,

					   pango_context_get_language (context));

      digit_width = pango_font_metrics_get_approximate_digit_width (metrics);

      digit_width = PANGO_SCALE *

        ((digit_width + PANGO_SCALE - 1) / PANGO_SCALE);

      pango_font_metrics_unref (metrics);

      /* Get max of MIN_SPIN_BUTTON_WIDTH, size of upper, size of lower */

      width = MIN_SPIN_BUTTON_WIDTH;

      max_string_len = MAX (10, compute_double_length (1e9 * spin_button->adjustment->step_increment,

                                                       spin_button->digits));

      string_len = compute_double_length (spin_button->adjustment->upper,

                                          spin_button->digits);

      w = PANGO_PIXELS (MIN (string_len, max_string_len) * digit_width);

      width = MAX (width, w);

      string_len = compute_double_length (spin_button->adjustment->lower,

					  spin_button->digits);

      w = PANGO_PIXELS (MIN (string_len, max_string_len) * digit_width);

      width = MAX (width, w);

      _gtk_entry_get_borders (entry, &xborder, &yborder);

      _gtk_entry_effective_inner_border (entry, &inner_border);

      requisition->width = width + xborder * 2 + inner_border.left + inner_border.right;

    }

  requisition->width += arrow_size + 2 * widget->style->xthickness;

}

static void

gtk_spin_button_size_allocate (GtkWidget     *widget,

			       GtkAllocation *allocation)

{

  GtkSpinButton *spin = GTK_SPIN_BUTTON (widget);

  GtkAllocation panel_allocation;

  gint arrow_size;

  gint panel_width;

  arrow_size = spin_button_get_arrow_size (spin);

  panel_width = arrow_size + 2 * widget->style->xthickness;

  widget->allocation = *allocation;

  if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)

    panel_allocation.x = 0;

  else

    panel_allocation.x = allocation->width - panel_width;

  panel_allocation.width = panel_width;

  panel_allocation.height = MIN (widget->requisition.height, allocation->height);

  panel_allocation.y = 0;

  GTK_WIDGET_CLASS (gtk_spin_button_parent_class)->size_allocate (widget, allocation);

  if (gtk_widget_get_realized (widget))

    {

      gdk_window_move_resize (GTK_SPIN_BUTTON (widget)->panel, 

			      panel_allocation.x,

			      panel_allocation.y,

			      panel_allocation.width,

			      panel_allocation.height); 

    }

  gtk_widget_queue_draw (GTK_WIDGET (spin));

}

static gint

gtk_spin_button_expose (GtkWidget      *widget,

			GdkEventExpose *event)

{

  GtkSpinButton *spin = GTK_SPIN_BUTTON (widget);

  if (gtk_widget_is_drawable (widget))

    {

      if (event->window == spin->panel)

	{

	  GtkShadowType shadow_type;

	  shadow_type = spin_button_get_shadow_type (spin);

	  if (shadow_type != GTK_SHADOW_NONE)

	    {

	      gint width, height;

              gboolean state_hint;

              GtkStateType state;

              gtk_widget_style_get (widget, "state-hint", &state_hint, NULL);

              if (state_hint)

                state = gtk_widget_has_focus (widget) ?

                  GTK_STATE_ACTIVE : gtk_widget_get_state (widget);

              else

                state = GTK_STATE_NORMAL;

              width = gdk_window_get_width (spin->panel);

              height = gdk_window_get_height (spin->panel);

              if (gtk_entry_get_has_frame (GTK_ENTRY (spin)))

                gtk_paint_box (widget->style, spin->panel,

                               state, shadow_type,

                               &event->area, widget, "spinbutton",

                               0, 0, width, height);

	    }

	  gtk_spin_button_draw_arrow (spin, &event->area, GTK_ARROW_UP);

	  gtk_spin_button_draw_arrow (spin, &event->area, GTK_ARROW_DOWN);

	}

      else

        {

          if (event->window == widget->window)

            {

              gint text_x, text_y, text_width, text_height, slice_x;

              /* Since we reuse xthickness for the buttons panel on one side, and GtkEntry

               * always sizes its background to (allocation->width - 2 * xthickness), we

               * have to manually render the missing slice of the background on the panel

               * side.

               */

              GTK_ENTRY_GET_CLASS (spin)->get_text_area_size (GTK_ENTRY (spin),

                                                              &text_x, &text_y,

                                                              &text_width, &text_height);

              if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)

                slice_x = text_x - widget->style->xthickness;

              else

                slice_x = text_x + text_width;

              gtk_paint_flat_box (widget->style, widget->window,

                                  gtk_widget_get_state (widget), GTK_SHADOW_NONE,

                                  &event->area, widget, "entry_bg",

                                  slice_x, text_y,

                                  widget->style->xthickness, text_height);

            }

          GTK_WIDGET_CLASS (gtk_spin_button_parent_class)->expose_event (widget, event);

        }

    }

  return FALSE;

}

static gboolean

spin_button_at_limit (GtkSpinButton *spin_button,

                     GtkArrowType   arrow)

{

  GtkArrowType effective_arrow;

  if (spin_button->wrap)

    return FALSE;

  if (spin_button->adjustment->step_increment > 0)

    effective_arrow = arrow;

  else

    effective_arrow = arrow == GTK_ARROW_UP ? GTK_ARROW_DOWN : GTK_ARROW_UP; 

  if (effective_arrow == GTK_ARROW_UP &&

      (spin_button->adjustment->upper - spin_button->adjustment->value <= EPSILON))

    return TRUE;

  if (effective_arrow == GTK_ARROW_DOWN &&

      (spin_button->adjustment->value - spin_button->adjustment->lower <= EPSILON))

    return TRUE;

  return FALSE;

}

static void

gtk_spin_button_draw_arrow (GtkSpinButton *spin_button, 

			    GdkRectangle  *area,

			    GtkArrowType   arrow_type)

{

  GtkStateType state_type;

  GtkShadowType shadow_type;

  GtkWidget *widget;

  gint x;

  gint y;

  gint height;

  gint width;

  gint h, w;

  g_return_if_fail (arrow_type == GTK_ARROW_UP || arrow_type == GTK_ARROW_DOWN);

  widget = GTK_WIDGET (spin_button);

  if (gtk_widget_is_drawable (widget))

    {

      width = spin_button_get_arrow_size (spin_button) + 2 * widget->style->xthickness;

      if (arrow_type == GTK_ARROW_UP)

	{

	  x = 0;

	  y = 0;

	  height = widget->requisition.height / 2;

	}

      else

	{

	  x = 0;

	  y = widget->requisition.height / 2;

	  height = (widget->requisition.height + 1) / 2;

	}

      if (spin_button_at_limit (spin_button, arrow_type))

	{

	  shadow_type = GTK_SHADOW_OUT;

	  state_type = GTK_STATE_INSENSITIVE;

	}

      else

	{

	  if (spin_button->click_child == arrow_type)

	    {

	      state_type = GTK_STATE_ACTIVE;