/* GTK - The GIMP Toolkit

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

 * Copyright (C) 2001 Red Hat, Inc.

 *

 * 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-2004.  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 <math.h>

#undef GTK_DISABLE_DEPRECATED

#include <gdk/gdkkeysyms.h>

#include "gtkmain.h"

#include "gtkmarshalers.h"

#include "gtkorientable.h"

#include "gtkrange.h"

#include "gtkscale.h"

#include "gtkscrollbar.h"

#include "gtkprivate.h"

#include "gtkintl.h"

#include "gtkalias.h"

#define SCROLL_DELAY_FACTOR 5    /* Scroll repeat multiplier */

#define UPDATE_DELAY        300  /* Delay for queued update */

enum {

  PROP_0,

  PROP_ORIENTATION,

  PROP_UPDATE_POLICY,

  PROP_ADJUSTMENT,

  PROP_INVERTED,

  PROP_LOWER_STEPPER_SENSITIVITY,

  PROP_UPPER_STEPPER_SENSITIVITY,

  PROP_SHOW_FILL_LEVEL,

  PROP_RESTRICT_TO_FILL_LEVEL,

  PROP_FILL_LEVEL,

  PROP_ROUND_DIGITS

};

enum {

  VALUE_CHANGED,

  ADJUST_BOUNDS,

  MOVE_SLIDER,

  CHANGE_VALUE,

  LAST_SIGNAL

};

typedef enum {

  MOUSE_OUTSIDE,

  MOUSE_STEPPER_A,

  MOUSE_STEPPER_B,

  MOUSE_STEPPER_C,

  MOUSE_STEPPER_D,

  MOUSE_TROUGH,

  MOUSE_SLIDER,

  MOUSE_WIDGET /* inside widget but not in any of the above GUI elements */

} MouseLocation;

typedef enum {

  STEPPER_A,

  STEPPER_B,

  STEPPER_C,

  STEPPER_D

} Stepper;

#define GTK_RANGE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_RANGE, GtkRangeLayout))

struct _GtkRangeLayout

{

  /* These are in widget->window coordinates */

  GdkRectangle stepper_a;

  GdkRectangle stepper_b;

  GdkRectangle stepper_c;

  GdkRectangle stepper_d;

  /* The trough rectangle is the area the thumb can slide in, not the

   * entire range_rect

   */

  GdkRectangle trough;

  GdkRectangle slider;

  /* Layout-related state */

  MouseLocation mouse_location;

  /* last mouse coords we got, or -1 if mouse is outside the range */

  gint mouse_x;

  gint mouse_y;

  /* "grabbed" mouse location, OUTSIDE for no grab */

  MouseLocation grab_location;

  guint grab_button : 8; /* 0 if none */

  /* Stepper sensitivity */

  guint lower_sensitive : 1;

  guint upper_sensitive : 1;

  /* Fill level */

  guint show_fill_level : 1;

  guint restrict_to_fill_level : 1;

  GtkSensitivityType lower_sensitivity;

  GtkSensitivityType upper_sensitivity;

  guint repaint_id;

  gdouble fill_level;

  GQuark slider_detail_quark;

  GQuark stepper_detail_quark[4];

  gdouble *marks;

  gint *mark_pos;

  gint n_marks;

  gboolean recalc_marks;

};

static void gtk_range_set_property   (GObject          *object,

                                      guint             prop_id,

                                      const GValue     *value,

                                      GParamSpec       *pspec);

static void gtk_range_get_property   (GObject          *object,

                                      guint             prop_id,

                                      GValue           *value,

                                      GParamSpec       *pspec);

static void gtk_range_destroy        (GtkObject        *object);

static void gtk_range_size_request   (GtkWidget        *widget,

                                      GtkRequisition   *requisition);

static void gtk_range_size_allocate  (GtkWidget        *widget,

                                      GtkAllocation    *allocation);

static void gtk_range_realize        (GtkWidget        *widget);

static void gtk_range_unrealize      (GtkWidget        *widget);

static void gtk_range_map            (GtkWidget        *widget);

static void gtk_range_unmap          (GtkWidget        *widget);

static gboolean gtk_range_expose         (GtkWidget        *widget,

                                      GdkEventExpose   *event);

static gboolean gtk_range_button_press   (GtkWidget        *widget,

                                      GdkEventButton   *event);

static gboolean gtk_range_button_release (GtkWidget        *widget,

                                      GdkEventButton   *event);

static gboolean gtk_range_motion_notify  (GtkWidget        *widget,

                                      GdkEventMotion   *event);

static gboolean gtk_range_enter_notify   (GtkWidget        *widget,

                                      GdkEventCrossing *event);

static gboolean gtk_range_leave_notify   (GtkWidget        *widget,

                                      GdkEventCrossing *event);

static gboolean gtk_range_grab_broken (GtkWidget          *widget,

				       GdkEventGrabBroken *event);

static void gtk_range_grab_notify    (GtkWidget          *widget,

				      gboolean            was_grabbed);

static void gtk_range_state_changed  (GtkWidget          *widget,

				      GtkStateType        previous_state);

static gboolean gtk_range_scroll_event   (GtkWidget        *widget,

                                      GdkEventScroll   *event);

static void gtk_range_style_set      (GtkWidget        *widget,

                                      GtkStyle         *previous_style);

static void update_slider_position   (GtkRange	       *range,

				      gint              mouse_x,

				      gint              mouse_y);

static void stop_scrolling           (GtkRange         *range);

/* Range methods */

static void gtk_range_move_slider              (GtkRange         *range,

                                                GtkScrollType     scroll);

/* Internals */

static gboolean      gtk_range_scroll                   (GtkRange      *range,

                                                         GtkScrollType  scroll);

static gboolean      gtk_range_update_mouse_location    (GtkRange      *range);

static void          gtk_range_calc_layout              (GtkRange      *range,

							 gdouble	adjustment_value);

static void          gtk_range_calc_marks               (GtkRange      *range);

static void          gtk_range_get_props                (GtkRange      *range,

                                                         gint          *slider_width,

                                                         gint          *stepper_size,

                                                         gint          *focus_width,

                                                         gint          *trough_border,

                                                         gint          *stepper_spacing,

                                                         gboolean      *trough_under_steppers,

							 gint          *arrow_displacement_x,

							 gint	       *arrow_displacement_y);

static void          gtk_range_calc_request             (GtkRange      *range,

                                                         gint           slider_width,

                                                         gint           stepper_size,

                                                         gint           focus_width,

                                                         gint           trough_border,

                                                         gint           stepper_spacing,

                                                         GdkRectangle  *range_rect,

                                                         GtkBorder     *border,

                                                         gint          *n_steppers_p,

                                                         gboolean      *has_steppers_ab,

                                                         gboolean      *has_steppers_cd,

                                                         gint          *slider_length_p);

static void          gtk_range_adjustment_value_changed (GtkAdjustment *adjustment,

                                                         gpointer       data);

static void          gtk_range_adjustment_changed       (GtkAdjustment *adjustment,

                                                         gpointer       data);

static void          gtk_range_add_step_timer           (GtkRange      *range,

                                                         GtkScrollType  step);

static void          gtk_range_remove_step_timer        (GtkRange      *range);

static void          gtk_range_reset_update_timer       (GtkRange      *range);

static void          gtk_range_remove_update_timer      (GtkRange      *range);

static GdkRectangle* get_area                           (GtkRange      *range,

                                                         MouseLocation  location);

static gboolean      gtk_range_real_change_value        (GtkRange      *range,

                                                         GtkScrollType  scroll,

                                                         gdouble        value);

static void          gtk_range_update_value             (GtkRange      *range);

static gboolean      gtk_range_key_press                (GtkWidget     *range,

							 GdkEventKey   *event);

G_DEFINE_ABSTRACT_TYPE_WITH_CODE (GtkRange, gtk_range, GTK_TYPE_WIDGET,

                                  G_IMPLEMENT_INTERFACE (GTK_TYPE_ORIENTABLE,

                                                         NULL))

static guint signals[LAST_SIGNAL];

static void

gtk_range_class_init (GtkRangeClass *class)

{

  GObjectClass   *gobject_class;

  GtkObjectClass *object_class;

  GtkWidgetClass *widget_class;

  gobject_class = G_OBJECT_CLASS (class);

  object_class = (GtkObjectClass*) class;

  widget_class = (GtkWidgetClass*) class;

  gobject_class->set_property = gtk_range_set_property;

  gobject_class->get_property = gtk_range_get_property;

  object_class->destroy = gtk_range_destroy;

  widget_class->size_request = gtk_range_size_request;

  widget_class->size_allocate = gtk_range_size_allocate;

  widget_class->realize = gtk_range_realize;

  widget_class->unrealize = gtk_range_unrealize;  

  widget_class->map = gtk_range_map;

  widget_class->unmap = gtk_range_unmap;

  widget_class->expose_event = gtk_range_expose;

  widget_class->button_press_event = gtk_range_button_press;

  widget_class->button_release_event = gtk_range_button_release;

  widget_class->motion_notify_event = gtk_range_motion_notify;

  widget_class->scroll_event = gtk_range_scroll_event;

  widget_class->enter_notify_event = gtk_range_enter_notify;

  widget_class->leave_notify_event = gtk_range_leave_notify;

  widget_class->grab_broken_event = gtk_range_grab_broken;

  widget_class->grab_notify = gtk_range_grab_notify;

  widget_class->state_changed = gtk_range_state_changed;

  widget_class->style_set = gtk_range_style_set;

  widget_class->key_press_event = gtk_range_key_press;

  class->move_slider = gtk_range_move_slider;

  class->change_value = gtk_range_real_change_value;

  class->slider_detail = "slider";

  class->stepper_detail = "stepper";

  /**

   * GtkRange::value-changed:

   * @range: the #GtkRange

   *

   * Emitted when the range value changes.

   */

  signals[VALUE_CHANGED] =

    g_signal_new (I_("value-changed"),

                  G_TYPE_FROM_CLASS (gobject_class),

                  G_SIGNAL_RUN_LAST,

                  G_STRUCT_OFFSET (GtkRangeClass, value_changed),

                  NULL, NULL,

                  _gtk_marshal_VOID__VOID,

                  G_TYPE_NONE, 0);

  signals[ADJUST_BOUNDS] =

    g_signal_new (I_("adjust-bounds"),

                  G_TYPE_FROM_CLASS (gobject_class),

                  G_SIGNAL_RUN_LAST,

                  G_STRUCT_OFFSET (GtkRangeClass, adjust_bounds),

                  NULL, NULL,

                  _gtk_marshal_VOID__DOUBLE,

                  G_TYPE_NONE, 1,

                  G_TYPE_DOUBLE);

  /**

   * GtkRange::move-slider:

   * @range: the #GtkRange

   * @step: how to move the slider

   *

   * Virtual function that moves the slider. Used for keybindings.

   */

  signals[MOVE_SLIDER] =

    g_signal_new (I_("move-slider"),

                  G_TYPE_FROM_CLASS (gobject_class),

                  G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,

                  G_STRUCT_OFFSET (GtkRangeClass, move_slider),

                  NULL, NULL,

                  _gtk_marshal_VOID__ENUM,

                  G_TYPE_NONE, 1,

                  GTK_TYPE_SCROLL_TYPE);

  /**

   * GtkRange::change-value:

   * @range: the range that received the signal

   * @scroll: the type of scroll action that was performed

   * @value: the new value resulting from the scroll action

   * @returns: %TRUE to prevent other handlers from being invoked for the

   * signal, %FALSE to propagate the signal further

   *

   * The ::change-value signal is emitted when a scroll action is

   * performed on a range.  It allows an application to determine the

   * type of scroll event that occurred and the resultant new value.

   * The application can handle the event itself and return %TRUE to

   * prevent further processing.  Or, by returning %FALSE, it can pass

   * the event to other handlers until the default GTK+ handler is

   * reached.

   *

   * The value parameter is unrounded.  An application that overrides

   * the ::change-value signal is responsible for clamping the value to

   * the desired number of decimal digits; the default GTK+ handler

   * clamps the value based on #GtkRange:round_digits.

   *

   * It is not possible to use delayed update policies in an overridden

   * ::change-value handler.

   *

   * Since: 2.6

   */

  signals[CHANGE_VALUE] =

    g_signal_new (I_("change-value"),

                  G_TYPE_FROM_CLASS (gobject_class),

                  G_SIGNAL_RUN_LAST,

                  G_STRUCT_OFFSET (GtkRangeClass, change_value),

                  _gtk_boolean_handled_accumulator, NULL,

                  _gtk_marshal_BOOLEAN__ENUM_DOUBLE,

                  G_TYPE_BOOLEAN, 2,

                  GTK_TYPE_SCROLL_TYPE,

                  G_TYPE_DOUBLE);

  g_object_class_override_property (gobject_class,

                                    PROP_ORIENTATION,

                                    "orientation");

  g_object_class_install_property (gobject_class,

                                   PROP_UPDATE_POLICY,

                                   g_param_spec_enum ("update-policy",

						      P_("Update policy"),

						      P_("How the range should be updated on the screen"),

						      GTK_TYPE_UPDATE_TYPE,

						      GTK_UPDATE_CONTINUOUS,

						      GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_ADJUSTMENT,

                                   g_param_spec_object ("adjustment",

							P_("Adjustment"),

							P_("The GtkAdjustment that contains the current value of this range object"),

                                                        GTK_TYPE_ADJUSTMENT,

                                                        GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));

  g_object_class_install_property (gobject_class,

                                   PROP_INVERTED,

                                   g_param_spec_boolean ("inverted",

							P_("Inverted"),

							P_("Invert direction slider moves to increase range value"),

                                                         FALSE,

                                                         GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_LOWER_STEPPER_SENSITIVITY,

                                   g_param_spec_enum ("lower-stepper-sensitivity",

						      P_("Lower stepper sensitivity"),

						      P_("The sensitivity policy for the stepper that points to the adjustment's lower side"),

						      GTK_TYPE_SENSITIVITY_TYPE,

						      GTK_SENSITIVITY_AUTO,

						      GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_UPPER_STEPPER_SENSITIVITY,

                                   g_param_spec_enum ("upper-stepper-sensitivity",

						      P_("Upper stepper sensitivity"),

						      P_("The sensitivity policy for the stepper that points to the adjustment's upper side"),

						      GTK_TYPE_SENSITIVITY_TYPE,

						      GTK_SENSITIVITY_AUTO,

						      GTK_PARAM_READWRITE));

  /**

   * GtkRange:show-fill-level:

   *

   * The show-fill-level property controls whether fill level indicator

   * graphics are displayed on the trough. See

   * gtk_range_set_show_fill_level().

   *

   * Since: 2.12

   **/

  g_object_class_install_property (gobject_class,

                                   PROP_SHOW_FILL_LEVEL,

                                   g_param_spec_boolean ("show-fill-level",

                                                         P_("Show Fill Level"),

                                                         P_("Whether to display a fill level indicator graphics on trough."),

                                                         FALSE,

                                                         GTK_PARAM_READWRITE));

  /**

   * GtkRange:restrict-to-fill-level:

   *

   * The restrict-to-fill-level property controls whether slider

   * movement is restricted to an upper boundary set by the

   * fill level. See gtk_range_set_restrict_to_fill_level().

   *

   * Since: 2.12

   **/

  g_object_class_install_property (gobject_class,

                                   PROP_RESTRICT_TO_FILL_LEVEL,

                                   g_param_spec_boolean ("restrict-to-fill-level",

                                                         P_("Restrict to Fill Level"),

                                                         P_("Whether to restrict the upper boundary to the fill level."),

                                                         TRUE,

                                                         GTK_PARAM_READWRITE));

  /**

   * GtkRange:fill-level:

   *

   * The fill level (e.g. prebuffering of a network stream).

   * See gtk_range_set_fill_level().

   *

   * Since: 2.12

   **/

  g_object_class_install_property (gobject_class,

                                   PROP_FILL_LEVEL,

                                   g_param_spec_double ("fill-level",

							P_("Fill Level"),

							P_("The fill level."),

							-G_MAXDOUBLE,

							G_MAXDOUBLE,

                                                        G_MAXDOUBLE,

                                                        GTK_PARAM_READWRITE));

  /**

   * GtkRange:round-digits:

   *

   * The number of digits to round the value to when

   * it changes, or -1. See #GtkRange::change-value.

   *

   * Since: 2.24

   */

  g_object_class_install_property (gobject_class,

                                   PROP_ROUND_DIGITS,

                                   g_param_spec_int ("round-digits",

                                                     P_("Round Digits"),

                                                     P_("The number of digits to round the value to."),

                                                     -1,

                                                     G_MAXINT,

                                                     -1,

                                                     GTK_PARAM_READWRITE));

  gtk_widget_class_install_style_property (widget_class,

					   g_param_spec_int ("slider-width",

							     P_("Slider Width"),

							     P_("Width of scrollbar or scale thumb"),

							     0,

							     G_MAXINT,

							     14,

							     GTK_PARAM_READABLE));

  gtk_widget_class_install_style_property (widget_class,

					   g_param_spec_int ("trough-border",

                                                             P_("Trough Border"),

                                                             P_("Spacing between thumb/steppers and outer trough bevel"),

                                                             0,

                                                             G_MAXINT,

                                                             1,

                                                             GTK_PARAM_READABLE));

  gtk_widget_class_install_style_property (widget_class,

					   g_param_spec_int ("stepper-size",

							     P_("Stepper Size"),

							     P_("Length of step buttons at ends"),

							     0,

							     G_MAXINT,

							     14,

							     GTK_PARAM_READABLE));

  /**

   * GtkRange:stepper-spacing:

   *

   * The spacing between the stepper buttons and thumb. Note that

   * setting this value to anything > 0 will automatically set the

   * trough-under-steppers style property to %TRUE as well. Also,

   * stepper-spacing won't have any effect if there are no steppers.

   */

  gtk_widget_class_install_style_property (widget_class,

					   g_param_spec_int ("stepper-spacing",

							     P_("Stepper Spacing"),

							     P_("Spacing between step buttons and thumb"),

                                                             0,

							     G_MAXINT,

							     0,

							     GTK_PARAM_READABLE));

  gtk_widget_class_install_style_property (widget_class,

					   g_param_spec_int ("arrow-displacement-x",

							     P_("Arrow X Displacement"),

							     P_("How far in the x direction to move the arrow 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 ("arrow-displacement-y",

							     P_("Arrow Y Displacement"),

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

							     G_MININT,

							     G_MAXINT,

							     0,

							     GTK_PARAM_READABLE));

  /**

   * GtkRange:activate-slider:

   *

   * When %TRUE, sliders will be drawn active and with shadow in

   * while they are dragged.

   *

   * Deprecated: 2.22: This style property will be removed in GTK+ 3

   */

  gtk_widget_class_install_style_property (widget_class,

					   g_param_spec_boolean ("activate-slider",

                                                                 P_("Draw slider ACTIVE during drag"),

							         P_("With this option set to TRUE, sliders will be drawn ACTIVE and with shadow IN while they are dragged"),

							         FALSE,

							         GTK_PARAM_READABLE));

  /**

   * GtkRange:trough-side-details:

   *

   * When %TRUE, the parts of the trough on the two sides of the 

   * slider are drawn with different details.

   *

   * Since: 2.10

   *

   * Deprecated: 2.22: This style property will be removed in GTK+ 3

   */

  gtk_widget_class_install_style_property (widget_class,

                                           g_param_spec_boolean ("trough-side-details",

                                                                 P_("Trough Side Details"),

                                                                 P_("When TRUE, the parts of the trough on the two sides of the slider are drawn with different details"),

                                                                 FALSE,

                                                                 GTK_PARAM_READABLE));

  /**

   * GtkRange:trough-under-steppers:

   *

   * Whether to draw the trough across the full length of the range or

   * to exclude the steppers and their spacing. Note that setting the

   * #GtkRange:stepper-spacing style property to any value > 0 will

   * automatically enable trough-under-steppers too.

   *

   * Since: 2.10

   */

  gtk_widget_class_install_style_property (widget_class,

                                           g_param_spec_boolean ("trough-under-steppers",

                                                                 P_("Trough Under Steppers"),

                                                                 P_("Whether to draw trough for full length of range or exclude the steppers and spacing"),

                                                                 TRUE,

                                                                 GTK_PARAM_READABLE));

  /**

   * GtkRange:arrow-scaling:

   *

   * The arrow size proportion relative to the scroll button size.

   *

   * Since: 2.14

   */

  gtk_widget_class_install_style_property (widget_class,

                                           g_param_spec_float ("arrow-scaling",

							       P_("Arrow scaling"),

							       P_("Arrow scaling with regard to scroll button size"),

							       0.0, 1.0, 0.5,

							       GTK_PARAM_READABLE));

  /**

   * GtkRange:stepper-position-details:

   *

   * When %TRUE, the detail string for rendering the steppers will be

   * suffixed with information about the stepper position.

   *

   * Since: 2.22

   *

   * Deprecated: 2.22: This style property will be removed in GTK+ 3

   */

  gtk_widget_class_install_style_property (widget_class,

                                           g_param_spec_boolean ("stepper-position-details",

                                                                 P_("Stepper Position Details"),

                                                                 P_("When TRUE, the detail string for rendering the steppers is suffixed with position information"),

                                                                 FALSE,

                                                                 GTK_PARAM_READABLE));

  g_type_class_add_private (class, sizeof (GtkRangeLayout));

}

static void

gtk_range_set_property (GObject      *object,

			guint         prop_id,

			const GValue *value,

			GParamSpec   *pspec)

{

  GtkRange *range = GTK_RANGE (object);

  switch (prop_id)

    {

    case PROP_ORIENTATION:

      range->orientation = g_value_get_enum (value);

      range->layout->slider_detail_quark = 0;

      range->layout->stepper_detail_quark[0] = 0;

      range->layout->stepper_detail_quark[1] = 0;

      range->layout->stepper_detail_quark[2] = 0;

      range->layout->stepper_detail_quark[3] = 0;

      gtk_widget_queue_resize (GTK_WIDGET (range));

      break;

    case PROP_UPDATE_POLICY:

      gtk_range_set_update_policy (range, g_value_get_enum (value));

      break;

    case PROP_ADJUSTMENT:

      gtk_range_set_adjustment (range, g_value_get_object (value));

      break;

    case PROP_INVERTED:

      gtk_range_set_inverted (range, g_value_get_boolean (value));

      break;

    case PROP_LOWER_STEPPER_SENSITIVITY:

      gtk_range_set_lower_stepper_sensitivity (range, g_value_get_enum (value));

      break;

    case PROP_UPPER_STEPPER_SENSITIVITY:

      gtk_range_set_upper_stepper_sensitivity (range, g_value_get_enum (value));

      break;

    case PROP_SHOW_FILL_LEVEL:

      gtk_range_set_show_fill_level (range, g_value_get_boolean (value));

      break;

    case PROP_RESTRICT_TO_FILL_LEVEL:

      gtk_range_set_restrict_to_fill_level (range, g_value_get_boolean (value));

      break;

    case PROP_FILL_LEVEL:

      gtk_range_set_fill_level (range, g_value_get_double (value));

      break;

    case PROP_ROUND_DIGITS:

      gtk_range_set_round_digits (range, g_value_get_int (value));

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

static void

gtk_range_get_property (GObject      *object,

			guint         prop_id,

			GValue       *value,

			GParamSpec   *pspec)

{

  GtkRange *range = GTK_RANGE (object);

  switch (prop_id)

    {

    case PROP_ORIENTATION:

      g_value_set_enum (value, range->orientation);

      break;

    case PROP_UPDATE_POLICY:

      g_value_set_enum (value, range->update_policy);

      break;

    case PROP_ADJUSTMENT:

      g_value_set_object (value, range->adjustment);

      break;

    case PROP_INVERTED:

      g_value_set_boolean (value, range->inverted);

      break;

    case PROP_LOWER_STEPPER_SENSITIVITY:

      g_value_set_enum (value, gtk_range_get_lower_stepper_sensitivity (range));

      break;

    case PROP_UPPER_STEPPER_SENSITIVITY:

      g_value_set_enum (value, gtk_range_get_upper_stepper_sensitivity (range));

      break;

    case PROP_SHOW_FILL_LEVEL:

      g_value_set_boolean (value, gtk_range_get_show_fill_level (range));

      break;

    case PROP_RESTRICT_TO_FILL_LEVEL:

      g_value_set_boolean (value, gtk_range_get_restrict_to_fill_level (range));

      break;

    case PROP_FILL_LEVEL:

      g_value_set_double (value, gtk_range_get_fill_level (range));

      break;

    case PROP_ROUND_DIGITS:

      g_value_set_int (value, gtk_range_get_round_digits (range));

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

static void

gtk_range_init (GtkRange *range)

{

  gtk_widget_set_has_window (GTK_WIDGET (range), FALSE);

  range->orientation = GTK_ORIENTATION_HORIZONTAL;

  range->adjustment = NULL;

  range->update_policy = GTK_UPDATE_CONTINUOUS;

  range->inverted = FALSE;

  range->flippable = FALSE;

  range->min_slider_size = 1;

  range->has_stepper_a = FALSE;

  range->has_stepper_b = FALSE;

  range->has_stepper_c = FALSE;

  range->has_stepper_d = FALSE;

  range->need_recalc = TRUE;

  range->round_digits = -1;

  range->layout = GTK_RANGE_GET_PRIVATE (range);

  range->layout->mouse_location = MOUSE_OUTSIDE;

  range->layout->mouse_x = -1;

  range->layout->mouse_y = -1;

  range->layout->grab_location = MOUSE_OUTSIDE;

  range->layout->grab_button = 0;

  range->layout->lower_sensitivity = GTK_SENSITIVITY_AUTO;

  range->layout->upper_sensitivity = GTK_SENSITIVITY_AUTO;

  range->layout->lower_sensitive = TRUE;

  range->layout->upper_sensitive = TRUE;

  range->layout->show_fill_level = FALSE;

  range->layout->restrict_to_fill_level = TRUE;

  range->layout->fill_level = G_MAXDOUBLE;

  range->timer = NULL;  

}

/**

 * gtk_range_get_adjustment:

 * @range: a #GtkRange

 * 

 * Get the #GtkAdjustment which is the "model" object for #GtkRange.

 * See gtk_range_set_adjustment() for details.

 * The return value does not have a reference added, so should not

 * be unreferenced.

 * 

 * Return value: (transfer none): a #GtkAdjustment

 **/

GtkAdjustment*

gtk_range_get_adjustment (GtkRange *range)

{

  g_return_val_if_fail (GTK_IS_RANGE (range), NULL);

  if (!range->adjustment)

    gtk_range_set_adjustment (range, NULL);

  return range->adjustment;

}

/**

 * gtk_range_set_update_policy:

 * @range: a #GtkRange

 * @policy: update policy

 *

 * Sets the update policy for the range. #GTK_UPDATE_CONTINUOUS means that

 * anytime the range slider is moved, the range value will change and the

 * value_changed signal will be emitted. #GTK_UPDATE_DELAYED means that

 * the value will be updated after a brief timeout where no slider motion

 * occurs, so updates are spaced by a short time rather than

 * continuous. #GTK_UPDATE_DISCONTINUOUS means that the value will only

 * be updated when the user releases the button and ends the slider

 * drag operation.

 *

 * Deprecated: 2.24: There is no replacement. If you require delayed

 *   updates, you need to code it yourself.

 **/

void

gtk_range_set_update_policy (GtkRange      *range,

			     GtkUpdateType  policy)

{

  g_return_if_fail (GTK_IS_RANGE (range));

  if (range->update_policy != policy)

    {

      range->update_policy = policy;

      g_object_notify (G_OBJECT (range), "update-policy");

    }

}

/**

 * gtk_range_get_update_policy:

 * @range: a #GtkRange

 *

 * Gets the update policy of @range. See gtk_range_set_update_policy().

 *

 * Return value: the current update policy

 *

 * Deprecated: 2.24: There is no replacement. If you require delayed

 *   updates, you need to code it yourself.

 **/

GtkUpdateType

gtk_range_get_update_policy (GtkRange *range)

{

  g_return_val_if_fail (GTK_IS_RANGE (range), GTK_UPDATE_CONTINUOUS);

  return range->update_policy;

}

/**

 * gtk_range_set_adjustment:

 * @range: a #GtkRange

 * @adjustment: a #GtkAdjustment

 *

 * Sets the adjustment to be used as the "model" object for this range

 * widget. The adjustment indicates the current range value, the

 * minimum and maximum range values, the step/page increments used

 * for keybindings and scrolling, and the page size. The page size

 * is normally 0 for #GtkScale and nonzero for #GtkScrollbar, and

 * indicates the size of the visible area of the widget being scrolled.

 * The page size affects the size of the scrollbar slider.

 **/

void

gtk_range_set_adjustment (GtkRange      *range,

			  GtkAdjustment *adjustment)

{

  g_return_if_fail (GTK_IS_RANGE (range));

  if (!adjustment)

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

  else

    g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));

  if (range->adjustment != adjustment)

    {

      if (range->adjustment)

	{

	  g_signal_handlers_disconnect_by_func (range->adjustment,

						gtk_range_adjustment_changed,

						range);

	  g_signal_handlers_disconnect_by_func (range->adjustment,

						gtk_range_adjustment_value_changed,

						range);

	  g_object_unref (range->adjustment);

	}

      range->adjustment = adjustment;

      g_object_ref_sink (adjustment);

      g_signal_connect (adjustment, "changed",

			G_CALLBACK (gtk_range_adjustment_changed),

			range);

      g_signal_connect (adjustment, "value-changed",

			G_CALLBACK (gtk_range_adjustment_value_changed),

			range);

      gtk_range_adjustment_changed (adjustment, range);

      g_object_notify (G_OBJECT (range), "adjustment");

    }

}

/**

 * gtk_range_set_inverted:

 * @range: a #GtkRange

 * @setting: %TRUE to invert the range

 *

 * Ranges normally move from lower to higher values as the