Pileus Git - ~andy/gtk/blob - gtk/gtkrange.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  * Copyright (C) 2001 Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 /*
  22  * Modified by the GTK+ Team and others 1997-2004.  See the AUTHORS
  23  * file for a list of people on the GTK+ Team.  See the ChangeLog
  24  * files for a list of changes.  These files are distributed with
  25  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  26  */
  27
  28 #include "config.h"
  29 #include <stdio.h>
  30 #include <math.h>
  31 #include <gdk/gdkkeysyms.h>
  32 #include "gtkintl.h"
  33 #include "gtkmain.h"
  34 #include "gtkmarshalers.h"
  35 #include "gtkrange.h"
  36 #include "gtkscrollbar.h"
  37 #include "gtkprivate.h"
  38 #include "gtkalias.h"
  39
  40 #define SCROLL_DELAY_FACTOR 5    /* Scroll repeat multiplier */
  41 #define UPDATE_DELAY        300  /* Delay for queued update */
  42
  43 enum {
  44   PROP_0,
  45   PROP_UPDATE_POLICY,
  46   PROP_ADJUSTMENT,
  47   PROP_INVERTED,
  48   PROP_LOWER_STEPPER_SENSITIVITY,
  49   PROP_UPPER_STEPPER_SENSITIVITY,
  50   PROP_SHOW_FILL_LEVEL,
  51   PROP_RESTRICT_TO_FILL_LEVEL,
  52   PROP_FILL_LEVEL
  53 };
  54
  55 enum {
  56   VALUE_CHANGED,
  57   ADJUST_BOUNDS,
  58   MOVE_SLIDER,
  59   CHANGE_VALUE,
  60   LAST_SIGNAL
  61 };
  62
  63 typedef enum {
  64   MOUSE_OUTSIDE,
  65   MOUSE_STEPPER_A,
  66   MOUSE_STEPPER_B,
  67   MOUSE_STEPPER_C,
  68   MOUSE_STEPPER_D,
  69   MOUSE_TROUGH,
  70   MOUSE_SLIDER,
  71   MOUSE_WIDGET /* inside widget but not in any of the above GUI elements */
  72 } MouseLocation;
  73
  74 #define GTK_RANGE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_RANGE, GtkRangeLayout))
  75
  76 struct _GtkRangeLayout
  77 {
  78   /* These are in widget->window coordinates */
  79   GdkRectangle stepper_a;
  80   GdkRectangle stepper_b;
  81   GdkRectangle stepper_c;
  82   GdkRectangle stepper_d;
  83   /* The trough rectangle is the area the thumb can slide in, not the
  84    * entire range_rect
  85    */
  86   GdkRectangle trough;
  87   GdkRectangle slider;
  88
  89   /* Layout-related state */
  90
  91   MouseLocation mouse_location;
  92   /* last mouse coords we got, or -1 if mouse is outside the range */
  93   gint mouse_x;
  94   gint mouse_y;
  95
  96   /* "grabbed" mouse location, OUTSIDE for no grab */
  97   MouseLocation grab_location;
  98   guint grab_button : 8; /* 0 if none */
  99
 100   /* Stepper sensitivity */
 101   guint lower_sensitive : 1;
 102   guint upper_sensitive : 1;
 103
 104   /* Fill level */
 105   guint show_fill_level : 1;
 106   guint restrict_to_fill_level : 1;
 107
 108   GtkSensitivityType lower_sensitivity;
 109   GtkSensitivityType upper_sensitivity;
 110   guint repaint_id;
 111
 112   gdouble fill_level;
 113 };
 114
 115
 116 static void gtk_range_set_property   (GObject          *object,
 117                                       guint             prop_id,
 118                                       const GValue     *value,
 119                                       GParamSpec       *pspec);
 120 static void gtk_range_get_property   (GObject          *object,
 121                                       guint             prop_id,
 122                                       GValue           *value,
 123                                       GParamSpec       *pspec);
 124 static void gtk_range_destroy        (GtkObject        *object);
 125 static void gtk_range_size_request   (GtkWidget        *widget,
 126                                       GtkRequisition   *requisition);
 127 static void gtk_range_size_allocate  (GtkWidget        *widget,
 128                                       GtkAllocation    *allocation);
 129 static void gtk_range_realize        (GtkWidget        *widget);
 130 static void gtk_range_unrealize      (GtkWidget        *widget);
 131 static void gtk_range_map            (GtkWidget        *widget);
 132 static void gtk_range_unmap          (GtkWidget        *widget);
 133 static gboolean gtk_range_expose         (GtkWidget        *widget,
 134                                       GdkEventExpose   *event);
 135 static gboolean gtk_range_button_press   (GtkWidget        *widget,
 136                                       GdkEventButton   *event);
 137 static gboolean gtk_range_button_release (GtkWidget        *widget,
 138                                       GdkEventButton   *event);
 139 static gboolean gtk_range_motion_notify  (GtkWidget        *widget,
 140                                       GdkEventMotion   *event);
 141 static gboolean gtk_range_enter_notify   (GtkWidget        *widget,
 142                                       GdkEventCrossing *event);
 143 static gboolean gtk_range_leave_notify   (GtkWidget        *widget,
 144                                       GdkEventCrossing *event);
 145 static gboolean gtk_range_grab_broken (GtkWidget          *widget,
 146                                        GdkEventGrabBroken *event);
 147 static void gtk_range_grab_notify    (GtkWidget          *widget,
 148                                       gboolean            was_grabbed);
 149 static void gtk_range_state_changed  (GtkWidget          *widget,
 150                                       GtkStateType        previous_state);
 151 static gboolean gtk_range_scroll_event   (GtkWidget        *widget,
 152                                       GdkEventScroll   *event);
 153 static void gtk_range_style_set      (GtkWidget        *widget,
 154                                       GtkStyle         *previous_style);
 155 static void update_slider_position   (GtkRange         *range,
 156                                       gint              mouse_x,
 157                                       gint              mouse_y);
 158 static void stop_scrolling           (GtkRange         *range);
 159
 160 /* Range methods */
 161
 162 static void gtk_range_move_slider              (GtkRange         *range,
 163                                                 GtkScrollType     scroll);
 164
 165 /* Internals */
 166 static gboolean      gtk_range_scroll                   (GtkRange      *range,
 167                                                          GtkScrollType  scroll);
 168 static gboolean      gtk_range_update_mouse_location    (GtkRange      *range);
 169 static void          gtk_range_calc_layout              (GtkRange      *range,
 170                                                          gdouble        adjustment_value);
 171 static void          gtk_range_get_props                (GtkRange      *range,
 172                                                          gint          *slider_width,
 173                                                          gint          *stepper_size,
 174                                                          gint          *focus_width,
 175                                                          gint          *trough_border,
 176                                                          gint          *stepper_spacing,
 177                                                          gboolean      *trough_under_steppers,
 178                                                          gint          *arrow_displacement_x,
 179                                                          gint          *arrow_displacement_y);
 180 static void          gtk_range_calc_request             (GtkRange      *range,
 181                                                          gint           slider_width,
 182                                                          gint           stepper_size,
 183                                                          gint           focus_width,
 184                                                          gint           trough_border,
 185                                                          gint           stepper_spacing,
 186                                                          GdkRectangle  *range_rect,
 187                                                          GtkBorder     *border,
 188                                                          gint          *n_steppers_p,
 189                                                          gboolean      *has_steppers_ab,
 190                                                          gboolean      *has_steppers_cd,
 191                                                          gint          *slider_length_p);
 192 static void          gtk_range_adjustment_value_changed (GtkAdjustment *adjustment,
 193                                                          gpointer       data);
 194 static void          gtk_range_adjustment_changed       (GtkAdjustment *adjustment,
 195                                                          gpointer       data);
 196 static void          gtk_range_add_step_timer           (GtkRange      *range,
 197                                                          GtkScrollType  step);
 198 static void          gtk_range_remove_step_timer        (GtkRange      *range);
 199 static void          gtk_range_reset_update_timer       (GtkRange      *range);
 200 static void          gtk_range_remove_update_timer      (GtkRange      *range);
 201 static GdkRectangle* get_area                           (GtkRange      *range,
 202                                                          MouseLocation  location);
 203 static gboolean      gtk_range_real_change_value        (GtkRange      *range,
 204                                                          GtkScrollType  scroll,
 205                                                          gdouble        value);
 206 static void          gtk_range_update_value             (GtkRange      *range);
 207 static gboolean      gtk_range_key_press                (GtkWidget     *range,
 208                                                          GdkEventKey   *event);
 209
 210
 211 static guint signals[LAST_SIGNAL];
 212
 213 G_DEFINE_ABSTRACT_TYPE (GtkRange, gtk_range, GTK_TYPE_WIDGET)
 214
 215 static void
 216 gtk_range_class_init (GtkRangeClass *class)
 217 {
 218   GObjectClass   *gobject_class;
 219   GtkObjectClass *object_class;
 220   GtkWidgetClass *widget_class;
 221
 222   gobject_class = G_OBJECT_CLASS (class);
 223   object_class = (GtkObjectClass*) class;
 224   widget_class = (GtkWidgetClass*) class;
 225
 226   gobject_class->set_property = gtk_range_set_property;
 227   gobject_class->get_property = gtk_range_get_property;
 228   object_class->destroy = gtk_range_destroy;
 229
 230   widget_class->size_request = gtk_range_size_request;
 231   widget_class->size_allocate = gtk_range_size_allocate;
 232   widget_class->realize = gtk_range_realize;
 233   widget_class->unrealize = gtk_range_unrealize;
 234   widget_class->map = gtk_range_map;
 235   widget_class->unmap = gtk_range_unmap;
 236   widget_class->expose_event = gtk_range_expose;
 237   widget_class->button_press_event = gtk_range_button_press;
 238   widget_class->button_release_event = gtk_range_button_release;
 239   widget_class->motion_notify_event = gtk_range_motion_notify;
 240   widget_class->scroll_event = gtk_range_scroll_event;
 241   widget_class->enter_notify_event = gtk_range_enter_notify;
 242   widget_class->leave_notify_event = gtk_range_leave_notify;
 243   widget_class->grab_broken_event = gtk_range_grab_broken;
 244   widget_class->grab_notify = gtk_range_grab_notify;
 245   widget_class->state_changed = gtk_range_state_changed;
 246   widget_class->style_set = gtk_range_style_set;
 247   widget_class->key_press_event = gtk_range_key_press;
 248
 249   class->move_slider = gtk_range_move_slider;
 250   class->change_value = gtk_range_real_change_value;
 251
 252   class->slider_detail = "slider";
 253   class->stepper_detail = "stepper";
 254
 255   /**
 256    * GtkRange::value-changed:
 257    * @range: the #GtkRange
 258    *
 259    * Emitted when the range value changes.
 260    */
 261   signals[VALUE_CHANGED] =
 262     g_signal_new (I_("value_changed"),
 263                   G_TYPE_FROM_CLASS (gobject_class),
 264                   G_SIGNAL_RUN_LAST,
 265                   G_STRUCT_OFFSET (GtkRangeClass, value_changed),
 266                   NULL, NULL,
 267                   _gtk_marshal_NONE__NONE,
 268                   G_TYPE_NONE, 0);
 269
 270   signals[ADJUST_BOUNDS] =
 271     g_signal_new (I_("adjust_bounds"),
 272                   G_TYPE_FROM_CLASS (gobject_class),
 273                   G_SIGNAL_RUN_LAST,
 274                   G_STRUCT_OFFSET (GtkRangeClass, adjust_bounds),
 275                   NULL, NULL,
 276                   _gtk_marshal_VOID__DOUBLE,
 277                   G_TYPE_NONE, 1,
 278                   G_TYPE_DOUBLE);
 279
 280   /**
 281    * GtkRange::move-slider:
 282    * @range: the #GtkRange
 283    * @step: how to move the slider
 284    *
 285    * Virtual function that moves the slider. Used for keybindings.
 286    */
 287   signals[MOVE_SLIDER] =
 288     g_signal_new (I_("move_slider"),
 289                   G_TYPE_FROM_CLASS (gobject_class),
 290                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 291                   G_STRUCT_OFFSET (GtkRangeClass, move_slider),
 292                   NULL, NULL,
 293                   _gtk_marshal_VOID__ENUM,
 294                   G_TYPE_NONE, 1,
 295                   GTK_TYPE_SCROLL_TYPE);
 296
 297   /**
 298    * GtkRange::change-value:
 299    * @range: the range that received the signal
 300    * @scroll: the type of scroll action that was performed
 301    * @value: the new value resulting from the scroll action
 302    * @returns: %TRUE to prevent other handlers from being invoked for the
 303    * signal, %FALSE to propagate the signal further
 304    *
 305    * The ::change-value signal is emitted when a scroll action is
 306    * performed on a range.  It allows an application to determine the
 307    * type of scroll event that occurred and the resultant new value.
 308    * The application can handle the event itself and return %TRUE to
 309    * prevent further processing.  Or, by returning %FALSE, it can pass
 310    * the event to other handlers until the default GTK+ handler is
 311    * reached.
 312    *
 313    * The value parameter is unrounded.  An application that overrides
 314    * the ::change-value signal is responsible for clamping the value to
 315    * the desired number of decimal digits; the default GTK+ handler
 316    * clamps the value based on @range->round_digits.
 317    *
 318    * It is not possible to use delayed update policies in an overridden
 319    * ::change-value handler.
 320    *
 321    * Since: 2.6
 322    */
 323   signals[CHANGE_VALUE] =
 324     g_signal_new (I_("change_value"),
 325                   G_TYPE_FROM_CLASS (gobject_class),
 326                   G_SIGNAL_RUN_LAST,
 327                   G_STRUCT_OFFSET (GtkRangeClass, change_value),
 328                   _gtk_boolean_handled_accumulator, NULL,
 329                   _gtk_marshal_BOOLEAN__ENUM_DOUBLE,
 330                   G_TYPE_BOOLEAN, 2,
 331                   GTK_TYPE_SCROLL_TYPE,
 332                   G_TYPE_DOUBLE);
 333
 334   g_object_class_install_property (gobject_class,
 335                                    PROP_UPDATE_POLICY,
 336                                    g_param_spec_enum ("update-policy",
 337                                                       P_("Update policy"),
 338                                                       P_("How the range should be updated on the screen"),
 339                                                       GTK_TYPE_UPDATE_TYPE,
 340                                                       GTK_UPDATE_CONTINUOUS,
 341                                                       GTK_PARAM_READWRITE));
 342
 343   g_object_class_install_property (gobject_class,
 344                                    PROP_ADJUSTMENT,
 345                                    g_param_spec_object ("adjustment",
 346                                                         P_("Adjustment"),
 347                                                         P_("The GtkAdjustment that contains the current value of this range object"),
 348                                                         GTK_TYPE_ADJUSTMENT,
 349                                                         GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
 350
 351   g_object_class_install_property (gobject_class,
 352                                    PROP_INVERTED,
 353                                    g_param_spec_boolean ("inverted",
 354                                                         P_("Inverted"),
 355                                                         P_("Invert direction slider moves to increase range value"),
 356                                                          FALSE,
 357                                                          GTK_PARAM_READWRITE));
 358
 359   g_object_class_install_property (gobject_class,
 360                                    PROP_LOWER_STEPPER_SENSITIVITY,
 361                                    g_param_spec_enum ("lower-stepper-sensitivity",
 362                                                       P_("Lower stepper sensitivity"),
 363                                                       P_("The sensitivity policy for the stepper that points to the adjustment's lower side"),
 364                                                       GTK_TYPE_SENSITIVITY_TYPE,
 365                                                       GTK_SENSITIVITY_AUTO,
 366                                                       GTK_PARAM_READWRITE));
 367
 368   g_object_class_install_property (gobject_class,
 369                                    PROP_UPPER_STEPPER_SENSITIVITY,
 370                                    g_param_spec_enum ("upper-stepper-sensitivity",
 371                                                       P_("Upper stepper sensitivity"),
 372                                                       P_("The sensitivity policy for the stepper that points to the adjustment's upper side"),
 373                                                       GTK_TYPE_SENSITIVITY_TYPE,
 374                                                       GTK_SENSITIVITY_AUTO,
 375                                                       GTK_PARAM_READWRITE));
 376
 377   /**
 378    * GtkRange:show-fill-level:
 379    *
 380    * The show-fill-level property controls whether fill level indicator
 381    * graphics are displayed on the trough. See
 382    * gtk_range_set_show_fill_level().
 383    *
 384    * Since: 2.12
 385    **/
 386   g_object_class_install_property (gobject_class,
 387                                    PROP_SHOW_FILL_LEVEL,
 388                                    g_param_spec_boolean ("show-fill-level",
 389                                                          P_("Show Fill Level"),
 390                                                          P_("Whether to display a fill level indicator graphics on trough."),
 391                                                          FALSE,
 392                                                          GTK_PARAM_READWRITE));
 393
 394   /**
 395    * GtkRange:restrict-to-fill-level:
 396    *
 397    * The restrict-to-fill-level property controls whether slider
 398    * movement is restricted to an upper boundary set by the
 399    * fill level. See gtk_range_set_restrict_to_fill_level().
 400    *
 401    * Since: 2.12
 402    **/
 403   g_object_class_install_property (gobject_class,
 404                                    PROP_RESTRICT_TO_FILL_LEVEL,
 405                                    g_param_spec_boolean ("restrict-to-fill-level",
 406                                                          P_("Restrict to Fill Level"),
 407                                                          P_("Whether to restrict the upper boundary to the fill level."),
 408                                                          TRUE,
 409                                                          GTK_PARAM_READWRITE));
 410
 411   /**
 412    * GtkRange:fill-level:
 413    *
 414    * The fill level (e.g. prebuffering of a network stream).
 415    * See gtk_range_set_fill_level().
 416    *
 417    * Since: 2.12
 418    **/
 419   g_object_class_install_property (gobject_class,
 420                                    PROP_FILL_LEVEL,
 421                                    g_param_spec_double ("fill-level",
 422                                                         P_("Fill Level"),
 423                                                         P_("The fill level."),
 424                                                         -G_MAXDOUBLE,
 425                                                         G_MAXDOUBLE,
 426                                                         G_MAXDOUBLE,
 427                                                         GTK_PARAM_READWRITE));
 428
 429   gtk_widget_class_install_style_property (widget_class,
 430                                            g_param_spec_int ("slider-width",
 431                                                              P_("Slider Width"),
 432                                                              P_("Width of scrollbar or scale thumb"),
 433                                                              0,
 434                                                              G_MAXINT,
 435                                                              14,
 436                                                              GTK_PARAM_READABLE));
 437   gtk_widget_class_install_style_property (widget_class,
 438                                            g_param_spec_int ("trough-border",
 439                                                              P_("Trough Border"),
 440                                                              P_("Spacing between thumb/steppers and outer trough bevel"),
 441                                                              0,
 442                                                              G_MAXINT,
 443                                                              1,
 444                                                              GTK_PARAM_READABLE));
 445   gtk_widget_class_install_style_property (widget_class,
 446                                            g_param_spec_int ("stepper-size",
 447                                                              P_("Stepper Size"),
 448                                                              P_("Length of step buttons at ends"),
 449                                                              0,
 450                                                              G_MAXINT,
 451                                                              14,
 452                                                              GTK_PARAM_READABLE));
 453   /**
 454    * GtkRange:stepper-spacing:
 455    *
 456    * The spacing between the stepper buttons and thumb. Note that
 457    * setting this value to anything > 0 will automatically set the
 458    * trough-under-steppers style property to %TRUE as well. Also,
 459    * stepper-spacing won't have any effect if there are no steppers.
 460    */
 461   gtk_widget_class_install_style_property (widget_class,
 462                                            g_param_spec_int ("stepper-spacing",
 463                                                              P_("Stepper Spacing"),
 464                                                              P_("Spacing between step buttons and thumb"),
 465                                                              0,
 466                                                              G_MAXINT,
 467                                                              0,
 468                                                              GTK_PARAM_READABLE));
 469   gtk_widget_class_install_style_property (widget_class,
 470                                            g_param_spec_int ("arrow-displacement-x",
 471                                                              P_("Arrow X Displacement"),
 472                                                              P_("How far in the x direction to move the arrow when the button is depressed"),
 473                                                              G_MININT,
 474                                                              G_MAXINT,
 475                                                              0,
 476                                                              GTK_PARAM_READABLE));
 477   gtk_widget_class_install_style_property (widget_class,
 478                                            g_param_spec_int ("arrow-displacement-y",
 479                                                              P_("Arrow Y Displacement"),
 480                                                              P_("How far in the y direction to move the arrow when the button is depressed"),
 481                                                              G_MININT,
 482                                                              G_MAXINT,
 483                                                              0,
 484                                                              GTK_PARAM_READABLE));
 485
 486   gtk_widget_class_install_style_property (widget_class,
 487                                            g_param_spec_boolean ("activate-slider",
 488                                                                  P_("Draw slider ACTIVE during drag"),
 489                                                                  P_("With this option set to TRUE, sliders will be drawn ACTIVE and with shadow IN while they are dragged"),
 490                                                                  FALSE,
 491                                                                  GTK_PARAM_READABLE));
 492
 493   /**
 494    * GtkRange:trough-side-details:
 495    *
 496    * When %TRUE, the parts of the trough on the two sides of the
 497    * slider are drawn with different details.
 498    *
 499    * Since: 2.10
 500    */
 501   gtk_widget_class_install_style_property (widget_class,
 502                                            g_param_spec_boolean ("trough-side-details",
 503                                                                  P_("Trough Side Details"),
 504                                                                  P_("When TRUE, the parts of the trough on the two sides of the slider are drawn with different details"),
 505                                                                  FALSE,
 506                                                                  GTK_PARAM_READABLE));
 507
 508   /**
 509    * GtkRange:trough-under-steppers:
 510    *
 511    * Whether to draw the trough across the full length of the range or
 512    * to exclude the steppers and their spacing. Note that setting the
 513    * #GtkRange:stepper-spacing style property to any value > 0 will
 514    * automatically enable trough-under-steppers too.
 515    *
 516    * Since: 2.10
 517    */
 518   gtk_widget_class_install_style_property (widget_class,
 519                                            g_param_spec_boolean ("trough-under-steppers",
 520                                                                  P_("Trough Under Steppers"),
 521                                                                  P_("Whether to draw trough for full length of range or exclude the steppers and spacing"),
 522                                                                  TRUE,
 523                                                                  GTK_PARAM_READABLE));
 524
 525   g_type_class_add_private (class, sizeof (GtkRangeLayout));
 526 }
 527
 528 static void
 529 gtk_range_set_property (GObject      *object,
 530                         guint         prop_id,
 531                         const GValue *value,
 532                         GParamSpec   *pspec)
 533 {
 534   GtkRange *range;
 535
 536   range = GTK_RANGE (object);
 537
 538   switch (prop_id)
 539     {
 540     case PROP_UPDATE_POLICY:
 541       gtk_range_set_update_policy (range, g_value_get_enum (value));
 542       break;
 543     case PROP_ADJUSTMENT:
 544       gtk_range_set_adjustment (range, g_value_get_object (value));
 545       break;
 546     case PROP_INVERTED:
 547       gtk_range_set_inverted (range, g_value_get_boolean (value));
 548       break;
 549     case PROP_LOWER_STEPPER_SENSITIVITY:
 550       gtk_range_set_lower_stepper_sensitivity (range, g_value_get_enum (value));
 551       break;
 552     case PROP_UPPER_STEPPER_SENSITIVITY:
 553       gtk_range_set_upper_stepper_sensitivity (range, g_value_get_enum (value));
 554       break;
 555     case PROP_SHOW_FILL_LEVEL:
 556       gtk_range_set_show_fill_level (range, g_value_get_boolean (value));
 557       break;
 558     case PROP_RESTRICT_TO_FILL_LEVEL:
 559       gtk_range_set_restrict_to_fill_level (range, g_value_get_boolean (value));
 560       break;
 561     case PROP_FILL_LEVEL:
 562       gtk_range_set_fill_level (range, g_value_get_double (value));
 563       break;
 564     default:
 565       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 566       break;
 567     }
 568 }
 569
 570 static void
 571 gtk_range_get_property (GObject      *object,
 572                         guint         prop_id,
 573                         GValue       *value,
 574                         GParamSpec   *pspec)
 575 {
 576   GtkRange *range;
 577
 578   range = GTK_RANGE (object);
 579
 580   switch (prop_id)
 581     {
 582     case PROP_UPDATE_POLICY:
 583       g_value_set_enum (value, range->update_policy);
 584       break;
 585     case PROP_ADJUSTMENT:
 586       g_value_set_object (value, range->adjustment);
 587       break;
 588     case PROP_INVERTED:
 589       g_value_set_boolean (value, range->inverted);
 590       break;
 591     case PROP_LOWER_STEPPER_SENSITIVITY:
 592       g_value_set_enum (value, gtk_range_get_lower_stepper_sensitivity (range));
 593       break;
 594     case PROP_UPPER_STEPPER_SENSITIVITY:
 595       g_value_set_enum (value, gtk_range_get_upper_stepper_sensitivity (range));
 596       break;
 597     case PROP_SHOW_FILL_LEVEL:
 598       g_value_set_boolean (value, gtk_range_get_show_fill_level (range));
 599       break;
 600     case PROP_RESTRICT_TO_FILL_LEVEL:
 601       g_value_set_boolean (value, gtk_range_get_restrict_to_fill_level (range));
 602       break;
 603     case PROP_FILL_LEVEL:
 604       g_value_set_double (value, gtk_range_get_fill_level (range));
 605       break;
 606     default:
 607       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 608       break;
 609     }
 610 }
 611
 612 static void
 613 gtk_range_init (GtkRange *range)
 614 {
 615   GTK_WIDGET_SET_FLAGS (range, GTK_NO_WINDOW);
 616
 617   range->adjustment = NULL;
 618   range->update_policy = GTK_UPDATE_CONTINUOUS;
 619   range->inverted = FALSE;
 620   range->flippable = FALSE;
 621   range->min_slider_size = 1;
 622   range->has_stepper_a = FALSE;
 623   range->has_stepper_b = FALSE;
 624   range->has_stepper_c = FALSE;
 625   range->has_stepper_d = FALSE;
 626   range->need_recalc = TRUE;
 627   range->round_digits = -1;
 628   range->layout = GTK_RANGE_GET_PRIVATE (range);
 629   range->layout->mouse_location = MOUSE_OUTSIDE;
 630   range->layout->mouse_x = -1;
 631   range->layout->mouse_y = -1;
 632   range->layout->grab_location = MOUSE_OUTSIDE;
 633   range->layout->grab_button = 0;
 634   range->layout->lower_sensitivity = GTK_SENSITIVITY_AUTO;
 635   range->layout->upper_sensitivity = GTK_SENSITIVITY_AUTO;
 636   range->layout->lower_sensitive = TRUE;
 637   range->layout->upper_sensitive = TRUE;
 638   range->layout->show_fill_level = FALSE;
 639   range->layout->restrict_to_fill_level = TRUE;
 640   range->layout->fill_level = G_MAXDOUBLE;
 641   range->timer = NULL;
 642 }
 643
 644 /**
 645  * gtk_range_get_adjustment:
 646  * @range: a #GtkRange
 647  *
 648  * Get the #GtkAdjustment which is the "model" object for #GtkRange.
 649  * See gtk_range_set_adjustment() for details.
 650  * The return value does not have a reference added, so should not
 651  * be unreferenced.
 652  *
 653  * Return value: a #GtkAdjustment
 654  **/
 655 GtkAdjustment*
 656 gtk_range_get_adjustment (GtkRange *range)
 657 {
 658   g_return_val_if_fail (GTK_IS_RANGE (range), NULL);
 659
 660   if (!range->adjustment)
 661     gtk_range_set_adjustment (range, NULL);
 662
 663   return range->adjustment;
 664 }
 665
 666 /**
 667  * gtk_range_set_update_policy:
 668  * @range: a #GtkRange
 669  * @policy: update policy
 670  *
 671  * Sets the update policy for the range. #GTK_UPDATE_CONTINUOUS means that
 672  * anytime the range slider is moved, the range value will change and the
 673  * value_changed signal will be emitted. #GTK_UPDATE_DELAYED means that
 674  * the value will be updated after a brief timeout where no slider motion
 675  * occurs, so updates are spaced by a short time rather than
 676  * continuous. #GTK_UPDATE_DISCONTINUOUS means that the value will only
 677  * be updated when the user releases the button and ends the slider
 678  * drag operation.
 679  **/
 680 void
 681 gtk_range_set_update_policy (GtkRange      *range,
 682                              GtkUpdateType  policy)
 683 {
 684   g_return_if_fail (GTK_IS_RANGE (range));
 685
 686   if (range->update_policy != policy)
 687     {
 688       range->update_policy = policy;
 689       g_object_notify (G_OBJECT (range), "update-policy");
 690     }
 691 }
 692
 693 /**
 694  * gtk_range_get_update_policy:
 695  * @range: a #GtkRange
 696  *
 697  * Gets the update policy of @range. See gtk_range_set_update_policy().
 698  *
 699  * Return value: the current update policy
 700  **/
 701 GtkUpdateType
 702 gtk_range_get_update_policy (GtkRange *range)
 703 {
 704   g_return_val_if_fail (GTK_IS_RANGE (range), GTK_UPDATE_CONTINUOUS);
 705
 706   return range->update_policy;
 707 }
 708
 709 /**
 710  * gtk_range_set_adjustment:
 711  * @range: a #GtkRange
 712  * @adjustment: a #GtkAdjustment
 713  *
 714  * Sets the adjustment to be used as the "model" object for this range
 715  * widget. The adjustment indicates the current range value, the
 716  * minimum and maximum range values, the step/page increments used
 717  * for keybindings and scrolling, and the page size. The page size
 718  * is normally 0 for #GtkScale and nonzero for #GtkScrollbar, and
 719  * indicates the size of the visible area of the widget being scrolled.
 720  * The page size affects the size of the scrollbar slider.
 721  **/
 722 void
 723 gtk_range_set_adjustment (GtkRange      *range,
 724                           GtkAdjustment *adjustment)
 725 {
 726   g_return_if_fail (GTK_IS_RANGE (range));
 727
 728   if (!adjustment)
 729     adjustment = (GtkAdjustment*) gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
 730   else
 731     g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
 732
 733   if (range->adjustment != adjustment)
 734     {
 735       if (range->adjustment)
 736         {
 737           g_signal_handlers_disconnect_by_func (range->adjustment,
 738                                                 gtk_range_adjustment_changed,
 739                                                 range);
 740           g_signal_handlers_disconnect_by_func (range->adjustment,
 741                                                 gtk_range_adjustment_value_changed,
 742                                                 range);
 743           g_object_unref (range->adjustment);
 744         }
 745
 746       range->adjustment = adjustment;
 747       g_object_ref_sink (adjustment);
 748
 749       g_signal_connect (adjustment, "changed",
 750                         G_CALLBACK (gtk_range_adjustment_changed),
 751                         range);
 752       g_signal_connect (adjustment, "value_changed",
 753                         G_CALLBACK (gtk_range_adjustment_value_changed),
 754                         range);
 755
 756       gtk_range_adjustment_changed (adjustment, range);
 757       g_object_notify (G_OBJECT (range), "adjustment");
 758     }
 759 }
 760
 761 /**
 762  * gtk_range_set_inverted:
 763  * @range: a #GtkRange
 764  * @setting: %TRUE to invert the range
 765  *
 766  * Ranges normally move from lower to higher values as the
 767  * slider moves from top to bottom or left to right. Inverted
 768  * ranges have higher values at the top or on the right rather than
 769  * on the bottom or left.
 770  **/
 771 void
 772 gtk_range_set_inverted (GtkRange *range,
 773                         gboolean  setting)
 774 {
 775   g_return_if_fail (GTK_IS_RANGE (range));
 776
 777   setting = setting != FALSE;
 778
 779   if (setting != range->inverted)
 780     {
 781       range->inverted = setting;
 782       g_object_notify (G_OBJECT (range), "inverted");
 783       gtk_widget_queue_resize (GTK_WIDGET (range));
 784     }
 785 }
 786
 787 /**
 788  * gtk_range_get_inverted:
 789  * @range: a #GtkRange
 790  *
 791  * Gets the value set by gtk_range_set_inverted().
 792  *
 793  * Return value: %TRUE if the range is inverted
 794  **/
 795 gboolean
 796 gtk_range_get_inverted (GtkRange *range)
 797 {
 798   g_return_val_if_fail (GTK_IS_RANGE (range), FALSE);
 799
 800   return range->inverted;
 801 }
 802
 803 /**
 804  * gtk_range_set_lower_stepper_sensitivity:
 805  * @range:       a #GtkRange
 806  * @sensitivity: the lower stepper's sensitivity policy.
 807  *
 808  * Sets the sensitivity policy for the stepper that points to the
 809  * 'lower' end of the GtkRange's adjustment.
 810  *
 811  * Since: 2.10
 812  **/
 813 void
 814 gtk_range_set_lower_stepper_sensitivity (GtkRange           *range,
 815                                          GtkSensitivityType  sensitivity)
 816 {
 817   g_return_if_fail (GTK_IS_RANGE (range));
 818
 819   if (range->layout->lower_sensitivity != sensitivity)
 820     {
 821       range->layout->lower_sensitivity = sensitivity;
 822
 823       range->need_recalc = TRUE;
 824       gtk_range_calc_layout (range, range->adjustment->value);
 825       gtk_widget_queue_draw (GTK_WIDGET (range));
 826
 827       g_object_notify (G_OBJECT (range), "lower-stepper-sensitivity");
 828     }
 829 }
 830
 831 /**
 832  * gtk_range_get_lower_stepper_sensitivity:
 833  * @range: a #GtkRange
 834  *
 835  * Gets the sensitivity policy for the stepper that points to the
 836  * 'lower' end of the GtkRange's adjustment.
 837  *
 838  * Return value: The lower stepper's sensitivity policy.
 839  *
 840  * Since: 2.10
 841  **/
 842 GtkSensitivityType
 843 gtk_range_get_lower_stepper_sensitivity (GtkRange *range)
 844 {
 845   g_return_val_if_fail (GTK_IS_RANGE (range), GTK_SENSITIVITY_AUTO);
 846
 847   return range->layout->lower_sensitivity;
 848 }
 849
 850 /**
 851  * gtk_range_set_upper_stepper_sensitivity:
 852  * @range:       a #GtkRange
 853  * @sensitivity: the upper stepper's sensitivity policy.
 854  *
 855  * Sets the sensitivity policy for the stepper that points to the
 856  * 'upper' end of the GtkRange's adjustment.
 857  *
 858  * Since: 2.10
 859  **/
 860 void
 861 gtk_range_set_upper_stepper_sensitivity (GtkRange           *range,
 862                                          GtkSensitivityType  sensitivity)
 863 {
 864   g_return_if_fail (GTK_IS_RANGE (range));
 865
 866   if (range->layout->upper_sensitivity != sensitivity)
 867     {
 868       range->layout->upper_sensitivity = sensitivity;
 869
 870       range->need_recalc = TRUE;
 871       gtk_range_calc_layout (range, range->adjustment->value);
 872       gtk_widget_queue_draw (GTK_WIDGET (range));
 873
 874       g_object_notify (G_OBJECT (range), "upper-stepper-sensitivity");
 875     }
 876 }
 877
 878 /**
 879  * gtk_range_get_upper_stepper_sensitivity:
 880  * @range: a #GtkRange
 881  *
 882  * Gets the sensitivity policy for the stepper that points to the
 883  * 'upper' end of the GtkRange's adjustment.
 884  *
 885  * Return value: The upper stepper's sensitivity policy.
 886  *
 887  * Since: 2.10
 888  **/
 889 GtkSensitivityType
 890 gtk_range_get_upper_stepper_sensitivity (GtkRange *range)
 891 {
 892   g_return_val_if_fail (GTK_IS_RANGE (range), GTK_SENSITIVITY_AUTO);
 893
 894   return range->layout->upper_sensitivity;
 895 }
 896
 897 /**
 898  * gtk_range_set_increments:
 899  * @range: a #GtkRange
 900  * @step: step size
 901  * @page: page size
 902  *
 903  * Sets the step and page sizes for the range.
 904  * The step size is used when the user clicks the #GtkScrollbar
 905  * arrows or moves #GtkScale via arrow keys. The page size
 906  * is used for example when moving via Page Up or Page Down keys.
 907  **/
 908 void
 909 gtk_range_set_increments (GtkRange *range,
 910                           gdouble   step,
 911                           gdouble   page)
 912 {
 913   g_return_if_fail (GTK_IS_RANGE (range));
 914
 915   range->adjustment->step_increment = step;
 916   range->adjustment->page_increment = page;
 917
 918   gtk_adjustment_changed (range->adjustment);
 919 }
 920
 921 /**
 922  * gtk_range_set_range:
 923  * @range: a #GtkRange
 924  * @min: minimum range value
 925  * @max: maximum range value
 926  *
 927  * Sets the allowable values in the #GtkRange, and clamps the range
 928  * value to be between @min and @max. (If the range has a non-zero
 929  * page size, it is clamped between @min and @max - page-size.)
 930  **/
 931 void
 932 gtk_range_set_range (GtkRange *range,
 933                      gdouble   min,
 934                      gdouble   max)
 935 {
 936   gdouble value;
 937
 938   g_return_if_fail (GTK_IS_RANGE (range));
 939   g_return_if_fail (min < max);
 940
 941   range->adjustment->lower = min;
 942   range->adjustment->upper = max;
 943
 944   value = range->adjustment->value;
 945
 946   if (range->layout->restrict_to_fill_level)
 947     value = MIN (value, MAX (range->adjustment->lower,
 948                              range->layout->fill_level));
 949
 950   value = CLAMP (value, range->adjustment->lower,
 951                  (range->adjustment->upper - range->adjustment->page_size));
 952
 953   gtk_adjustment_set_value (range->adjustment, value);
 954   gtk_adjustment_changed (range->adjustment);
 955 }
 956
 957 /**
 958  * gtk_range_set_value:
 959  * @range: a #GtkRange
 960  * @value: new value of the range
 961  *
 962  * Sets the current value of the range; if the value is outside the
 963  * minimum or maximum range values, it will be clamped to fit inside
 964  * them. The range emits the #GtkRange::value-changed signal if the
 965  * value changes.
 966  **/
 967 void
 968 gtk_range_set_value (GtkRange *range,
 969                      gdouble   value)
 970 {
 971   g_return_if_fail (GTK_IS_RANGE (range));
 972
 973   if (range->layout->restrict_to_fill_level)
 974     value = MIN (value, MAX (range->adjustment->lower,
 975                              range->layout->fill_level));
 976
 977   value = CLAMP (value, range->adjustment->lower,
 978                  (range->adjustment->upper - range->adjustment->page_size));
 979
 980   gtk_adjustment_set_value (range->adjustment, value);
 981 }
 982
 983 /**
 984  * gtk_range_get_value:
 985  * @range: a #GtkRange
 986  *
 987  * Gets the current value of the range.
 988  *
 989  * Return value: current value of the range.
 990  **/
 991 gdouble
 992 gtk_range_get_value (GtkRange *range)
 993 {
 994   g_return_val_if_fail (GTK_IS_RANGE (range), 0.0);
 995
 996   return range->adjustment->value;
 997 }
 998
 999 /**
1000  * gtk_range_set_show_fill_level:
1001  * @range:           A #GtkRange
1002  * @show_fill_level: Whether a fill level indicator graphics is shown.
1003  *
1004  * Sets whether a graphical fill level is show on the trough. See
1005  * gtk_range_set_fill_level() for a general description of the fill
1006  * level concept.
1007  *
1008  * Since: 2.12
1009  **/
1010 void
1011 gtk_range_set_show_fill_level (GtkRange *range,
1012                                gboolean  show_fill_level)
1013 {
1014   g_return_if_fail (GTK_IS_RANGE (range));
1015
1016   show_fill_level = show_fill_level ? TRUE : FALSE;
1017
1018   if (show_fill_level != range->layout->show_fill_level)
1019     {
1020       range->layout->show_fill_level = show_fill_level;
1021       g_object_notify (G_OBJECT (range), "show-fill-level");
1022       gtk_widget_queue_draw (GTK_WIDGET (range));
1023     }
1024 }
1025
1026 /**
1027  * gtk_range_get_show_fill_level:
1028  * @range: A #GtkRange
1029  *
1030  * Gets whether the range displays the fill level graphically.
1031  *
1032  * Return value: %TRUE if @range shows the fill level.
1033  *
1034  * Since: 2.12
1035  **/
1036 gboolean
1037 gtk_range_get_show_fill_level (GtkRange *range)
1038 {
1039   g_return_val_if_fail (GTK_IS_RANGE (range), FALSE);
1040
1041   return range->layout->show_fill_level;
1042 }
1043
1044 /**
1045  * gtk_range_set_restrict_to_fill_level:
1046  * @range:                  A #GtkRange
1047  * @restrict_to_fill_level: Whether the fill level restricts slider movement.
1048  *
1049  * Sets whether the slider is restricted to the fill level. See
1050  * gtk_range_set_fill_level() for a general description of the fill
1051  * level concept.
1052  *
1053  * Since: 2.12
1054  **/
1055 void
1056 gtk_range_set_restrict_to_fill_level (GtkRange *range,
1057                                       gboolean  restrict_to_fill_level)
1058 {
1059   g_return_if_fail (GTK_IS_RANGE (range));
1060
1061   restrict_to_fill_level = restrict_to_fill_level ? TRUE : FALSE;
1062
1063   if (restrict_to_fill_level != range->layout->restrict_to_fill_level)
1064     {
1065       range->layout->restrict_to_fill_level = restrict_to_fill_level;
1066       g_object_notify (G_OBJECT (range), "restrict-to-fill-level");
1067
1068       gtk_range_set_value (range, gtk_range_get_value (range));
1069     }
1070 }
1071
1072 /**
1073  * gtk_range_get_restrict_to_fill_level:
1074  * @range: A #GtkRange
1075  *
1076  * Gets whether the range is restricted to the fill level.
1077  *
1078  * Return value: %TRUE if @range is restricted to the fill level.
1079  *
1080  * Since: 2.12
1081  **/
1082 gboolean
1083 gtk_range_get_restrict_to_fill_level (GtkRange *range)
1084 {
1085   g_return_val_if_fail (GTK_IS_RANGE (range), FALSE);
1086
1087   return range->layout->restrict_to_fill_level;
1088 }
1089
1090 /**
1091  * gtk_range_set_fill_level:
1092  * @range: a #GtkRange
1093  * @fill_level: the new position of the fill level indicator
1094  *
1095  * Set the new position of the fill level indicator.
1096  *
1097  * The "fill level" is probably best described by its most prominent
1098  * use case, which is an indicator for the amount of pre-buffering in
1099  * a streaming media player. In that use case, the value of the range
1100  * would indicate the current play position, and the fill level would
1101  * be the position up to which the file/stream has been downloaded.
1102  *
1103  * This amount of prebuffering can be displayed on the range's trough
1104  * and is themeable separately from the trough. To enable fill level
1105  * display, use gtk_range_set_show_fill_level(). The range defaults
1106  * to not showing the fill level.
1107  *
1108  * Additionally, it's possible to restrict the range's slider position
1109  * to values which are smaller than the fill level. This is controller
1110  * by gtk_range_set_restrict_to_fill_level() and is by default
1111  * enabled.
1112  *
1113  * Since: 2.12
1114  **/
1115 void
1116 gtk_range_set_fill_level (GtkRange *range,
1117                           gdouble   fill_level)
1118 {
1119   g_return_if_fail (GTK_IS_RANGE (range));
1120
1121   if (fill_level != range->layout->fill_level)
1122     {
1123       range->layout->fill_level = fill_level;
1124       g_object_notify (G_OBJECT (range), "fill-level");
1125
1126       if (range->layout->show_fill_level)
1127         gtk_widget_queue_draw (GTK_WIDGET (range));
1128
1129       if (range->layout->restrict_to_fill_level)
1130         gtk_range_set_value (range, gtk_range_get_value (range));
1131     }
1132 }
1133
1134 /**
1135  * gtk_range_get_fill_level:
1136  * @range : A #GtkRange
1137  *
1138  * Gets the current position of the fill level indicator.
1139  *
1140  * Return value: The current fill level
1141  *
1142  * Since: 2.12
1143  **/
1144 gdouble
1145 gtk_range_get_fill_level (GtkRange *range)
1146 {
1147   g_return_val_if_fail (GTK_IS_RANGE (range), 0.0);
1148
1149   return range->layout->fill_level;
1150 }
1151
1152 static gboolean
1153 should_invert (GtkRange *range)
1154 {
1155   if (range->orientation == GTK_ORIENTATION_HORIZONTAL)
1156     return
1157       (range->inverted && !range->flippable) ||
1158       (range->inverted && range->flippable && gtk_widget_get_direction (GTK_WIDGET (range)) == GTK_TEXT_DIR_LTR) ||
1159       (!range->inverted && range->flippable && gtk_widget_get_direction (GTK_WIDGET (range)) == GTK_TEXT_DIR_RTL);
1160   else
1161     return range->inverted;
1162 }
1163
1164 static void
1165 gtk_range_destroy (GtkObject *object)
1166 {
1167   GtkRange *range = GTK_RANGE (object);
1168
1169   gtk_range_remove_step_timer (range);
1170   gtk_range_remove_update_timer (range);
1171
1172   if (range->layout->repaint_id)
1173     g_source_remove (range->layout->repaint_id);
1174   range->layout->repaint_id = 0;
1175
1176   if (range->adjustment)
1177     {
1178       g_signal_handlers_disconnect_by_func (range->adjustment,
1179                                             gtk_range_adjustment_changed,
1180                                             range);
1181       g_signal_handlers_disconnect_by_func (range->adjustment,
1182                                             gtk_range_adjustment_value_changed,
1183                                             range);
1184       g_object_unref (range->adjustment);
1185       range->adjustment = NULL;
1186     }
1187
1188   (* GTK_OBJECT_CLASS (gtk_range_parent_class)->destroy) (object);
1189 }
1190
1191 static void
1192 gtk_range_size_request (GtkWidget      *widget,
1193                         GtkRequisition *requisition)
1194 {
1195   GtkRange *range;
1196   gint slider_width, stepper_size, focus_width, trough_border, stepper_spacing;
1197   GdkRectangle range_rect;
1198   GtkBorder border;
1199
1200   range = GTK_RANGE (widget);
1201
1202   gtk_range_get_props (range,
1203                        &slider_width, &stepper_size,
1204                        &focus_width, &trough_border,
1205                        &stepper_spacing, NULL,
1206                        NULL, NULL);
1207
1208   gtk_range_calc_request (range,
1209                           slider_width, stepper_size,
1210                           focus_width, trough_border, stepper_spacing,
1211                           &range_rect, &border, NULL, NULL, NULL, NULL);
1212
1213   requisition->width = range_rect.width + border.left + border.right;
1214   requisition->height = range_rect.height + border.top + border.bottom;
1215 }
1216
1217 static void
1218 gtk_range_size_allocate (GtkWidget     *widget,
1219                          GtkAllocation *allocation)
1220 {
1221   GtkRange *range;
1222
1223   range = GTK_RANGE (widget);
1224
1225   widget->allocation = *allocation;
1226
1227   range->need_recalc = TRUE;
1228   gtk_range_calc_layout (range, range->adjustment->value);
1229
1230   if (GTK_WIDGET_REALIZED (range))
1231     gdk_window_move_resize (range->event_window,
1232                             widget->allocation.x,
1233                             widget->allocation.y,
1234                             widget->allocation.width,
1235                             widget->allocation.height);
1236 }
1237
1238 static void
1239 gtk_range_realize (GtkWidget *widget)
1240 {
1241   GtkRange *range;
1242   GdkWindowAttr attributes;
1243   gint attributes_mask;
1244
1245   range = GTK_RANGE (widget);
1246
1247   gtk_range_calc_layout (range, range->adjustment->value);
1248
1249   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
1250
1251   widget->window = gtk_widget_get_parent_window (widget);
1252   g_object_ref (widget->window);
1253
1254   attributes.window_type = GDK_WINDOW_CHILD;
1255   attributes.x = widget->allocation.x;
1256   attributes.y = widget->allocation.y;
1257   attributes.width = widget->allocation.width;
1258   attributes.height = widget->allocation.height;
1259   attributes.wclass = GDK_INPUT_ONLY;
1260   attributes.event_mask = gtk_widget_get_events (widget);
1261   attributes.event_mask |= (GDK_BUTTON_PRESS_MASK |
1262                             GDK_BUTTON_RELEASE_MASK |
1263                             GDK_ENTER_NOTIFY_MASK |
1264                             GDK_LEAVE_NOTIFY_MASK |
1265                             GDK_POINTER_MOTION_MASK |
1266                             GDK_POINTER_MOTION_HINT_MASK);
1267
1268   attributes_mask = GDK_WA_X | GDK_WA_Y;
1269
1270   range->event_window = gdk_window_new (gtk_widget_get_parent_window (widget),
1271                                         &attributes, attributes_mask);
1272   gdk_window_set_user_data (range->event_window, range);
1273
1274   widget->style = gtk_style_attach (widget->style, widget->window);
1275 }
1276
1277 static void
1278 gtk_range_unrealize (GtkWidget *widget)
1279 {
1280   GtkRange *range = GTK_RANGE (widget);
1281
1282   gtk_range_remove_step_timer (range);
1283   gtk_range_remove_update_timer (range);
1284
1285   gdk_window_set_user_data (range->event_window, NULL);
1286   gdk_window_destroy (range->event_window);
1287   range->event_window = NULL;
1288
1289   if (GTK_WIDGET_CLASS (gtk_range_parent_class)->unrealize)
1290     (* GTK_WIDGET_CLASS (gtk_range_parent_class)->unrealize) (widget);
1291 }
1292
1293 static void
1294 gtk_range_map (GtkWidget *widget)
1295 {
1296   GtkRange *range = GTK_RANGE (widget);
1297
1298   gdk_window_show (range->event_window);
1299
1300   GTK_WIDGET_CLASS (gtk_range_parent_class)->map (widget);
1301 }
1302
1303 static void
1304 gtk_range_unmap (GtkWidget *widget)
1305 {
1306   GtkRange *range = GTK_RANGE (widget);
1307
1308   stop_scrolling (range);
1309
1310   gdk_window_hide (range->event_window);
1311
1312   GTK_WIDGET_CLASS (gtk_range_parent_class)->unmap (widget);
1313 }
1314
1315 static void
1316 draw_stepper (GtkRange     *range,
1317               GdkRectangle *rect,
1318               GtkArrowType  arrow_type,
1319               gboolean      clicked,
1320               gboolean      prelighted,
1321               GdkRectangle *area)
1322 {
1323   GtkStateType state_type;
1324   GtkShadowType shadow_type;
1325   GdkRectangle intersection;
1326   GtkWidget *widget = GTK_WIDGET (range);
1327
1328   gint arrow_x;
1329   gint arrow_y;
1330   gint arrow_width;
1331   gint arrow_height;
1332
1333   gboolean arrow_sensitive = TRUE;
1334
1335   /* More to get the right clip region than for efficiency */
1336   if (!gdk_rectangle_intersect (area, rect, &intersection))
1337     return;
1338
1339   intersection.x += widget->allocation.x;
1340   intersection.y += widget->allocation.y;
1341
1342   if ((!range->inverted && (arrow_type == GTK_ARROW_DOWN ||
1343                             arrow_type == GTK_ARROW_RIGHT)) ||
1344       (range->inverted  && (arrow_type == GTK_ARROW_UP ||
1345                             arrow_type == GTK_ARROW_LEFT)))
1346     {
1347       arrow_sensitive = range->layout->upper_sensitive;
1348     }
1349   else
1350     {
1351       arrow_sensitive = range->layout->lower_sensitive;
1352     }
1353
1354   if (!GTK_WIDGET_IS_SENSITIVE (range) || !arrow_sensitive)
1355     state_type = GTK_STATE_INSENSITIVE;
1356   else if (clicked)
1357     state_type = GTK_STATE_ACTIVE;
1358   else if (prelighted)
1359     state_type = GTK_STATE_PRELIGHT;
1360   else
1361     state_type = GTK_STATE_NORMAL;
1362
1363   if (clicked && arrow_sensitive)
1364     shadow_type = GTK_SHADOW_IN;
1365   else
1366     shadow_type = GTK_SHADOW_OUT;
1367
1368   gtk_paint_box (widget->style,
1369                  widget->window,
1370                  state_type, shadow_type,
1371                  &intersection, widget,
1372                  GTK_RANGE_GET_CLASS (range)->stepper_detail,
1373                  widget->allocation.x + rect->x,
1374                  widget->allocation.y + rect->y,
1375                  rect->width,
1376                  rect->height);
1377
1378   arrow_width = rect->width / 2;
1379   arrow_height = rect->height / 2;
1380   arrow_x = widget->allocation.x + rect->x + (rect->width - arrow_width) / 2;
1381   arrow_y = widget->allocation.y + rect->y + (rect->height - arrow_height) / 2;
1382
1383   if (clicked && arrow_sensitive)
1384     {
1385       gint arrow_displacement_x;
1386       gint arrow_displacement_y;
1387
1388       gtk_range_get_props (GTK_RANGE (widget),
1389                            NULL, NULL, NULL, NULL, NULL, NULL,
1390                            &arrow_displacement_x, &arrow_displacement_y);
1391
1392       arrow_x += arrow_displacement_x;
1393       arrow_y += arrow_displacement_y;
1394     }
1395
1396   gtk_paint_arrow (widget->style,
1397                    widget->window,
1398                    state_type, shadow_type,
1399                    &intersection, widget,
1400                    GTK_RANGE_GET_CLASS (range)->stepper_detail,
1401                    arrow_type,
1402                    TRUE,
1403                    arrow_x, arrow_y, arrow_width, arrow_height);
1404 }
1405
1406 static gboolean
1407 gtk_range_expose (GtkWidget      *widget,
1408                   GdkEventExpose *event)
1409 {
1410   GtkRange *range = GTK_RANGE (widget);
1411   gboolean sensitive;
1412   GtkStateType state;
1413   GtkShadowType shadow_type;
1414   GdkRectangle expose_area;     /* Relative to widget->allocation */
1415   GdkRectangle area;
1416   gint focus_line_width = 0;
1417   gint focus_padding = 0;
1418   gboolean touchscreen;
1419
1420   g_object_get (gtk_widget_get_settings (widget),
1421                 "gtk-touchscreen-mode", &touchscreen,
1422                 NULL);
1423   if (GTK_WIDGET_CAN_FOCUS (range))
1424     gtk_widget_style_get (GTK_WIDGET (range),
1425                           "focus-line-width", &focus_line_width,
1426                           "focus-padding", &focus_padding,
1427                           NULL);
1428
1429   /* we're now exposing, so there's no need to force early repaints */
1430   if (range->layout->repaint_id)
1431     g_source_remove (range->layout->repaint_id);
1432   range->layout->repaint_id = 0;
1433
1434   expose_area = event->area;
1435   expose_area.x -= widget->allocation.x;
1436   expose_area.y -= widget->allocation.y;
1437
1438   gtk_range_calc_layout (range, range->adjustment->value);
1439
1440   sensitive = GTK_WIDGET_IS_SENSITIVE (widget);
1441
1442   /* Just to be confusing, we draw the trough for the whole
1443    * range rectangle, not the trough rectangle (the trough
1444    * rectangle is just for hit detection)
1445    */
1446   /* The gdk_rectangle_intersect is more to get the right
1447    * clip region (limited to range_rect) than for efficiency
1448    */
1449   if (gdk_rectangle_intersect (&expose_area, &range->range_rect,
1450                                &area))
1451     {
1452       gint     x      = (widget->allocation.x + range->range_rect.x +
1453                          focus_line_width + focus_padding);
1454       gint     y      = (widget->allocation.y + range->range_rect.y +
1455                          focus_line_width + focus_padding);
1456       gint     width  = (range->range_rect.width -
1457                          2 * (focus_line_width + focus_padding));
1458       gint     height = (range->range_rect.height -
1459                          2 * (focus_line_width + focus_padding));
1460       gboolean trough_side_details;
1461       gboolean trough_under_steppers;
1462       gint     stepper_size;
1463       gint     stepper_spacing;
1464
1465       area.x += widget->allocation.x;
1466       area.y += widget->allocation.y;
1467
1468       gtk_widget_style_get (GTK_WIDGET (range),
1469                             "trough-side-details",   &trough_side_details,
1470                             "trough-under-steppers", &trough_under_steppers,
1471                             "stepper-size",          &stepper_size,
1472                             "stepper-spacing",       &stepper_spacing,
1473                             NULL);
1474
1475       if (stepper_spacing > 0)
1476         trough_under_steppers = FALSE;
1477
1478       if (! trough_under_steppers)
1479         {
1480           gint offset  = 0;
1481           gint shorter = 0;
1482
1483           if (range->has_stepper_a)
1484             offset += stepper_size;
1485
1486           if (range->has_stepper_b)
1487             offset += stepper_size;
1488
1489           shorter += offset;
1490
1491           if (range->has_stepper_c)
1492             shorter += stepper_size;
1493
1494           if (range->has_stepper_d)
1495             shorter += stepper_size;
1496
1497           if (range->has_stepper_a || range->has_stepper_b)
1498             {
1499               offset  += stepper_spacing;
1500               shorter += stepper_spacing;
1501             }
1502
1503           if (range->has_stepper_c || range->has_stepper_d)
1504             {
1505               shorter += stepper_spacing;
1506             }
1507
1508           if (range->orientation == GTK_ORIENTATION_HORIZONTAL)
1509             {
1510               x     += offset;
1511               width -= shorter;
1512             }
1513           else
1514             {
1515               y      += offset;
1516               height -= shorter;
1517             }
1518         }
1519
1520       if (! trough_side_details)
1521         {
1522           gtk_paint_box (widget->style,
1523                          widget->window,
1524                          sensitive ? GTK_STATE_ACTIVE : GTK_STATE_INSENSITIVE,
1525                          GTK_SHADOW_IN,
1526                          &area, GTK_WIDGET(range), "trough",
1527                          x, y,
1528                          width, height);
1529         }
1530       else
1531         {
1532           gint trough_change_pos_x = width;
1533           gint trough_change_pos_y = height;
1534
1535           if (range->orientation == GTK_ORIENTATION_HORIZONTAL)
1536             trough_change_pos_x = (range->layout->slider.x +
1537                                    range->layout->slider.width / 2 -
1538                                    (x - widget->allocation.x));
1539           else
1540             trough_change_pos_y = (range->layout->slider.y +
1541                                    range->layout->slider.height / 2 -
1542                                    (y - widget->allocation.y));
1543
1544           gtk_paint_box (widget->style,
1545                          widget->window,
1546                          sensitive ? GTK_STATE_ACTIVE : GTK_STATE_INSENSITIVE,
1547                          GTK_SHADOW_IN,
1548                          &area, GTK_WIDGET (range),
1549                          should_invert (range) ? "trough-upper" : "trough-lower",
1550                          x, y,
1551                          trough_change_pos_x, trough_change_pos_y);
1552
1553           if (range->orientation == GTK_ORIENTATION_HORIZONTAL)
1554             trough_change_pos_y = 0;
1555           else
1556             trough_change_pos_x = 0;
1557
1558           gtk_paint_box (widget->style,
1559                          widget->window,
1560                          sensitive ? GTK_STATE_ACTIVE : GTK_STATE_INSENSITIVE,
1561                          GTK_SHADOW_IN,
1562                          &area, GTK_WIDGET (range),
1563                          should_invert (range) ? "trough-lower" : "trough-upper",
1564                          x + trough_change_pos_x, y + trough_change_pos_y,
1565                          width - trough_change_pos_x,
1566                          height - trough_change_pos_y);
1567         }
1568
1569       if (range->layout->show_fill_level &&
1570           range->adjustment->upper - range->adjustment->page_size -
1571           range->adjustment->lower != 0)
1572         {
1573           gdouble  fill_level  = range->layout->fill_level;
1574           gint     fill_x      = x;
1575           gint     fill_y      = y;
1576           gint     fill_width  = width;
1577           gint     fill_height = height;
1578           gchar   *fill_detail;
1579
1580           fill_level = CLAMP (fill_level, range->adjustment->lower,
1581                               range->adjustment->upper -
1582                               range->adjustment->page_size);
1583
1584           if (range->orientation == GTK_ORIENTATION_HORIZONTAL)
1585             {
1586               fill_x     = widget->allocation.x + range->layout->trough.x;
1587               fill_width = (range->layout->slider.width +
1588                             (fill_level - range->adjustment->lower) /
1589                             (range->adjustment->upper -
1590                              range->adjustment->lower -
1591                              range->adjustment->page_size) *
1592                             (range->layout->trough.width -
1593                              range->layout->slider.width));
1594
1595               if (should_invert (range))
1596                 fill_x += range->layout->trough.width - fill_width;
1597             }
1598           else
1599             {
1600               fill_y      = widget->allocation.y + range->layout->trough.y;
1601               fill_height = (range->layout->slider.height +
1602                              (fill_level - range->adjustment->lower) /
1603                              (range->adjustment->upper -
1604                               range->adjustment->lower -
1605                               range->adjustment->page_size) *
1606                              (range->layout->trough.height -
1607                               range->layout->slider.height));
1608
1609               if (should_invert (range))
1610                 fill_y += range->layout->trough.height - fill_height;
1611             }
1612
1613           if (fill_level < range->adjustment->upper - range->adjustment->page_size)
1614             fill_detail = "trough-fill-level-full";
1615           else
1616             fill_detail = "trough-fill-level";
1617
1618           gtk_paint_box (widget->style,
1619                          widget->window,
1620                          sensitive ? GTK_STATE_ACTIVE : GTK_STATE_INSENSITIVE,
1621                          GTK_SHADOW_OUT,
1622                          &area, GTK_WIDGET (range), fill_detail,
1623                          fill_x, fill_y,
1624                          fill_width, fill_height);
1625         }
1626
1627       if (sensitive &&
1628           GTK_WIDGET_HAS_FOCUS (range))
1629         gtk_paint_focus (widget->style, widget->window, GTK_WIDGET_STATE (widget),
1630                          &area, widget, "trough",
1631                          widget->allocation.x + range->range_rect.x,
1632                          widget->allocation.y + range->range_rect.y,
1633                          range->range_rect.width,
1634                          range->range_rect.height);
1635     }
1636
1637   shadow_type = GTK_SHADOW_OUT;
1638
1639   if (!sensitive)
1640     state = GTK_STATE_INSENSITIVE;
1641   else if (!touchscreen && range->layout->mouse_location == MOUSE_SLIDER)
1642     state = GTK_STATE_PRELIGHT;
1643   else
1644     state = GTK_STATE_NORMAL;
1645
1646   if (range->layout->grab_location == MOUSE_SLIDER)
1647     {
1648       gboolean activate_slider;
1649
1650       gtk_widget_style_get (widget, "activate-slider", &activate_slider, NULL);
1651
1652       if (activate_slider)
1653         {
1654           state = GTK_STATE_ACTIVE;
1655           shadow_type = GTK_SHADOW_IN;
1656         }
1657     }
1658
1659   if (gdk_rectangle_intersect (&expose_area,
1660                                &range->layout->slider,
1661                                &area))
1662     {
1663       area.x += widget->allocation.x;
1664       area.y += widget->allocation.y;
1665
1666       gtk_paint_slider (widget->style,
1667                         widget->window,
1668                         state,
1669                         shadow_type,
1670                         &area,
1671                         widget,
1672                         GTK_RANGE_GET_CLASS (range)->slider_detail,
1673                         widget->allocation.x + range->layout->slider.x,
1674                         widget->allocation.y + range->layout->slider.y,
1675                         range->layout->slider.width,
1676                         range->layout->slider.height,
1677                         range->orientation);
1678     }
1679
1680   if (range->has_stepper_a)
1681     draw_stepper (range, &range->layout->stepper_a,
1682                   range->orientation == GTK_ORIENTATION_VERTICAL ? GTK_ARROW_UP : GTK_ARROW_LEFT,
1683                   range->layout->grab_location == MOUSE_STEPPER_A,
1684                   !touchscreen && range->layout->mouse_location == MOUSE_STEPPER_A,
1685                   &expose_area);
1686
1687   if (range->has_stepper_b)
1688     draw_stepper (range, &range->layout->stepper_b,
1689                   range->orientation == GTK_ORIENTATION_VERTICAL ? GTK_ARROW_DOWN : GTK_ARROW_RIGHT,
1690                   range->layout->grab_location == MOUSE_STEPPER_B,
1691                   !touchscreen && range->layout->mouse_location == MOUSE_STEPPER_B,
1692                   &expose_area);
1693
1694   if (range->has_stepper_c)
1695     draw_stepper (range, &range->layout->stepper_c,
1696                   range->orientation == GTK_ORIENTATION_VERTICAL ? GTK_ARROW_UP : GTK_ARROW_LEFT,
1697                   range->layout->grab_location == MOUSE_STEPPER_C,
1698                   !touchscreen && range->layout->mouse_location == MOUSE_STEPPER_C,
1699                   &expose_area);
1700
1701   if (range->has_stepper_d)
1702     draw_stepper (range, &range->layout->stepper_d,
1703                   range->orientation == GTK_ORIENTATION_VERTICAL ? GTK_ARROW_DOWN : GTK_ARROW_RIGHT,
1704                   range->layout->grab_location == MOUSE_STEPPER_D,
1705                   !touchscreen && range->layout->mouse_location == MOUSE_STEPPER_D,
1706                   &expose_area);
1707
1708   return FALSE;
1709 }
1710
1711 static void
1712 range_grab_add (GtkRange      *range,
1713                 MouseLocation  location,
1714                 gint           button)
1715 {
1716   /* we don't actually gtk_grab, since a button is down */
1717
1718   gtk_grab_add (GTK_WIDGET (range));
1719
1720   range->layout->grab_location = location;
1721   range->layout->grab_button = button;
1722
1723   if (gtk_range_update_mouse_location (range))
1724     gtk_widget_queue_draw (GTK_WIDGET (range));
1725 }
1726
1727 static void
1728 range_grab_remove (GtkRange *range)
1729 {
1730   MouseLocation location;
1731
1732   gtk_grab_remove (GTK_WIDGET (range));
1733
1734   location = range->layout->grab_location;
1735   range->layout->grab_location = MOUSE_OUTSIDE;
1736   range->layout->grab_button = 0;
1737
1738   if (gtk_range_update_mouse_location (range) ||
1739       location != MOUSE_OUTSIDE)
1740     gtk_widget_queue_draw (GTK_WIDGET (range));
1741 }
1742
1743 static GtkScrollType
1744 range_get_scroll_for_grab (GtkRange      *range)
1745 {
1746   gboolean invert;
1747
1748   invert = should_invert (range);
1749   switch (range->layout->grab_location)
1750     {
1751       /* Backward stepper */
1752     case MOUSE_STEPPER_A:
1753     case MOUSE_STEPPER_C:
1754       switch (range->layout->grab_button)
1755         {
1756         case 1:
1757           return invert ? GTK_SCROLL_STEP_FORWARD : GTK_SCROLL_STEP_BACKWARD;
1758           break;
1759         case 2:
1760           return invert ? GTK_SCROLL_PAGE_FORWARD : GTK_SCROLL_PAGE_BACKWARD;
1761           break;
1762         case 3:
1763           return invert ? GTK_SCROLL_END : GTK_SCROLL_START;
1764           break;
1765         }
1766       break;
1767
1768       /* Forward stepper */
1769     case MOUSE_STEPPER_B:
1770     case MOUSE_STEPPER_D:
1771       switch (range->layout->grab_button)
1772         {
1773         case 1:
1774           return invert ? GTK_SCROLL_STEP_BACKWARD : GTK_SCROLL_STEP_FORWARD;
1775           break;
1776         case 2:
1777           return invert ? GTK_SCROLL_PAGE_BACKWARD : GTK_SCROLL_PAGE_FORWARD;
1778           break;
1779         case 3:
1780           return invert ? GTK_SCROLL_START : GTK_SCROLL_END;
1781           break;
1782        }
1783       break;
1784
1785       /* In the trough */
1786     case MOUSE_TROUGH:
1787       {
1788         if (range->trough_click_forward)
1789           return GTK_SCROLL_PAGE_FORWARD;
1790         else
1791           return GTK_SCROLL_PAGE_BACKWARD;
1792       }
1793       break;
1794
1795     case MOUSE_OUTSIDE:
1796     case MOUSE_SLIDER:
1797     case MOUSE_WIDGET:
1798       break;
1799     }
1800
1801   return GTK_SCROLL_NONE;
1802 }
1803
1804 static gdouble
1805 coord_to_value (GtkRange *range,
1806                 gint      coord)
1807 {
1808   gdouble frac;
1809   gdouble value;
1810   gint    trough_length;
1811   gint    trough_start;
1812   gint    slider_length;
1813   gint    trough_border;
1814   gint    trough_under_steppers;
1815
1816   if (range->orientation == GTK_ORIENTATION_VERTICAL)
1817     {
1818       trough_length = range->layout->trough.height;
1819       trough_start  = range->layout->trough.y;
1820       slider_length = range->layout->slider.height;
1821     }
1822   else
1823     {
1824       trough_length = range->layout->trough.width;
1825       trough_start  = range->layout->trough.x;
1826       slider_length = range->layout->slider.width;
1827     }
1828
1829   gtk_range_get_props (range, NULL, NULL, NULL, &trough_border, NULL,
1830                        &trough_under_steppers, NULL, NULL);
1831
1832   if (! trough_under_steppers)
1833     {
1834       trough_start += trough_border;
1835       trough_length -= 2 * trough_border;
1836     }
1837
1838   if (trough_length == slider_length)
1839     frac = 1.0;
1840   else
1841     frac = (MAX (0, coord - trough_start) /
1842             (gdouble) (trough_length - slider_length));
1843
1844   if (should_invert (range))
1845     frac = 1.0 - frac;
1846
1847   value = range->adjustment->lower + frac * (range->adjustment->upper -
1848                                              range->adjustment->lower -
1849                                              range->adjustment->page_size);
1850
1851   return value;
1852 }
1853
1854 static gboolean
1855 gtk_range_key_press (GtkWidget   *widget,
1856                      GdkEventKey *event)
1857 {
1858   GtkRange *range = GTK_RANGE (widget);
1859
1860   if (event->keyval == GDK_Escape &&
1861       range->layout->grab_location != MOUSE_OUTSIDE)
1862     {
1863       stop_scrolling (range);
1864
1865       update_slider_position (range,
1866                               range->slide_initial_coordinate,
1867                               range->slide_initial_coordinate);
1868
1869       return TRUE;
1870     }
1871
1872   return GTK_WIDGET_CLASS (gtk_range_parent_class)->key_press_event (widget, event);
1873 }
1874
1875 static gint
1876 gtk_range_button_press (GtkWidget      *widget,
1877                         GdkEventButton *event)
1878 {
1879   GtkRange *range = GTK_RANGE (widget);
1880
1881   if (!GTK_WIDGET_HAS_FOCUS (widget))
1882     gtk_widget_grab_focus (widget);
1883
1884   /* ignore presses when we're already doing something else. */
1885   if (range->layout->grab_location != MOUSE_OUTSIDE)
1886     return FALSE;
1887
1888   range->layout->mouse_x = event->x;
1889   range->layout->mouse_y = event->y;
1890   if (gtk_range_update_mouse_location (range))
1891     gtk_widget_queue_draw (widget);
1892
1893   if (range->layout->mouse_location == MOUSE_TROUGH  &&
1894       event->button == 1)
1895     {
1896       /* button 1 steps by page increment, as with button 2 on a stepper
1897        */
1898       GtkScrollType scroll;
1899       gdouble click_value;
1900
1901       click_value = coord_to_value (range,
1902                                     range->orientation == GTK_ORIENTATION_VERTICAL ?
1903                                     event->y : event->x);
1904
1905       range->trough_click_forward = click_value > range->adjustment->value;
1906       range_grab_add (range, MOUSE_TROUGH, event->button);
1907
1908       scroll = range_get_scroll_for_grab (range);
1909
1910       gtk_range_add_step_timer (range, scroll);
1911
1912       return TRUE;
1913     }
1914   else if ((range->layout->mouse_location == MOUSE_STEPPER_A ||
1915             range->layout->mouse_location == MOUSE_STEPPER_B ||
1916             range->layout->mouse_location == MOUSE_STEPPER_C ||
1917             range->layout->mouse_location == MOUSE_STEPPER_D) &&
1918            (event->button == 1 || event->button == 2 || event->button == 3))
1919     {
1920       GdkRectangle *stepper_area;
1921       GtkScrollType scroll;
1922
1923       range_grab_add (range, range->layout->mouse_location, event->button);
1924
1925       stepper_area = get_area (range, range->layout->mouse_location);
1926       gtk_widget_queue_draw_area (widget,
1927                                   widget->allocation.x + stepper_area->x,
1928                                   widget->allocation.y + stepper_area->y,
1929                                   stepper_area->width,
1930                                   stepper_area->height);
1931
1932       scroll = range_get_scroll_for_grab (range);
1933       if (scroll != GTK_SCROLL_NONE)
1934         gtk_range_add_step_timer (range, scroll);
1935
1936       return TRUE;
1937     }
1938   else if ((range->layout->mouse_location == MOUSE_TROUGH &&
1939             event->button == 2) ||
1940            range->layout->mouse_location == MOUSE_SLIDER)
1941     {
1942       gboolean need_value_update = FALSE;
1943       gboolean activate_slider;
1944
1945       /* Any button can be used to drag the slider, but you can start
1946        * dragging the slider with a trough click using button 2;
1947        * On button 2 press, we warp the slider to mouse position,
1948        * then begin the slider drag.
1949        */
1950       if (event->button == 2)
1951         {
1952           gdouble slider_low_value, slider_high_value, new_value;
1953
1954           slider_high_value =
1955             coord_to_value (range,
1956                             range->orientation == GTK_ORIENTATION_VERTICAL ?
1957                             event->y : event->x);
1958           slider_low_value =
1959             coord_to_value (range,
1960                             range->orientation == GTK_ORIENTATION_VERTICAL ?
1961                             event->y - range->layout->slider.height :
1962                             event->x - range->layout->slider.width);
1963
1964           /* compute new value for warped slider */
1965           new_value = slider_low_value + (slider_high_value - slider_low_value) / 2;
1966
1967           /* recalc slider, so we can set slide_initial_slider_position
1968            * properly
1969            */
1970           range->need_recalc = TRUE;
1971           gtk_range_calc_layout (range, new_value);
1972
1973           /* defer adjustment updates to update_slider_position() in order
1974            * to keep pixel quantisation
1975            */
1976           need_value_update = TRUE;
1977         }
1978
1979       if (range->orientation == GTK_ORIENTATION_VERTICAL)
1980         {
1981           range->slide_initial_slider_position = range->layout->slider.y;
1982           range->slide_initial_coordinate = event->y;
1983         }
1984       else
1985         {
1986           range->slide_initial_slider_position = range->layout->slider.x;
1987           range->slide_initial_coordinate = event->x;
1988         }
1989
1990       range_grab_add (range, MOUSE_SLIDER, event->button);
1991
1992       gtk_widget_style_get (widget, "activate-slider", &activate_slider, NULL);
1993
1994       /* force a redraw, if the active slider is drawn differently to the
1995        * prelight one
1996        */
1997       if (activate_slider)
1998         gtk_widget_queue_draw (widget);
1999
2000       if (need_value_update)
2001         update_slider_position (range, event->x, event->y);
2002
2003       return TRUE;
2004     }
2005
2006   return FALSE;
2007 }
2008
2009 /* During a slide, move the slider as required given new mouse position */
2010 static void
2011 update_slider_position (GtkRange *range,
2012                         gint      mouse_x,
2013                         gint      mouse_y)
2014 {
2015   gint delta;
2016   gint c;
2017   gdouble new_value;
2018   gboolean handled;
2019
2020   if (range->orientation == GTK_ORIENTATION_VERTICAL)
2021     delta = mouse_y - range->slide_initial_coordinate;
2022   else
2023     delta = mouse_x - range->slide_initial_coordinate;
2024
2025   c = range->slide_initial_slider_position + delta;
2026
2027   new_value = coord_to_value (range, c);
2028
2029   g_signal_emit (range, signals[CHANGE_VALUE], 0, GTK_SCROLL_JUMP, new_value,
2030                  &handled);
2031 }
2032
2033 static void
2034 stop_scrolling (GtkRange *range)
2035 {
2036   range_grab_remove (range);
2037   gtk_range_remove_step_timer (range);
2038   /* Flush any pending discontinuous/delayed updates */
2039   gtk_range_update_value (range);
2040 }
2041
2042 static gboolean
2043 gtk_range_grab_broken (GtkWidget          *widget,
2044                        GdkEventGrabBroken *event)
2045 {
2046   GtkRange *range = GTK_RANGE (widget);
2047
2048   if (range->layout->grab_location != MOUSE_OUTSIDE)
2049     {
2050       if (range->layout->grab_location == MOUSE_SLIDER)
2051         update_slider_position (range, range->layout->mouse_x, range->layout->mouse_y);
2052
2053       stop_scrolling (range);
2054
2055       return TRUE;
2056     }
2057
2058   return FALSE;
2059 }
2060
2061 static gint
2062 gtk_range_button_release (GtkWidget      *widget,
2063                           GdkEventButton *event)
2064 {
2065   GtkRange *range = GTK_RANGE (widget);
2066
2067   if (event->window == range->event_window)
2068     {
2069       range->layout->mouse_x = event->x;
2070       range->layout->mouse_y = event->y;
2071     }
2072   else
2073     {
2074       gdk_window_get_pointer (range->event_window,
2075                               &range->layout->mouse_x,
2076                               &range->layout->mouse_y,
2077                               NULL);
2078     }
2079
2080   if (range->layout->grab_button == event->button)
2081     {
2082       if (range->layout->grab_location == MOUSE_SLIDER)
2083         update_slider_position (range, range->layout->mouse_x, range->layout->mouse_y);
2084
2085       stop_scrolling (range);
2086
2087       return TRUE;
2088     }
2089
2090   return FALSE;
2091 }
2092
2093 /**
2094  * _gtk_range_get_wheel_delta:
2095  * @range: a #GtkRange
2096  * @direction: A #GdkScrollDirection
2097  *
2098  * Returns a good step value for the mouse wheel.
2099  *
2100  * Return value: A good step value for the mouse wheel.
2101  *
2102  * Since: 2.4
2103  **/
2104 gdouble
2105 _gtk_range_get_wheel_delta (GtkRange           *range,
2106                             GdkScrollDirection  direction)
2107 {
2108   GtkAdjustment *adj = range->adjustment;
2109   gdouble delta;
2110
2111   if (GTK_IS_SCROLLBAR (range))
2112     delta = pow (adj->page_size, 2.0 / 3.0);
2113   else
2114     delta = adj->step_increment * 2;
2115
2116   if (direction == GDK_SCROLL_UP ||
2117       direction == GDK_SCROLL_LEFT)
2118     delta = - delta;
2119
2120   if (range->inverted)
2121     delta = - delta;
2122
2123   return delta;
2124 }
2125
2126 static gboolean
2127 gtk_range_scroll_event (GtkWidget      *widget,
2128                         GdkEventScroll *event)
2129 {
2130   GtkRange *range = GTK_RANGE (widget);
2131
2132   if (GTK_WIDGET_REALIZED (range))
2133     {
2134       GtkAdjustment *adj = GTK_RANGE (range)->adjustment;
2135       gdouble delta;
2136       gboolean handled;
2137
2138       delta = _gtk_range_get_wheel_delta (range, event->direction);
2139
2140       g_signal_emit (range, signals[CHANGE_VALUE], 0,
2141                      GTK_SCROLL_JUMP, adj->value + delta,
2142                      &handled);
2143
2144       /* Policy DELAYED makes sense with scroll events,
2145        * but DISCONTINUOUS doesn't, so we update immediately
2146        * for DISCONTINUOUS
2147        */
2148       if (range->update_policy == GTK_UPDATE_DISCONTINUOUS)
2149         gtk_range_update_value (range);
2150     }
2151
2152   return TRUE;
2153 }
2154
2155 static gboolean
2156 gtk_range_motion_notify (GtkWidget      *widget,
2157                          GdkEventMotion *event)
2158 {
2159   GtkRange *range;
2160   gint x, y;
2161
2162   range = GTK_RANGE (widget);
2163
2164   gdk_window_get_pointer (range->event_window, &x, &y, NULL);
2165
2166   range->layout->mouse_x = x;
2167   range->layout->mouse_y = y;
2168
2169   if (gtk_range_update_mouse_location (range))
2170     gtk_widget_queue_draw (widget);
2171
2172   if (range->layout->grab_location == MOUSE_SLIDER)
2173     update_slider_position (range, x, y);
2174
2175   /* We handled the event if the mouse was in the range_rect */
2176   return range->layout->mouse_location != MOUSE_OUTSIDE;
2177 }
2178
2179 static gboolean
2180 gtk_range_enter_notify (GtkWidget        *widget,
2181                         GdkEventCrossing *event)
2182 {
2183   GtkRange *range = GTK_RANGE (widget);
2184
2185   range->layout->mouse_x = event->x;
2186   range->layout->mouse_y = event->y;
2187
2188   if (gtk_range_update_mouse_location (range))
2189     gtk_widget_queue_draw (widget);
2190
2191   return TRUE;
2192 }
2193
2194 static gboolean
2195 gtk_range_leave_notify (GtkWidget        *widget,
2196                         GdkEventCrossing *event)
2197 {
2198   GtkRange *range = GTK_RANGE (widget);
2199
2200   range->layout->mouse_x = -1;
2201   range->layout->mouse_y = -1;
2202
2203   if (gtk_range_update_mouse_location (range))
2204     gtk_widget_queue_draw (widget);
2205
2206   return TRUE;
2207 }
2208
2209 static void
2210 gtk_range_grab_notify (GtkWidget *widget,
2211                        gboolean   was_grabbed)
2212 {
2213   if (!was_grabbed)
2214     stop_scrolling (GTK_RANGE (widget));
2215 }
2216
2217 static void
2218 gtk_range_state_changed (GtkWidget    *widget,
2219                          GtkStateType  previous_state)
2220 {
2221   if (!GTK_WIDGET_IS_SENSITIVE (widget))
2222     stop_scrolling (GTK_RANGE (widget));
2223 }
2224
2225 #define check_rectangle(rectangle1, rectangle2)              \
2226   {                                                          \
2227     if (rectangle1.x != rectangle2.x) return TRUE;           \
2228     if (rectangle1.y != rectangle2.y) return TRUE;           \
2229     if (rectangle1.width  != rectangle2.width)  return TRUE; \
2230     if (rectangle1.height != rectangle2.height) return TRUE; \
2231   }
2232
2233 static gboolean
2234 layout_changed (GtkRangeLayout *layout1,
2235                 GtkRangeLayout *layout2)
2236 {
2237   check_rectangle (layout1->slider, layout2->slider);
2238   check_rectangle (layout1->trough, layout2->trough);
2239   check_rectangle (layout1->stepper_a, layout2->stepper_a);
2240   check_rectangle (layout1->stepper_d, layout2->stepper_d);
2241   check_rectangle (layout1->stepper_b, layout2->stepper_b);
2242   check_rectangle (layout1->stepper_c, layout2->stepper_c);
2243
2244   if (layout1->upper_sensitive != layout2->upper_sensitive) return TRUE;
2245   if (layout1->lower_sensitive != layout2->lower_sensitive) return TRUE;
2246
2247   return FALSE;
2248 }
2249
2250 static void
2251 gtk_range_adjustment_changed (GtkAdjustment *adjustment,
2252                               gpointer       data)
2253 {
2254   GtkRange *range = GTK_RANGE (data);
2255   /* create a copy of the layout */
2256   GtkRangeLayout layout = *range->layout;
2257
2258   range->need_recalc = TRUE;
2259   gtk_range_calc_layout (range, range->adjustment->value);
2260
2261   /* now check whether the layout changed  */
2262   if (layout_changed (range->layout, &layout))
2263     gtk_widget_queue_draw (GTK_WIDGET (range));
2264
2265   /* Note that we don't round off to range->round_digits here.
2266    * that's because it's really broken to change a value
2267    * in response to a change signal on that value; round_digits
2268    * is therefore defined to be a filter on what the GtkRange
2269    * can input into the adjustment, not a filter that the GtkRange
2270    * will enforce on the adjustment.
2271    */
2272 }
2273
2274 static gboolean
2275 force_repaint (gpointer data)
2276 {
2277   GtkRange *range = GTK_RANGE (data);
2278   range->layout->repaint_id = 0;
2279   if (GTK_WIDGET_DRAWABLE (range))
2280     gdk_window_process_updates (GTK_WIDGET (range)->window, FALSE);
2281   return FALSE;
2282 }
2283
2284 static void
2285 gtk_range_adjustment_value_changed (GtkAdjustment *adjustment,
2286                                     gpointer       data)
2287 {
2288   GtkRange *range = GTK_RANGE (data);
2289   /* create a copy of the layout */
2290   GtkRangeLayout layout = *range->layout;
2291
2292   range->need_recalc = TRUE;
2293   gtk_range_calc_layout (range, range->adjustment->value);
2294
2295   /* now check whether the layout changed  */
2296   if (layout_changed (range->layout, &layout))
2297     {
2298       gtk_widget_queue_draw (GTK_WIDGET (range));
2299       /* setup a timer to ensure the range isn't lagging too much behind the scroll position */
2300       if (!range->layout->repaint_id)
2301         range->layout->repaint_id = gdk_threads_add_timeout_full (GDK_PRIORITY_EVENTS, 181, force_repaint, range, NULL);
2302     }
2303
2304   /* Note that we don't round off to range->round_digits here.
2305    * that's because it's really broken to change a value
2306    * in response to a change signal on that value; round_digits
2307    * is therefore defined to be a filter on what the GtkRange
2308    * can input into the adjustment, not a filter that the GtkRange
2309    * will enforce on the adjustment.
2310    */
2311
2312   g_signal_emit (range, signals[VALUE_CHANGED], 0);
2313 }
2314
2315 static void
2316 gtk_range_style_set (GtkWidget *widget,
2317                      GtkStyle  *previous_style)
2318 {
2319   GtkRange *range = GTK_RANGE (widget);
2320
2321   range->need_recalc = TRUE;
2322
2323   (* GTK_WIDGET_CLASS (gtk_range_parent_class)->style_set) (widget, previous_style);
2324 }
2325
2326 static void
2327 step_back (GtkRange *range)
2328 {
2329   gdouble newval;
2330   gboolean handled;
2331
2332   newval = range->adjustment->value - range->adjustment->step_increment;
2333   g_signal_emit (range, signals[CHANGE_VALUE], 0,
2334                  GTK_SCROLL_STEP_BACKWARD, newval, &handled);
2335 }
2336
2337 static void
2338 step_forward (GtkRange *range)
2339 {
2340   gdouble newval;
2341   gboolean handled;
2342
2343   newval = range->adjustment->value + range->adjustment->step_increment;
2344   g_signal_emit (range, signals[CHANGE_VALUE], 0,
2345                  GTK_SCROLL_STEP_FORWARD, newval, &handled);
2346 }
2347
2348
2349 static void
2350 page_back (GtkRange *range)
2351 {
2352   gdouble newval;
2353   gboolean handled;
2354
2355   newval = range->adjustment->value - range->adjustment->page_increment;
2356   g_signal_emit (range, signals[CHANGE_VALUE], 0,
2357                  GTK_SCROLL_PAGE_BACKWARD, newval, &handled);
2358 }
2359
2360 static void
2361 page_forward (GtkRange *range)
2362 {
2363   gdouble newval;
2364   gboolean handled;
2365
2366   newval = range->adjustment->value + range->adjustment->page_increment;
2367   g_signal_emit (range, signals[CHANGE_VALUE], 0,
2368                  GTK_SCROLL_PAGE_FORWARD, newval, &handled);
2369 }
2370
2371 static void
2372 scroll_begin (GtkRange *range)
2373 {
2374   gboolean handled;
2375   g_signal_emit (range, signals[CHANGE_VALUE], 0,
2376                  GTK_SCROLL_START, range->adjustment->lower,
2377                  &handled);
2378 }
2379
2380 static void
2381 scroll_end (GtkRange *range)
2382 {
2383   gdouble newval;
2384   gboolean handled;
2385
2386   newval = range->adjustment->upper - range->adjustment->page_size;
2387   g_signal_emit (range, signals[CHANGE_VALUE], 0, GTK_SCROLL_END, newval,
2388                  &handled);
2389 }
2390
2391 static gboolean
2392 gtk_range_scroll (GtkRange     *range,
2393                   GtkScrollType scroll)
2394 {
2395   gdouble old_value = range->adjustment->value;
2396
2397   switch (scroll)
2398     {
2399     case GTK_SCROLL_STEP_LEFT:
2400       if (should_invert (range))
2401         step_forward (range);
2402       else
2403         step_back (range);
2404       break;
2405
2406     case GTK_SCROLL_STEP_UP:
2407       if (should_invert (range))
2408         step_forward (range);
2409       else
2410         step_back (range);
2411       break;
2412
2413     case GTK_SCROLL_STEP_RIGHT:
2414       if (should_invert (range))
2415         step_back (range);
2416       else
2417         step_forward (range);
2418       break;
2419
2420     case GTK_SCROLL_STEP_DOWN:
2421       if (should_invert (range))
2422         step_back (range);
2423       else
2424         step_forward (range);
2425       break;
2426
2427     case GTK_SCROLL_STEP_BACKWARD:
2428       step_back (range);
2429       break;
2430
2431     case GTK_SCROLL_STEP_FORWARD:
2432       step_forward (range);
2433       break;
2434
2435     case GTK_SCROLL_PAGE_LEFT:
2436       if (should_invert (range))
2437         page_forward (range);
2438       else
2439         page_back (range);
2440       break;
2441
2442     case GTK_SCROLL_PAGE_UP:
2443       if (should_invert (range))
2444         page_forward (range);
2445       else
2446         page_back (range);
2447       break;
2448
2449     case GTK_SCROLL_PAGE_RIGHT:
2450       if (should_invert (range))
2451         page_back (range);
2452       else
2453         page_forward (range);
2454       break;
2455
2456     case GTK_SCROLL_PAGE_DOWN:
2457       if (should_invert (range))
2458         page_back (range);
2459       else
2460         page_forward (range);
2461       break;
2462
2463     case GTK_SCROLL_PAGE_BACKWARD:
2464       page_back (range);
2465       break;
2466
2467     case GTK_SCROLL_PAGE_FORWARD:
2468       page_forward (range);
2469       break;
2470
2471     case GTK_SCROLL_START:
2472       scroll_begin (range);
2473       break;
2474
2475     case GTK_SCROLL_END:
2476       scroll_end (range);
2477       break;
2478
2479     case GTK_SCROLL_JUMP:
2480       /* Used by CList, range doesn't use it. */
2481       break;
2482
2483     case GTK_SCROLL_NONE:
2484       break;
2485     }
2486
2487   return range->adjustment->value != old_value;
2488 }
2489
2490 static void
2491 gtk_range_move_slider (GtkRange     *range,
2492                        GtkScrollType scroll)
2493 {
2494   gboolean cursor_only;
2495
2496   g_object_get (gtk_widget_get_settings (GTK_WIDGET (range)),
2497                 "gtk-keynav-cursor-only", &cursor_only,
2498                 NULL);
2499
2500   if (cursor_only)
2501     {
2502       GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (range));
2503
2504       if (range->orientation == GTK_ORIENTATION_HORIZONTAL)
2505         {
2506           if (scroll == GTK_SCROLL_STEP_UP ||
2507               scroll == GTK_SCROLL_STEP_DOWN)
2508             {
2509               if (toplevel)
2510                 gtk_widget_child_focus (toplevel,
2511                                         scroll == GTK_SCROLL_STEP_UP ?
2512                                         GTK_DIR_UP : GTK_DIR_DOWN);
2513               return;
2514             }
2515         }
2516       else
2517         {
2518           if (scroll == GTK_SCROLL_STEP_LEFT ||
2519               scroll == GTK_SCROLL_STEP_RIGHT)
2520             {
2521               if (toplevel)
2522                 gtk_widget_child_focus (toplevel,
2523                                         scroll == GTK_SCROLL_STEP_LEFT ?
2524                                         GTK_DIR_LEFT : GTK_DIR_RIGHT);
2525               return;
2526             }
2527         }
2528     }
2529
2530   if (! gtk_range_scroll (range, scroll))
2531     gtk_widget_error_bell (GTK_WIDGET (range));
2532
2533   /* Policy DELAYED makes sense with key events,
2534    * but DISCONTINUOUS doesn't, so we update immediately
2535    * for DISCONTINUOUS
2536    */
2537   if (range->update_policy == GTK_UPDATE_DISCONTINUOUS)
2538     gtk_range_update_value (range);
2539 }
2540
2541 static void
2542 gtk_range_get_props (GtkRange  *range,
2543                      gint      *slider_width,
2544                      gint      *stepper_size,
2545                      gint      *focus_width,
2546                      gint      *trough_border,
2547                      gint      *stepper_spacing,
2548                      gboolean  *trough_under_steppers,
2549                      gint      *arrow_displacement_x,
2550                      gint      *arrow_displacement_y)
2551 {
2552   GtkWidget *widget =  GTK_WIDGET (range);
2553   gint tmp_slider_width, tmp_stepper_size, tmp_focus_width, tmp_trough_border;
2554   gint tmp_stepper_spacing, tmp_trough_under_steppers;
2555   gint tmp_arrow_displacement_x, tmp_arrow_displacement_y;
2556
2557   gtk_widget_style_get (widget,
2558                         "slider-width", &tmp_slider_width,
2559                         "trough-border", &tmp_trough_border,
2560                         "stepper-size", &tmp_stepper_size,
2561                         "stepper-spacing", &tmp_stepper_spacing,
2562                         "trough-under-steppers", &tmp_trough_under_steppers,
2563                         "arrow-displacement-x", &tmp_arrow_displacement_x,
2564                         "arrow-displacement-y", &tmp_arrow_displacement_y,
2565                         NULL);
2566
2567   if (tmp_stepper_spacing > 0)
2568     tmp_trough_under_steppers = FALSE;
2569
2570   if (GTK_WIDGET_CAN_FOCUS (range))
2571     {
2572       gint focus_line_width;
2573       gint focus_padding;
2574
2575       gtk_widget_style_get (GTK_WIDGET (range),
2576                             "focus-line-width", &focus_line_width,
2577                             "focus-padding", &focus_padding,
2578                             NULL);
2579
2580       tmp_focus_width = focus_line_width + focus_padding;
2581     }
2582   else
2583     {
2584       tmp_focus_width = 0;
2585     }
2586
2587   if (slider_width)
2588     *slider_width = tmp_slider_width;
2589
2590   if (focus_width)
2591     *focus_width = tmp_focus_width;
2592
2593   if (trough_border)
2594     *trough_border = tmp_trough_border;
2595
2596   if (stepper_size)
2597     *stepper_size = tmp_stepper_size;
2598
2599   if (stepper_spacing)
2600     *stepper_spacing = tmp_stepper_spacing;
2601
2602   if (trough_under_steppers)
2603     *trough_under_steppers = tmp_trough_under_steppers;
2604
2605   if (arrow_displacement_x)
2606     *arrow_displacement_x = tmp_arrow_displacement_x;
2607
2608   if (arrow_displacement_y)
2609     *arrow_displacement_y = tmp_arrow_displacement_y;
2610 }
2611
2612 #define POINT_IN_RECT(xcoord, ycoord, rect) \
2613  ((xcoord) >= (rect).x &&                   \
2614   (xcoord) <  ((rect).x + (rect).width) &&  \
2615   (ycoord) >= (rect).y &&                   \
2616   (ycoord) <  ((rect).y + (rect).height))
2617
2618 /* Update mouse location, return TRUE if it changes */
2619 static gboolean
2620 gtk_range_update_mouse_location (GtkRange *range)
2621 {
2622   gint x, y;
2623   MouseLocation old;
2624   GtkWidget *widget;
2625
2626   widget = GTK_WIDGET (range);
2627
2628   old = range->layout->mouse_location;
2629
2630   x = range->layout->mouse_x;
2631   y = range->layout->mouse_y;
2632
2633   if (range->layout->grab_location != MOUSE_OUTSIDE)
2634     range->layout->mouse_location = range->layout->grab_location;
2635   else if (POINT_IN_RECT (x, y, range->layout->stepper_a))
2636     range->layout->mouse_location = MOUSE_STEPPER_A;
2637   else if (POINT_IN_RECT (x, y, range->layout->stepper_b))
2638     range->layout->mouse_location = MOUSE_STEPPER_B;
2639   else if (POINT_IN_RECT (x, y, range->layout->stepper_c))
2640     range->layout->mouse_location = MOUSE_STEPPER_C;
2641   else if (POINT_IN_RECT (x, y, range->layout->stepper_d))
2642     range->layout->mouse_location = MOUSE_STEPPER_D;
2643   else if (POINT_IN_RECT (x, y, range->layout->slider))
2644     range->layout->mouse_location = MOUSE_SLIDER;
2645   else if (POINT_IN_RECT (x, y, range->layout->trough))
2646     range->layout->mouse_location = MOUSE_TROUGH;
2647   else if (POINT_IN_RECT (x, y, widget->allocation))
2648     range->layout->mouse_location = MOUSE_WIDGET;
2649   else
2650     range->layout->mouse_location = MOUSE_OUTSIDE;
2651
2652   return old != range->layout->mouse_location;
2653 }
2654
2655 /* Clamp rect, border inside widget->allocation, such that we prefer
2656  * to take space from border not rect in all directions, and prefer to
2657  * give space to border over rect in one direction.
2658  */
2659 static void
2660 clamp_dimensions (GtkWidget    *widget,
2661                   GdkRectangle *rect,
2662                   GtkBorder    *border,
2663                   gboolean      border_expands_horizontally)
2664 {
2665   gint extra, shortage;
2666
2667   g_return_if_fail (rect->x == 0);
2668   g_return_if_fail (rect->y == 0);
2669   g_return_if_fail (rect->width >= 0);
2670   g_return_if_fail (rect->height >= 0);
2671
2672   /* Width */
2673
2674   extra = widget->allocation.width - border->left - border->right - rect->width;
2675   if (extra > 0)
2676     {
2677       if (border_expands_horizontally)
2678         {
2679           border->left += extra / 2;
2680           border->right += extra / 2 + extra % 2;
2681         }
2682       else
2683         {
2684           rect->width += extra;
2685         }
2686     }
2687
2688   /* See if we can fit rect, if not kill the border */
2689   shortage = rect->width - widget->allocation.width;
2690   if (shortage > 0)
2691     {
2692       rect->width = widget->allocation.width;
2693       /* lose the border */
2694       border->left = 0;
2695       border->right = 0;
2696     }
2697   else
2698     {
2699       /* See if we can fit rect with borders */
2700       shortage = rect->width + border->left + border->right -
2701         widget->allocation.width;
2702       if (shortage > 0)
2703         {
2704           /* Shrink borders */
2705           border->left -= shortage / 2;
2706           border->right -= shortage / 2 + shortage % 2;
2707         }
2708     }
2709
2710   /* Height */
2711
2712   extra = widget->allocation.height - border->top - border->bottom - rect->height;
2713   if (extra > 0)
2714     {
2715       if (border_expands_horizontally)
2716         {
2717           /* don't expand border vertically */
2718           rect->height += extra;
2719         }
2720       else
2721         {
2722           border->top += extra / 2;
2723           border->bottom += extra / 2 + extra % 2;
2724         }
2725     }
2726
2727   /* See if we can fit rect, if not kill the border */
2728   shortage = rect->height - widget->allocation.height;
2729   if (shortage > 0)
2730     {
2731       rect->height = widget->allocation.height;
2732       /* lose the border */
2733       border->top = 0;
2734       border->bottom = 0;
2735     }
2736   else
2737     {
2738       /* See if we can fit rect with borders */
2739       shortage = rect->height + border->top + border->bottom -
2740         widget->allocation.height;
2741       if (shortage > 0)
2742         {
2743           /* Shrink borders */
2744           border->top -= shortage / 2;
2745           border->bottom -= shortage / 2 + shortage % 2;
2746         }
2747     }
2748 }
2749
2750 static void
2751 gtk_range_calc_request (GtkRange      *range,
2752                         gint           slider_width,
2753                         gint           stepper_size,
2754                         gint           focus_width,
2755                         gint           trough_border,
2756                         gint           stepper_spacing,
2757                         GdkRectangle  *range_rect,
2758                         GtkBorder     *border,
2759                         gint          *n_steppers_p,
2760                         gboolean      *has_steppers_ab,
2761                         gboolean      *has_steppers_cd,
2762                         gint          *slider_length_p)
2763 {
2764   gint slider_length;
2765   gint n_steppers;
2766   gint n_steppers_ab;
2767   gint n_steppers_cd;
2768
2769   border->left = 0;
2770   border->right = 0;
2771   border->top = 0;
2772   border->bottom = 0;
2773
2774   if (GTK_RANGE_GET_CLASS (range)->get_range_border)
2775     (* GTK_RANGE_GET_CLASS (range)->get_range_border) (range, border);
2776
2777   n_steppers_ab = 0;
2778   n_steppers_cd = 0;
2779
2780   if (range->has_stepper_a)
2781     n_steppers_ab += 1;
2782   if (range->has_stepper_b)
2783     n_steppers_ab += 1;
2784   if (range->has_stepper_c)
2785     n_steppers_cd += 1;
2786   if (range->has_stepper_d)
2787     n_steppers_cd += 1;
2788
2789   n_steppers = n_steppers_ab + n_steppers_cd;
2790
2791   slider_length = range->min_slider_size;
2792
2793   range_rect->x = 0;
2794   range_rect->y = 0;
2795
2796   /* We never expand to fill available space in the small dimension
2797    * (i.e. vertical scrollbars are always a fixed width)
2798    */
2799   if (range->orientation == GTK_ORIENTATION_VERTICAL)
2800     {
2801       range_rect->width = (focus_width + trough_border) * 2 + slider_width;
2802       range_rect->height = stepper_size * n_steppers + (focus_width + trough_border) * 2 + slider_length;
2803
2804       if (n_steppers_ab > 0)
2805         range_rect->height += stepper_spacing;
2806
2807       if (n_steppers_cd > 0)
2808         range_rect->height += stepper_spacing;
2809     }
2810   else
2811     {
2812       range_rect->width = stepper_size * n_steppers + (focus_width + trough_border) * 2 + slider_length;
2813       range_rect->height = (focus_width + trough_border) * 2 + slider_width;
2814
2815       if (n_steppers_ab > 0)
2816         range_rect->width += stepper_spacing;
2817
2818       if (n_steppers_cd > 0)
2819         range_rect->width += stepper_spacing;
2820     }
2821
2822   if (n_steppers_p)
2823     *n_steppers_p = n_steppers;
2824
2825   if (has_steppers_ab)
2826     *has_steppers_ab = (n_steppers_ab > 0);
2827
2828   if (has_steppers_cd)
2829     *has_steppers_cd = (n_steppers_cd > 0);
2830
2831   if (slider_length_p)
2832     *slider_length_p = slider_length;
2833 }
2834
2835 static void
2836 gtk_range_calc_layout (GtkRange *range,
2837                        gdouble   adjustment_value)
2838 {
2839   gint slider_width, stepper_size, focus_width, trough_border, stepper_spacing;
2840   gint slider_length;
2841   GtkBorder border;
2842   gint n_steppers;
2843   gboolean has_steppers_ab;
2844   gboolean has_steppers_cd;
2845   gboolean trough_under_steppers;
2846   GdkRectangle range_rect;
2847   GtkRangeLayout *layout;
2848   GtkWidget *widget;
2849
2850   if (!range->need_recalc)
2851     return;
2852
2853   /* If we have a too-small allocation, we prefer the steppers over
2854    * the trough/slider, probably the steppers are a more useful
2855    * feature in small spaces.
2856    *
2857    * Also, we prefer to draw the range itself rather than the border
2858    * areas if there's a conflict, since the borders will be decoration
2859    * not controls. Though this depends on subclasses cooperating by
2860    * not drawing on range->range_rect.
2861    */
2862
2863   widget = GTK_WIDGET (range);
2864   layout = range->layout;
2865
2866   gtk_range_get_props (range,
2867                        &slider_width, &stepper_size,
2868                        &focus_width, &trough_border,
2869                        &stepper_spacing, &trough_under_steppers,
2870                        NULL, NULL);
2871
2872   gtk_range_calc_request (range,
2873                           slider_width, stepper_size,
2874                           focus_width, trough_border, stepper_spacing,
2875                           &range_rect, &border, &n_steppers,
2876                           &has_steppers_ab, &has_steppers_cd, &slider_length);
2877
2878   /* We never expand to fill available space in the small dimension
2879    * (i.e. vertical scrollbars are always a fixed width)
2880    */
2881   if (range->orientation == GTK_ORIENTATION_VERTICAL)
2882     {
2883       clamp_dimensions (widget, &range_rect, &border, TRUE);
2884     }
2885   else
2886     {
2887       clamp_dimensions (widget, &range_rect, &border, FALSE);
2888     }
2889
2890   range_rect.x = border.left;
2891   range_rect.y = border.top;
2892
2893   range->range_rect = range_rect;
2894
2895   if (range->orientation == GTK_ORIENTATION_VERTICAL)
2896     {
2897       gint stepper_width, stepper_height;
2898
2899       /* Steppers are the width of the range, and stepper_size in
2900        * height, or if we don't have enough height, divided equally
2901        * among available space.
2902        */
2903       stepper_width = range_rect.width - focus_width * 2;
2904
2905       if (trough_under_steppers)
2906         stepper_width -= trough_border * 2;
2907
2908       if (stepper_width < 1)
2909         stepper_width = range_rect.width; /* screw the trough border */
2910
2911       if (n_steppers == 0)
2912         stepper_height = 0; /* avoid divide by n_steppers */
2913       else
2914         stepper_height = MIN (stepper_size, (range_rect.height / n_steppers));
2915
2916       /* Stepper A */
2917
2918       layout->stepper_a.x = range_rect.x + focus_width + trough_border * trough_under_steppers;
2919       layout->stepper_a.y = range_rect.y + focus_width + trough_border * trough_under_steppers;
2920
2921       if (range->has_stepper_a)
2922         {
2923           layout->stepper_a.width = stepper_width;
2924           layout->stepper_a.height = stepper_height;
2925         }
2926       else
2927         {
2928           layout->stepper_a.width = 0;
2929           layout->stepper_a.height = 0;
2930         }
2931
2932       /* Stepper B */
2933
2934       layout->stepper_b.x = layout->stepper_a.x;
2935       layout->stepper_b.y = layout->stepper_a.y + layout->stepper_a.height;
2936
2937       if (range->has_stepper_b)
2938         {
2939           layout->stepper_b.width = stepper_width;
2940           layout->stepper_b.height = stepper_height;
2941         }
2942       else
2943         {
2944           layout->stepper_b.width = 0;
2945           layout->stepper_b.height = 0;
2946         }
2947
2948       /* Stepper D */
2949
2950       if (range->has_stepper_d)
2951         {
2952           layout->stepper_d.width = stepper_width;
2953           layout->stepper_d.height = stepper_height;
2954         }
2955       else
2956         {
2957           layout->stepper_d.width = 0;
2958           layout->stepper_d.height = 0;
2959         }
2960
2961       layout->stepper_d.x = layout->stepper_a.x;
2962       layout->stepper_d.y = range_rect.y + range_rect.height - layout->stepper_d.height - focus_width - trough_border * trough_under_steppers;
2963
2964       /* Stepper C */
2965
2966       if (range->has_stepper_c)
2967         {
2968           layout->stepper_c.width = stepper_width;
2969           layout->stepper_c.height = stepper_height;
2970         }
2971       else
2972         {
2973           layout->stepper_c.width = 0;
2974           layout->stepper_c.height = 0;
2975         }
2976
2977       layout->stepper_c.x = layout->stepper_a.x;
2978       layout->stepper_c.y = layout->stepper_d.y - layout->stepper_c.height;
2979
2980       /* Now the trough is the remaining space between steppers B and C,
2981        * if any, minus spacing
2982        */
2983       layout->trough.x = range_rect.x;
2984       layout->trough.y = layout->stepper_b.y + layout->stepper_b.height + stepper_spacing * has_steppers_ab;
2985       layout->trough.width = range_rect.width;
2986       layout->trough.height = layout->stepper_c.y - layout->trough.y - stepper_spacing * has_steppers_cd;
2987
2988       /* Slider fits into the trough, with stepper_spacing on either side,
2989        * and the size/position based on the adjustment or fixed, depending.
2990        */
2991       layout->slider.x = layout->trough.x + focus_width + trough_border;
2992       layout->slider.width = layout->trough.width - (focus_width + trough_border) * 2;
2993
2994       /* Compute slider position/length */
2995       {
2996         gint y, bottom, top, height;
2997
2998         top = layout->trough.y;
2999         bottom = layout->trough.y + layout->trough.height;
3000
3001         if (! trough_under_steppers)
3002           {
3003             top += trough_border;
3004             bottom -= trough_border;
3005           }
3006
3007         /* slider height is the fraction (page_size /
3008          * total_adjustment_range) times the trough height in pixels
3009          */
3010
3011         if (range->adjustment->upper - range->adjustment->lower != 0)
3012           height = ((bottom - top) * (range->adjustment->page_size /
3013                                        (range->adjustment->upper - range->adjustment->lower)));
3014         else
3015           height = range->min_slider_size;
3016
3017         if (height < range->min_slider_size ||
3018             range->slider_size_fixed)
3019           height = range->min_slider_size;
3020
3021         height = MIN (height, layout->trough.height);
3022
3023         y = top;
3024
3025         if (range->adjustment->upper - range->adjustment->lower - range->adjustment->page_size != 0)
3026           y += (bottom - top - height) * ((adjustment_value - range->adjustment->lower) /
3027                                           (range->adjustment->upper - range->adjustment->lower - range->adjustment->page_size));
3028
3029         y = CLAMP (y, top, bottom);
3030
3031         if (should_invert (range))
3032           y = bottom - (y - top + height);
3033
3034         layout->slider.y = y;
3035         layout->slider.height = height;
3036
3037         /* These are publically exported */
3038         range->slider_start = layout->slider.y;
3039         range->slider_end = layout->slider.y + layout->slider.height;
3040       }
3041     }
3042   else
3043     {
3044       gint stepper_width, stepper_height;
3045
3046       /* Steppers are the height of the range, and stepper_size in
3047        * width, or if we don't have enough width, divided equally
3048        * among available space.
3049        */
3050       stepper_height = range_rect.height + focus_width * 2;
3051
3052       if (trough_under_steppers)
3053         stepper_height -= trough_border * 2;
3054
3055       if (stepper_height < 1)
3056         stepper_height = range_rect.height; /* screw the trough border */
3057
3058       if (n_steppers == 0)
3059         stepper_width = 0; /* avoid divide by n_steppers */
3060       else
3061         stepper_width = MIN (stepper_size, (range_rect.width / n_steppers));
3062
3063       /* Stepper A */
3064
3065       layout->stepper_a.x = range_rect.x + focus_width + trough_border * trough_under_steppers;
3066       layout->stepper_a.y = range_rect.y + focus_width + trough_border * trough_under_steppers;
3067
3068       if (range->has_stepper_a)
3069         {
3070           layout->stepper_a.width = stepper_width;
3071           layout->stepper_a.height = stepper_height;
3072         }
3073       else
3074         {
3075           layout->stepper_a.width = 0;
3076           layout->stepper_a.height = 0;
3077         }
3078
3079       /* Stepper B */
3080
3081       layout->stepper_b.x = layout->stepper_a.x + layout->stepper_a.width;
3082       layout->stepper_b.y = layout->stepper_a.y;
3083
3084       if (range->has_stepper_b)
3085         {
3086           layout->stepper_b.width = stepper_width;
3087           layout->stepper_b.height = stepper_height;
3088         }
3089       else
3090         {
3091           layout->stepper_b.width = 0;
3092           layout->stepper_b.height = 0;
3093         }
3094
3095       /* Stepper D */
3096
3097       if (range->has_stepper_d)
3098         {
3099           layout->stepper_d.width = stepper_width;
3100           layout->stepper_d.height = stepper_height;
3101         }
3102       else
3103         {
3104           layout->stepper_d.width = 0;
3105           layout->stepper_d.height = 0;
3106         }
3107
3108       layout->stepper_d.x = range_rect.x + range_rect.width - layout->stepper_d.width - focus_width - trough_border * trough_under_steppers;
3109       layout->stepper_d.y = layout->stepper_a.y;
3110
3111
3112       /* Stepper C */
3113
3114       if (range->has_stepper_c)
3115         {
3116           layout->stepper_c.width = stepper_width;
3117           layout->stepper_c.height = stepper_height;
3118         }
3119       else
3120         {
3121           layout->stepper_c.width = 0;
3122           layout->stepper_c.height = 0;
3123         }
3124
3125       layout->stepper_c.x = layout->stepper_d.x - layout->stepper_c.width;
3126       layout->stepper_c.y = layout->stepper_a.y;
3127
3128       /* Now the trough is the remaining space between steppers B and C,
3129        * if any
3130        */
3131       layout->trough.x = layout->stepper_b.x + layout->stepper_b.width + stepper_spacing * has_steppers_ab;
3132       layout->trough.y = range_rect.y;
3133
3134       layout->trough.width = layout->stepper_c.x - layout->trough.x - stepper_spacing * has_steppers_cd;
3135       layout->trough.height = range_rect.height;
3136
3137       /* Slider fits into the trough, with stepper_spacing on either side,
3138        * and the size/position based on the adjustment or fixed, depending.
3139        */
3140       layout->slider.y = layout->trough.y + focus_width + trough_border;
3141       layout->slider.height = layout->trough.height - (focus_width + trough_border) * 2;
3142
3143       /* Compute slider position/length */
3144       {
3145         gint x, left, right, width;
3146
3147         left = layout->trough.x;
3148         right = layout->trough.x + layout->trough.width;
3149
3150         if (! trough_under_steppers)
3151           {
3152             left += trough_border;
3153             right -= trough_border;
3154           }
3155
3156         /* slider width is the fraction (page_size /
3157          * total_adjustment_range) times the trough width in pixels
3158          */
3159
3160         if (range->adjustment->upper - range->adjustment->lower != 0)
3161           width = ((right - left) * (range->adjustment->page_size /
3162                                    (range->adjustment->upper - range->adjustment->lower)));
3163         else
3164           width = range->min_slider_size;
3165
3166         if (width < range->min_slider_size ||
3167             range->slider_size_fixed)
3168           width = range->min_slider_size;
3169
3170         width = MIN (width, layout->trough.width);
3171
3172         x = left;
3173
3174         if (range->adjustment->upper - range->adjustment->lower - range->adjustment->page_size != 0)
3175           x += (right - left - width) * ((adjustment_value - range->adjustment->lower) /
3176                                          (range->adjustment->upper - range->adjustment->lower - range->adjustment->page_size));
3177
3178         x = CLAMP (x, left, right);
3179
3180         if (should_invert (range))
3181           x = right - (x - left + width);
3182
3183         layout->slider.x = x;
3184         layout->slider.width = width;
3185
3186         /* These are publically exported */
3187         range->slider_start = layout->slider.x;
3188         range->slider_end = layout->slider.x + layout->slider.width;
3189       }
3190     }
3191
3192   gtk_range_update_mouse_location (range);
3193
3194   switch (range->layout->upper_sensitivity)
3195     {
3196     case GTK_SENSITIVITY_AUTO:
3197       range->layout->upper_sensitive =
3198         (range->adjustment->value <
3199          (range->adjustment->upper - range->adjustment->page_size));
3200       break;
3201
3202     case GTK_SENSITIVITY_ON:
3203       range->layout->upper_sensitive = TRUE;
3204       break;
3205
3206     case GTK_SENSITIVITY_OFF:
3207       range->layout->upper_sensitive = FALSE;
3208       break;
3209     }
3210
3211   switch (range->layout->lower_sensitivity)
3212     {
3213     case GTK_SENSITIVITY_AUTO:
3214       range->layout->lower_sensitive =
3215         (range->adjustment->value > range->adjustment->lower);
3216       break;
3217
3218     case GTK_SENSITIVITY_ON:
3219       range->layout->lower_sensitive = TRUE;
3220       break;
3221
3222     case GTK_SENSITIVITY_OFF:
3223       range->layout->lower_sensitive = FALSE;
3224       break;
3225     }
3226 }
3227
3228 static GdkRectangle*
3229 get_area (GtkRange     *range,
3230           MouseLocation location)
3231 {
3232   switch (location)
3233     {
3234     case MOUSE_STEPPER_A:
3235       return &range->layout->stepper_a;
3236     case MOUSE_STEPPER_B:
3237       return &range->layout->stepper_b;
3238     case MOUSE_STEPPER_C:
3239       return &range->layout->stepper_c;
3240     case MOUSE_STEPPER_D:
3241       return &range->layout->stepper_d;
3242     case MOUSE_TROUGH:
3243       return &range->layout->trough;
3244     case MOUSE_SLIDER:
3245       return &range->layout->slider;
3246     case MOUSE_WIDGET:
3247     case MOUSE_OUTSIDE:
3248       break;
3249     }
3250
3251   g_warning (G_STRLOC": bug");
3252   return NULL;
3253 }
3254
3255 static gboolean
3256 gtk_range_real_change_value (GtkRange     *range,
3257                              GtkScrollType scroll,
3258                              gdouble       value)
3259 {
3260   /* potentially adjust the bounds _before we clamp */
3261   g_signal_emit (range, signals[ADJUST_BOUNDS], 0, value);
3262
3263   if (range->layout->restrict_to_fill_level)
3264     value = MIN (value, MAX (range->adjustment->lower,
3265                              range->layout->fill_level));
3266
3267   value = CLAMP (value, range->adjustment->lower,
3268                  (range->adjustment->upper - range->adjustment->page_size));
3269
3270   if (range->round_digits >= 0)
3271     {
3272       gdouble power;
3273       gint i;
3274
3275       i = range->round_digits;
3276       power = 1;
3277       while (i--)
3278         power *= 10;
3279
3280       value = floor ((value * power) + 0.5) / power;
3281     }
3282
3283   if (range->adjustment->value != value)
3284     {
3285       range->need_recalc = TRUE;
3286
3287       gtk_widget_queue_draw (GTK_WIDGET (range));
3288
3289       switch (range->update_policy)
3290         {
3291         case GTK_UPDATE_CONTINUOUS:
3292           gtk_adjustment_set_value (range->adjustment, value);
3293           break;
3294
3295           /* Delayed means we update after a period of inactivity */
3296         case GTK_UPDATE_DELAYED:
3297           gtk_range_reset_update_timer (range);
3298           /* FALL THRU */
3299
3300           /* Discontinuous means we update on button release */
3301         case GTK_UPDATE_DISCONTINUOUS:
3302           /* don't emit value_changed signal */
3303           range->adjustment->value = value;
3304           range->update_pending = TRUE;
3305           break;
3306         }
3307     }
3308   return FALSE;
3309 }
3310
3311 static void
3312 gtk_range_update_value (GtkRange *range)
3313 {
3314   gtk_range_remove_update_timer (range);
3315
3316   if (range->update_pending)
3317     {
3318       gtk_adjustment_value_changed (range->adjustment);
3319
3320       range->update_pending = FALSE;
3321     }
3322 }
3323
3324 struct _GtkRangeStepTimer
3325 {
3326   guint timeout_id;
3327   GtkScrollType step;
3328 };
3329
3330 static gboolean
3331 second_timeout (gpointer data)
3332 {
3333   GtkRange *range;
3334
3335   range = GTK_RANGE (data);
3336   gtk_range_scroll (range, range->timer->step);
3337
3338   return TRUE;
3339 }
3340
3341 static gboolean
3342 initial_timeout (gpointer data)
3343 {
3344   GtkRange    *range;
3345   GtkSettings *settings;
3346   guint        timeout;
3347
3348   settings = gtk_widget_get_settings (GTK_WIDGET (data));
3349   g_object_get (settings, "gtk-timeout-repeat", &timeout, NULL);
3350
3351   range = GTK_RANGE (data);
3352   range->timer->timeout_id = gdk_threads_add_timeout (timeout * SCROLL_DELAY_FACTOR,
3353                                             second_timeout,
3354                                             range);
3355   /* remove self */
3356   return FALSE;
3357 }
3358
3359 static void
3360 gtk_range_add_step_timer (GtkRange      *range,
3361                           GtkScrollType  step)
3362 {
3363   GtkSettings *settings;
3364   guint        timeout;
3365
3366   g_return_if_fail (range->timer == NULL);
3367   g_return_if_fail (step != GTK_SCROLL_NONE);
3368
3369   settings = gtk_widget_get_settings (GTK_WIDGET (range));
3370   g_object_get (settings, "gtk-timeout-initial", &timeout, NULL);
3371
3372   range->timer = g_new (GtkRangeStepTimer, 1);
3373
3374   range->timer->timeout_id = gdk_threads_add_timeout (timeout,
3375                                             initial_timeout,
3376                                             range);
3377   range->timer->step = step;
3378
3379   gtk_range_scroll (range, range->timer->step);
3380 }
3381
3382 static void
3383 gtk_range_remove_step_timer (GtkRange *range)
3384 {
3385   if (range->timer)
3386     {
3387       if (range->timer->timeout_id != 0)
3388         g_source_remove (range->timer->timeout_id);
3389
3390       g_free (range->timer);
3391
3392       range->timer = NULL;
3393     }
3394 }
3395
3396 static gboolean
3397 update_timeout (gpointer data)
3398 {
3399   GtkRange *range;
3400
3401   range = GTK_RANGE (data);
3402   gtk_range_update_value (range);
3403   range->update_timeout_id = 0;
3404
3405   /* self-remove */
3406   return FALSE;
3407 }
3408
3409 static void
3410 gtk_range_reset_update_timer (GtkRange *range)
3411 {
3412   gtk_range_remove_update_timer (range);
3413
3414   range->update_timeout_id = gdk_threads_add_timeout (UPDATE_DELAY,
3415                                             update_timeout,
3416                                             range);
3417 }
3418
3419 static void
3420 gtk_range_remove_update_timer (GtkRange *range)
3421 {
3422   if (range->update_timeout_id != 0)
3423     {
3424       g_source_remove (range->update_timeout_id);
3425       range->update_timeout_id = 0;
3426     }
3427 }
3428
3429 #define __GTK_RANGE_C__
3430 #include "gtkaliasdef.c"