Pileus Git - ~andy/gtk/blob - gtk/gtkscale.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-2000.  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
  30 #include <math.h>
  31 #include <stdlib.h>
  32
  33 #include "gtkscaleprivate.h"
  34 #include "gtkiconfactory.h"
  35 #include "gtkicontheme.h"
  36 #include "gtkmarshalers.h"
  37 #include "gtkbindings.h"
  38 #include "gtkorientable.h"
  39 #include "gtktypebuiltins.h"
  40 #include "gtkprivate.h"
  41 #include "gtkintl.h"
  42 #include "gtkbuildable.h"
  43 #include "gtkbuilderprivate.h"
  44
  45 #include "a11y/gtkscaleaccessible.h"
  46
  47
  48 /**
  49  * SECTION:gtkscale
  50  * @Short_description: A slider widget for selecting a value from a range
  51  * @Title: GtkScale
  52  *
  53  * A GtkScale is a slider control used to select a numeric value.
  54  * To use it, you'll probably want to investigate the methods on
  55  * its base class, #GtkRange, in addition to the methods for GtkScale itself.
  56  * To set the value of a scale, you would normally use gtk_range_set_value().
  57  * To detect changes to the value, you would normally use the
  58  * #GtkRange::value-changed signal.
  59  *
  60  * Note that using the same upper and lower bounds for the #GtkScale (through
  61  * the #GtkRange methods) will hide the slider itself. This is useful for
  62  * applications that want to show an undeterminate value on the scale, without
  63  * changing the layout of the application (such as movie or music players).
  64  *
  65  * <refsect2 id="GtkScale-BUILDER-UI"><title>GtkScale as GtkBuildable</title>
  66  * GtkScale supports a custom &lt;marks&gt; element, which
  67  * can contain multiple &lt;mark&gt; elements. The "value" and "position"
  68  * attributes have the same meaning as gtk_scale_add_mark() parameters of the
  69  * same name. If the element is not empty, its content is taken as the markup
  70  * to show at the mark. It can be translated with the usual "translatable and
  71  * "context" attributes.
  72  * </refsect2>
  73  */
  74
  75
  76 #define MAX_DIGITS      (64)    /* don't change this,
  77                                  * a) you don't need to and
  78                                  * b) you might cause buffer owerflows in
  79                                  *    unrelated code portions otherwise
  80                                  */
  81
  82 typedef struct _GtkScaleMark GtkScaleMark;
  83
  84 struct _GtkScalePrivate
  85 {
  86   PangoLayout  *layout;
  87
  88   GSList       *marks;
  89
  90   gint          digits;
  91
  92   guint         draw_value : 1;
  93   guint         value_pos  : 2;
  94 };
  95
  96 struct _GtkScaleMark
  97 {
  98   gdouble          value;
  99   gchar           *markup;
 100   GtkPositionType  position; /* always GTK_POS_TOP or GTK_POS_BOTTOM */
 101 };
 102
 103 enum {
 104   PROP_0,
 105   PROP_DIGITS,
 106   PROP_DRAW_VALUE,
 107   PROP_HAS_ORIGIN,
 108   PROP_VALUE_POS
 109 };
 110
 111 enum {
 112   FORMAT_VALUE,
 113   LAST_SIGNAL
 114 };
 115
 116 static guint signals[LAST_SIGNAL];
 117
 118 static void     gtk_scale_set_property            (GObject        *object,
 119                                                    guint           prop_id,
 120                                                    const GValue   *value,
 121                                                    GParamSpec     *pspec);
 122 static void     gtk_scale_get_property            (GObject        *object,
 123                                                    guint           prop_id,
 124                                                    GValue         *value,
 125                                                    GParamSpec     *pspec);
 126 static void     gtk_scale_get_preferred_width     (GtkWidget      *widget,
 127                                                    gint           *minimum,
 128                                                    gint           *natural);
 129 static void     gtk_scale_get_preferred_height    (GtkWidget      *widget,
 130                                                    gint           *minimum,
 131                                                    gint           *natural);
 132 static void     gtk_scale_style_updated           (GtkWidget      *widget);
 133 static void     gtk_scale_get_range_border        (GtkRange       *range,
 134                                                    GtkBorder      *border);
 135 static void     gtk_scale_get_mark_label_size     (GtkScale        *scale,
 136                                                    GtkPositionType  position,
 137                                                    gint            *count1,
 138                                                    gint            *width1,
 139                                                    gint            *height1,
 140                                                    gint            *count2,
 141                                                    gint            *width2,
 142                                                    gint            *height2);
 143 static void     gtk_scale_finalize                (GObject        *object);
 144 static void     gtk_scale_screen_changed          (GtkWidget      *widget,
 145                                                    GdkScreen      *old_screen);
 146 static gboolean gtk_scale_draw                    (GtkWidget      *widget,
 147                                                    cairo_t        *cr);
 148 static void     gtk_scale_real_get_layout_offsets (GtkScale       *scale,
 149                                                    gint           *x,
 150                                                    gint           *y);
 151 static void     gtk_scale_buildable_interface_init   (GtkBuildableIface *iface);
 152 static gboolean gtk_scale_buildable_custom_tag_start (GtkBuildable  *buildable,
 153                                                       GtkBuilder    *builder,
 154                                                       GObject       *child,
 155                                                       const gchar   *tagname,
 156                                                       GMarkupParser *parser,
 157                                                       gpointer      *data);
 158 static void     gtk_scale_buildable_custom_finished  (GtkBuildable  *buildable,
 159                                                       GtkBuilder    *builder,
 160                                                       GObject       *child,
 161                                                       const gchar   *tagname,
 162                                                       gpointer       user_data);
 163
 164
 165 G_DEFINE_TYPE_WITH_CODE (GtkScale, gtk_scale, GTK_TYPE_RANGE,
 166                          G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
 167                                                 gtk_scale_buildable_interface_init))
 168
 169
 170 #define add_slider_binding(binding_set, keyval, mask, scroll)              \
 171   gtk_binding_entry_add_signal (binding_set, keyval, mask,                 \
 172                                 I_("move-slider"), 1, \
 173                                 GTK_TYPE_SCROLL_TYPE, scroll)
 174
 175 static void
 176 gtk_scale_class_init (GtkScaleClass *class)
 177 {
 178   GObjectClass   *gobject_class;
 179   GtkWidgetClass *widget_class;
 180   GtkRangeClass  *range_class;
 181   GtkBindingSet  *binding_set;
 182
 183   gobject_class = G_OBJECT_CLASS (class);
 184   range_class = (GtkRangeClass*) class;
 185   widget_class = (GtkWidgetClass*) class;
 186
 187   gobject_class->set_property = gtk_scale_set_property;
 188   gobject_class->get_property = gtk_scale_get_property;
 189   gobject_class->finalize = gtk_scale_finalize;
 190
 191   widget_class->style_updated = gtk_scale_style_updated;
 192   widget_class->screen_changed = gtk_scale_screen_changed;
 193   widget_class->draw = gtk_scale_draw;
 194   widget_class->get_preferred_width = gtk_scale_get_preferred_width;
 195   widget_class->get_preferred_height = gtk_scale_get_preferred_height;
 196
 197   range_class->slider_detail = "Xscale";
 198   range_class->get_range_border = gtk_scale_get_range_border;
 199
 200   class->get_layout_offsets = gtk_scale_real_get_layout_offsets;
 201
 202   /**
 203    * GtkScale::format-value:
 204    * @scale: the object which received the signal
 205    * @value: the value to format
 206    *
 207    * Signal which allows you to change how the scale value is displayed.
 208    * Connect a signal handler which returns an allocated string representing
 209    * @value. That string will then be used to display the scale's value.
 210    *
 211    * Here's an example signal handler which displays a value 1.0 as
 212    * with "--&gt;1.0&lt;--".
 213    * |[
 214    * static gchar*
 215    * format_value_callback (GtkScale *scale,
 216    *                        gdouble   value)
 217    * {
 218    *   return g_strdup_printf ("--&gt;&percnt;0.*g&lt;--",
 219    *                           gtk_scale_get_digits (scale), value);
 220    *  }
 221    * ]|
 222    *
 223    * Return value: allocated string representing @value
 224    */
 225   signals[FORMAT_VALUE] =
 226     g_signal_new (I_("format-value"),
 227                   G_TYPE_FROM_CLASS (gobject_class),
 228                   G_SIGNAL_RUN_LAST,
 229                   G_STRUCT_OFFSET (GtkScaleClass, format_value),
 230                   _gtk_single_string_accumulator, NULL,
 231                   _gtk_marshal_STRING__DOUBLE,
 232                   G_TYPE_STRING, 1,
 233                   G_TYPE_DOUBLE);
 234
 235   g_object_class_install_property (gobject_class,
 236                                    PROP_DIGITS,
 237                                    g_param_spec_int ("digits",
 238                                                      P_("Digits"),
 239                                                      P_("The number of decimal places that are displayed in the value"),
 240                                                      -1,
 241                                                      MAX_DIGITS,
 242                                                      1,
 243                                                      GTK_PARAM_READWRITE));
 244
 245   g_object_class_install_property (gobject_class,
 246                                    PROP_DRAW_VALUE,
 247                                    g_param_spec_boolean ("draw-value",
 248                                                          P_("Draw Value"),
 249                                                          P_("Whether the current value is displayed as a string next to the slider"),
 250                                                          TRUE,
 251                                                          GTK_PARAM_READWRITE));
 252
 253   g_object_class_install_property (gobject_class,
 254                                    PROP_HAS_ORIGIN,
 255                                    g_param_spec_boolean ("has-origin",
 256                                                          P_("Has Origin"),
 257                                                          P_("Whether the scale has an origin"),
 258                                                          TRUE,
 259                                                          GTK_PARAM_READWRITE));
 260
 261   g_object_class_install_property (gobject_class,
 262                                    PROP_VALUE_POS,
 263                                    g_param_spec_enum ("value-pos",
 264                                                       P_("Value Position"),
 265                                                       P_("The position in which the current value is displayed"),
 266                                                       GTK_TYPE_POSITION_TYPE,
 267                                                       GTK_POS_TOP,
 268                                                       GTK_PARAM_READWRITE));
 269
 270   gtk_widget_class_install_style_property (widget_class,
 271                                            g_param_spec_int ("slider-length",
 272                                                              P_("Slider Length"),
 273                                                              P_("Length of scale's slider"),
 274                                                              0,
 275                                                              G_MAXINT,
 276                                                              31,
 277                                                              GTK_PARAM_READABLE));
 278
 279   gtk_widget_class_install_style_property (widget_class,
 280                                            g_param_spec_int ("value-spacing",
 281                                                              P_("Value spacing"),
 282                                                              P_("Space between value text and the slider/trough area"),
 283                                                              0,
 284                                                              G_MAXINT,
 285                                                              2,
 286                                                              GTK_PARAM_READABLE));
 287
 288   /* All bindings (even arrow keys) are on both h/v scale, because
 289    * blind users etc. don't care about scale orientation.
 290    */
 291
 292   binding_set = gtk_binding_set_by_class (class);
 293
 294   add_slider_binding (binding_set, GDK_KEY_Left, 0,
 295                       GTK_SCROLL_STEP_LEFT);
 296
 297   add_slider_binding (binding_set, GDK_KEY_Left, GDK_CONTROL_MASK,
 298                       GTK_SCROLL_PAGE_LEFT);
 299
 300   add_slider_binding (binding_set, GDK_KEY_KP_Left, 0,
 301                       GTK_SCROLL_STEP_LEFT);
 302
 303   add_slider_binding (binding_set, GDK_KEY_KP_Left, GDK_CONTROL_MASK,
 304                       GTK_SCROLL_PAGE_LEFT);
 305
 306   add_slider_binding (binding_set, GDK_KEY_Right, 0,
 307                       GTK_SCROLL_STEP_RIGHT);
 308
 309   add_slider_binding (binding_set, GDK_KEY_Right, GDK_CONTROL_MASK,
 310                       GTK_SCROLL_PAGE_RIGHT);
 311
 312   add_slider_binding (binding_set, GDK_KEY_KP_Right, 0,
 313                       GTK_SCROLL_STEP_RIGHT);
 314
 315   add_slider_binding (binding_set, GDK_KEY_KP_Right, GDK_CONTROL_MASK,
 316                       GTK_SCROLL_PAGE_RIGHT);
 317
 318   add_slider_binding (binding_set, GDK_KEY_Up, 0,
 319                       GTK_SCROLL_STEP_UP);
 320
 321   add_slider_binding (binding_set, GDK_KEY_Up, GDK_CONTROL_MASK,
 322                       GTK_SCROLL_PAGE_UP);
 323
 324   add_slider_binding (binding_set, GDK_KEY_KP_Up, 0,
 325                       GTK_SCROLL_STEP_UP);
 326
 327   add_slider_binding (binding_set, GDK_KEY_KP_Up, GDK_CONTROL_MASK,
 328                       GTK_SCROLL_PAGE_UP);
 329
 330   add_slider_binding (binding_set, GDK_KEY_Down, 0,
 331                       GTK_SCROLL_STEP_DOWN);
 332
 333   add_slider_binding (binding_set, GDK_KEY_Down, GDK_CONTROL_MASK,
 334                       GTK_SCROLL_PAGE_DOWN);
 335
 336   add_slider_binding (binding_set, GDK_KEY_KP_Down, 0,
 337                       GTK_SCROLL_STEP_DOWN);
 338
 339   add_slider_binding (binding_set, GDK_KEY_KP_Down, GDK_CONTROL_MASK,
 340                       GTK_SCROLL_PAGE_DOWN);
 341
 342   add_slider_binding (binding_set, GDK_KEY_Page_Up, GDK_CONTROL_MASK,
 343                       GTK_SCROLL_PAGE_LEFT);
 344
 345   add_slider_binding (binding_set, GDK_KEY_KP_Page_Up, GDK_CONTROL_MASK,
 346                       GTK_SCROLL_PAGE_LEFT);
 347
 348   add_slider_binding (binding_set, GDK_KEY_Page_Up, 0,
 349                       GTK_SCROLL_PAGE_UP);
 350
 351   add_slider_binding (binding_set, GDK_KEY_KP_Page_Up, 0,
 352                       GTK_SCROLL_PAGE_UP);
 353
 354   add_slider_binding (binding_set, GDK_KEY_Page_Down, GDK_CONTROL_MASK,
 355                       GTK_SCROLL_PAGE_RIGHT);
 356
 357   add_slider_binding (binding_set, GDK_KEY_KP_Page_Down, GDK_CONTROL_MASK,
 358                       GTK_SCROLL_PAGE_RIGHT);
 359
 360   add_slider_binding (binding_set, GDK_KEY_Page_Down, 0,
 361                       GTK_SCROLL_PAGE_DOWN);
 362
 363   add_slider_binding (binding_set, GDK_KEY_KP_Page_Down, 0,
 364                       GTK_SCROLL_PAGE_DOWN);
 365
 366   /* Logical bindings (vs. visual bindings above) */
 367
 368   add_slider_binding (binding_set, GDK_KEY_plus, 0,
 369                       GTK_SCROLL_STEP_FORWARD);
 370
 371   add_slider_binding (binding_set, GDK_KEY_minus, 0,
 372                       GTK_SCROLL_STEP_BACKWARD);
 373
 374   add_slider_binding (binding_set, GDK_KEY_plus, GDK_CONTROL_MASK,
 375                       GTK_SCROLL_PAGE_FORWARD);
 376
 377   add_slider_binding (binding_set, GDK_KEY_minus, GDK_CONTROL_MASK,
 378                       GTK_SCROLL_PAGE_BACKWARD);
 379
 380
 381   add_slider_binding (binding_set, GDK_KEY_KP_Add, 0,
 382                       GTK_SCROLL_STEP_FORWARD);
 383
 384   add_slider_binding (binding_set, GDK_KEY_KP_Subtract, 0,
 385                       GTK_SCROLL_STEP_BACKWARD);
 386
 387   add_slider_binding (binding_set, GDK_KEY_KP_Add, GDK_CONTROL_MASK,
 388                       GTK_SCROLL_PAGE_FORWARD);
 389
 390   add_slider_binding (binding_set, GDK_KEY_KP_Subtract, GDK_CONTROL_MASK,
 391                       GTK_SCROLL_PAGE_BACKWARD);
 392
 393
 394   add_slider_binding (binding_set, GDK_KEY_Home, 0,
 395                       GTK_SCROLL_START);
 396
 397   add_slider_binding (binding_set, GDK_KEY_KP_Home, 0,
 398                       GTK_SCROLL_START);
 399
 400   add_slider_binding (binding_set, GDK_KEY_End, 0,
 401                       GTK_SCROLL_END);
 402
 403   add_slider_binding (binding_set, GDK_KEY_KP_End, 0,
 404                       GTK_SCROLL_END);
 405
 406   g_type_class_add_private (gobject_class, sizeof (GtkScalePrivate));
 407
 408   gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_SCALE_ACCESSIBLE);
 409 }
 410
 411 static void
 412 gtk_scale_orientation_notify (GtkRange         *range,
 413                               const GParamSpec *pspec)
 414 {
 415   GtkOrientation orientation;
 416
 417   orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (range));
 418   gtk_range_set_flippable (range,
 419                            orientation == GTK_ORIENTATION_HORIZONTAL);
 420 }
 421
 422 static void
 423 gtk_scale_init (GtkScale *scale)
 424 {
 425   GtkScalePrivate *priv;
 426   GtkRange *range = GTK_RANGE (scale);
 427   GtkStyleContext *context;
 428
 429   scale->priv = G_TYPE_INSTANCE_GET_PRIVATE (scale,
 430                                              GTK_TYPE_SCALE,
 431                                              GtkScalePrivate);
 432   priv = scale->priv;
 433
 434   gtk_widget_set_can_focus (GTK_WIDGET (scale), TRUE);
 435
 436   gtk_range_set_slider_size_fixed (range, TRUE);
 437
 438   _gtk_range_set_has_origin (range, TRUE);
 439
 440   priv->draw_value = TRUE;
 441   priv->value_pos = GTK_POS_TOP;
 442   priv->digits = 1;
 443   gtk_range_set_round_digits (range, priv->digits);
 444
 445   gtk_scale_orientation_notify (range, NULL);
 446   g_signal_connect (scale, "notify::orientation",
 447                     G_CALLBACK (gtk_scale_orientation_notify),
 448                     NULL);
 449
 450   context = gtk_widget_get_style_context (GTK_WIDGET (scale));
 451   gtk_style_context_add_class (context, GTK_STYLE_CLASS_SCALE);
 452 }
 453
 454 static void
 455 gtk_scale_set_property (GObject      *object,
 456                         guint         prop_id,
 457                         const GValue *value,
 458                         GParamSpec   *pspec)
 459 {
 460   GtkScale *scale;
 461
 462   scale = GTK_SCALE (object);
 463
 464   switch (prop_id)
 465     {
 466     case PROP_DIGITS:
 467       gtk_scale_set_digits (scale, g_value_get_int (value));
 468       break;
 469     case PROP_DRAW_VALUE:
 470       gtk_scale_set_draw_value (scale, g_value_get_boolean (value));
 471       break;
 472     case PROP_HAS_ORIGIN:
 473       gtk_scale_set_has_origin (scale, g_value_get_boolean (value));
 474       break;
 475     case PROP_VALUE_POS:
 476       gtk_scale_set_value_pos (scale, g_value_get_enum (value));
 477       break;
 478     default:
 479       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 480       break;
 481     }
 482 }
 483
 484 static void
 485 gtk_scale_get_property (GObject      *object,
 486                         guint         prop_id,
 487                         GValue       *value,
 488                         GParamSpec   *pspec)
 489 {
 490   GtkScale *scale = GTK_SCALE (object);
 491   GtkScalePrivate *priv = scale->priv;
 492
 493   switch (prop_id)
 494     {
 495     case PROP_DIGITS:
 496       g_value_set_int (value, priv->digits);
 497       break;
 498     case PROP_DRAW_VALUE:
 499       g_value_set_boolean (value, priv->draw_value);
 500       break;
 501     case PROP_HAS_ORIGIN:
 502       g_value_set_boolean (value, gtk_scale_get_has_origin (scale));
 503       break;
 504     case PROP_VALUE_POS:
 505       g_value_set_enum (value, priv->value_pos);
 506       break;
 507     default:
 508       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 509       break;
 510     }
 511 }
 512
 513 /**
 514  * gtk_scale_new:
 515  * @orientation: the scale's orientation.
 516  * @adjustment: (allow-none): the #GtkAdjustment which sets the range
 517  *              of the scale, or %NULL to create a new adjustment.
 518  *
 519  * Creates a new #GtkScale.
 520  *
 521  * Return value: a new #GtkScale
 522  *
 523  * Since: 3.0
 524  **/
 525 GtkWidget *
 526 gtk_scale_new (GtkOrientation  orientation,
 527                GtkAdjustment  *adjustment)
 528 {
 529   g_return_val_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment),
 530                         NULL);
 531
 532   return g_object_new (GTK_TYPE_SCALE,
 533                        "orientation", orientation,
 534                        "adjustment",  adjustment,
 535                        NULL);
 536 }
 537
 538 /**
 539  * gtk_scale_new_with_range:
 540  * @orientation: the scale's orientation.
 541  * @min: minimum value
 542  * @max: maximum value
 543  * @step: step increment (tick size) used with keyboard shortcuts
 544  *
 545  * Creates a new scale widget with the given orientation that lets the
 546  * user input a number between @min and @max (including @min and @max)
 547  * with the increment @step.  @step must be nonzero; it's the distance
 548  * the slider moves when using the arrow keys to adjust the scale
 549  * value.
 550  *
 551  * Note that the way in which the precision is derived works best if @step
 552  * is a power of ten. If the resulting precision is not suitable for your
 553  * needs, use gtk_scale_set_digits() to correct it.
 554  *
 555  * Return value: a new #GtkScale
 556  *
 557  * Since: 3.0
 558  */
 559 GtkWidget *
 560 gtk_scale_new_with_range (GtkOrientation orientation,
 561                           gdouble        min,
 562                           gdouble        max,
 563                           gdouble        step)
 564 {
 565   GtkAdjustment *adj;
 566   gint digits;
 567
 568   g_return_val_if_fail (min < max, NULL);
 569   g_return_val_if_fail (step != 0.0, NULL);
 570
 571   adj = gtk_adjustment_new (min, min, max, step, 10 * step, 0);
 572
 573   if (fabs (step) >= 1.0 || step == 0.0)
 574     {
 575       digits = 0;
 576     }
 577   else
 578     {
 579       digits = abs ((gint) floor (log10 (fabs (step))));
 580       if (digits > 5)
 581         digits = 5;
 582     }
 583
 584   return g_object_new (GTK_TYPE_SCALE,
 585                        "orientation", orientation,
 586                        "adjustment",  adj,
 587                        "digits",      digits,
 588                        NULL);
 589 }
 590
 591 /**
 592  * gtk_scale_set_digits:
 593  * @scale: a #GtkScale
 594  * @digits: the number of decimal places to display,
 595  *     e.g. use 1 to display 1.0, 2 to display 1.00, etc
 596  *
 597  * Sets the number of decimal places that are displayed in the value.
 598  * Also causes the value of the adjustment to be rounded off to this
 599  * number of digits, so the retrieved value matches the value the user saw.
 600  */
 601 void
 602 gtk_scale_set_digits (GtkScale *scale,
 603                       gint      digits)
 604 {
 605   GtkScalePrivate *priv;
 606   GtkRange *range;
 607
 608   g_return_if_fail (GTK_IS_SCALE (scale));
 609
 610   priv = scale->priv;
 611   range = GTK_RANGE (scale);
 612
 613   digits = CLAMP (digits, -1, MAX_DIGITS);
 614
 615   if (priv->digits != digits)
 616     {
 617       priv->digits = digits;
 618       if (priv->draw_value)
 619         gtk_range_set_round_digits (range, digits);
 620
 621       _gtk_scale_clear_layout (scale);
 622       gtk_widget_queue_resize (GTK_WIDGET (scale));
 623
 624       g_object_notify (G_OBJECT (scale), "digits");
 625     }
 626 }
 627
 628 /**
 629  * gtk_scale_get_digits:
 630  * @scale: a #GtkScale
 631  *
 632  * Gets the number of decimal places that are displayed in the value.
 633  *
 634  * Returns: the number of decimal places that are displayed
 635  */
 636 gint
 637 gtk_scale_get_digits (GtkScale *scale)
 638 {
 639   g_return_val_if_fail (GTK_IS_SCALE (scale), -1);
 640
 641   return scale->priv->digits;
 642 }
 643
 644 /**
 645  * gtk_scale_set_draw_value:
 646  * @scale: a #GtkScale
 647  * @draw_value: %TRUE to draw the value
 648  *
 649  * Specifies whether the current value is displayed as a string next
 650  * to the slider.
 651  */
 652 void
 653 gtk_scale_set_draw_value (GtkScale *scale,
 654                           gboolean  draw_value)
 655 {
 656   GtkScalePrivate *priv;
 657
 658   g_return_if_fail (GTK_IS_SCALE (scale));
 659
 660   priv = scale->priv;
 661
 662   draw_value = draw_value != FALSE;
 663
 664   if (priv->draw_value != draw_value)
 665     {
 666       priv->draw_value = draw_value;
 667       if (draw_value)
 668         gtk_range_set_round_digits (GTK_RANGE (scale), priv->digits);
 669       else
 670         gtk_range_set_round_digits (GTK_RANGE (scale), -1);
 671
 672       _gtk_scale_clear_layout (scale);
 673
 674       gtk_widget_queue_resize (GTK_WIDGET (scale));
 675
 676       g_object_notify (G_OBJECT (scale), "draw-value");
 677     }
 678 }
 679
 680 /**
 681  * gtk_scale_get_draw_value:
 682  * @scale: a #GtkScale
 683  *
 684  * Returns whether the current value is displayed as a string
 685  * next to the slider.
 686  *
 687  * Returns: whether the current value is displayed as a string
 688  */
 689 gboolean
 690 gtk_scale_get_draw_value (GtkScale *scale)
 691 {
 692   g_return_val_if_fail (GTK_IS_SCALE (scale), FALSE);
 693
 694   return scale->priv->draw_value;
 695 }
 696
 697 /**
 698  * gtk_scale_set_has_origin:
 699  * @scale: a #GtkScale
 700  * @has_origin: %TRUE if the scale has an origin
 701  *
 702  * If @has_origin is set to %TRUE (the default),
 703  * the scale will highlight the part of the scale
 704  * between the origin (bottom or left side) of the scale
 705  * and the current value.
 706  *
 707  * Since: 3.4
 708  */
 709 void
 710 gtk_scale_set_has_origin (GtkScale *scale,
 711                           gboolean  has_origin)
 712 {
 713   g_return_if_fail (GTK_IS_SCALE (scale));
 714
 715   has_origin = has_origin != FALSE;
 716
 717   if (_gtk_range_get_has_origin (GTK_RANGE (scale)) != has_origin)
 718     {
 719       _gtk_range_set_has_origin (GTK_RANGE (scale), has_origin);
 720
 721       gtk_widget_queue_draw (GTK_WIDGET (scale));
 722
 723       g_object_notify (G_OBJECT (scale), "has-origin");
 724     }
 725 }
 726
 727 /**
 728  * gtk_scale_get_has_origin:
 729  * @scale: a #GtkScale
 730  *
 731  * Returns whether the scale has an origin.
 732  *
 733  * Returns: %TRUE if the scale has an origin.
 734  *
 735  * Since: 3.4
 736  */
 737 gboolean
 738 gtk_scale_get_has_origin (GtkScale *scale)
 739 {
 740   g_return_val_if_fail (GTK_IS_SCALE (scale), FALSE);
 741
 742   return _gtk_range_get_has_origin (GTK_RANGE (scale));
 743 }
 744
 745 /**
 746  * gtk_scale_set_value_pos:
 747  * @scale: a #GtkScale
 748  * @pos: the position in which the current value is displayed
 749  *
 750  * Sets the position in which the current value is displayed.
 751  */
 752 void
 753 gtk_scale_set_value_pos (GtkScale        *scale,
 754                          GtkPositionType  pos)
 755 {
 756   GtkScalePrivate *priv;
 757   GtkWidget *widget;
 758
 759   g_return_if_fail (GTK_IS_SCALE (scale));
 760
 761   priv = scale->priv;
 762
 763   if (priv->value_pos != pos)
 764     {
 765       priv->value_pos = pos;
 766       widget = GTK_WIDGET (scale);
 767
 768       _gtk_scale_clear_layout (scale);
 769       if (gtk_widget_get_visible (widget) && gtk_widget_get_mapped (widget))
 770         gtk_widget_queue_resize (widget);
 771
 772       g_object_notify (G_OBJECT (scale), "value-pos");
 773     }
 774 }
 775
 776 /**
 777  * gtk_scale_get_value_pos:
 778  * @scale: a #GtkScale
 779  *
 780  * Gets the position in which the current value is displayed.
 781  *
 782  * Returns: the position in which the current value is displayed
 783  */
 784 GtkPositionType
 785 gtk_scale_get_value_pos (GtkScale *scale)
 786 {
 787   g_return_val_if_fail (GTK_IS_SCALE (scale), 0);
 788
 789   return scale->priv->value_pos;
 790 }
 791
 792 static void
 793 gtk_scale_get_range_border (GtkRange  *range,
 794                             GtkBorder *border)
 795 {
 796   GtkScalePrivate *priv;
 797   GtkWidget *widget;
 798   GtkScale *scale;
 799   gint w, h;
 800
 801   widget = GTK_WIDGET (range);
 802   scale = GTK_SCALE (range);
 803   priv = scale->priv;
 804
 805   _gtk_scale_get_value_size (scale, &w, &h);
 806
 807   border->left = 0;
 808   border->right = 0;
 809   border->top = 0;
 810   border->bottom = 0;
 811
 812   if (priv->draw_value)
 813     {
 814       gint value_spacing;
 815       gtk_widget_style_get (widget, "value-spacing", &value_spacing, NULL);
 816
 817       switch (priv->value_pos)
 818         {
 819         case GTK_POS_LEFT:
 820           border->left += w + value_spacing;
 821           break;
 822         case GTK_POS_RIGHT:
 823           border->right += w + value_spacing;
 824           break;
 825         case GTK_POS_TOP:
 826           border->top += h + value_spacing;
 827           break;
 828         case GTK_POS_BOTTOM:
 829           border->bottom += h + value_spacing;
 830           break;
 831         }
 832     }
 833
 834   if (priv->marks)
 835     {
 836       gint slider_width;
 837       gint value_spacing;
 838       gint n1, w1, h1, n2, w2, h2;
 839
 840       gtk_widget_style_get (widget,
 841                             "slider-width", &slider_width,
 842                             "value-spacing", &value_spacing,
 843                             NULL);
 844
 845
 846       gtk_scale_get_mark_label_size (scale, GTK_POS_TOP, &n1, &w1, &h1, &n2, &w2, &h2);
 847
 848       if (gtk_orientable_get_orientation (GTK_ORIENTABLE (scale)) == GTK_ORIENTATION_HORIZONTAL)
 849         {
 850           if (n1 > 0)
 851             border->top += h1 + value_spacing + slider_width / 2;
 852           if (n2 > 0)
 853             border->bottom += h2 + value_spacing + slider_width / 2;
 854         }
 855       else
 856         {
 857           if (n1 > 0)
 858             border->left += w1 + value_spacing + slider_width / 2;
 859           if (n2 > 0)
 860             border->right += w2 + value_spacing + slider_width / 2;
 861         }
 862     }
 863 }
 864
 865 /* FIXME this could actually be static at the moment. */
 866 void
 867 _gtk_scale_get_value_size (GtkScale *scale,
 868                            gint     *width,
 869                            gint     *height)
 870 {
 871   GtkScalePrivate *priv = scale->priv;
 872   GtkRange *range;
 873
 874   if (priv->draw_value)
 875     {
 876       GtkAdjustment *adjustment;
 877       PangoLayout *layout;
 878       PangoRectangle logical_rect;
 879       gchar *txt;
 880
 881       range = GTK_RANGE (scale);
 882
 883       layout = gtk_widget_create_pango_layout (GTK_WIDGET (scale), NULL);
 884       adjustment = gtk_range_get_adjustment (range);
 885
 886       txt = _gtk_scale_format_value (scale, gtk_adjustment_get_lower (adjustment));
 887       pango_layout_set_text (layout, txt, -1);
 888       g_free (txt);
 889
 890       pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
 891
 892       if (width)
 893         *width = logical_rect.width;
 894       if (height)
 895         *height = logical_rect.height;
 896
 897       txt = _gtk_scale_format_value (scale, gtk_adjustment_get_upper (adjustment));
 898       pango_layout_set_text (layout, txt, -1);
 899       g_free (txt);
 900
 901       pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
 902
 903       if (width)
 904         *width = MAX (*width, logical_rect.width);
 905       if (height)
 906         *height = MAX (*height, logical_rect.height);
 907
 908       g_object_unref (layout);
 909     }
 910   else
 911     {
 912       if (width)
 913         *width = 0;
 914       if (height)
 915         *height = 0;
 916     }
 917
 918 }
 919
 920 static void
 921 gtk_scale_get_mark_label_size (GtkScale        *scale,
 922                                GtkPositionType  position,
 923                                gint            *count1,
 924                                gint            *width1,
 925                                gint            *height1,
 926                                gint            *count2,
 927                                gint            *width2,
 928                                gint            *height2)
 929 {
 930   GtkScalePrivate *priv = scale->priv;
 931   PangoLayout *layout;
 932   PangoRectangle logical_rect;
 933   GSList *m;
 934   gint w, h;
 935
 936   *count1 = *count2 = 0;
 937   *width1 = *width2 = 0;
 938   *height1 = *height2 = 0;
 939
 940   layout = gtk_widget_create_pango_layout (GTK_WIDGET (scale), NULL);
 941
 942   for (m = priv->marks; m; m = m->next)
 943     {
 944       GtkScaleMark *mark = m->data;
 945
 946       if (mark->markup && *mark->markup)
 947         {
 948           pango_layout_set_markup (layout, mark->markup, -1);
 949           pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
 950
 951           w = logical_rect.width;
 952           h = logical_rect.height;
 953         }
 954       else
 955         {
 956           w = 0;
 957           h = 0;
 958         }
 959
 960       if (mark->position == position)
 961         {
 962           (*count1)++;
 963           *width1 = MAX (*width1, w);
 964           *height1 = MAX (*height1, h);
 965         }
 966       else
 967         {
 968           (*count2)++;
 969           *width2 = MAX (*width2, w);
 970           *height2 = MAX (*height2, h);
 971         }
 972     }
 973
 974   g_object_unref (layout);
 975 }
 976
 977 static void
 978 gtk_scale_style_updated (GtkWidget *widget)
 979 {
 980   gint slider_length;
 981   GtkRange *range;
 982
 983   range = GTK_RANGE (widget);
 984
 985   gtk_widget_style_get (widget,
 986                         "slider-length", &slider_length,
 987                         NULL);
 988
 989   gtk_range_set_min_slider_size (range, slider_length);
 990
 991   _gtk_scale_clear_layout (GTK_SCALE (widget));
 992
 993   GTK_WIDGET_CLASS (gtk_scale_parent_class)->style_updated (widget);
 994 }
 995
 996 static void
 997 gtk_scale_screen_changed (GtkWidget *widget,
 998                           GdkScreen *old_screen)
 999 {
1000   _gtk_scale_clear_layout (GTK_SCALE (widget));
1001 }
1002
1003 static void
1004 gtk_scale_get_preferred_width (GtkWidget *widget,
1005                                gint      *minimum,
1006                                gint      *natural)
1007 {
1008   GTK_WIDGET_CLASS (gtk_scale_parent_class)->get_preferred_width (widget, minimum, natural);
1009
1010   if (gtk_orientable_get_orientation (GTK_ORIENTABLE (widget)) == GTK_ORIENTATION_HORIZONTAL)
1011     {
1012       gint n1, w1, h1, n2, w2, h2;
1013       gint slider_length;
1014       gint w;
1015
1016       gtk_widget_style_get (widget, "slider-length", &slider_length, NULL);
1017
1018       gtk_scale_get_mark_label_size (GTK_SCALE (widget), GTK_POS_TOP, &n1, &w1, &h1, &n2, &w2, &h2);
1019
1020       w1 = (n1 - 1) * w1 + MAX (w1, slider_length);
1021       w2 = (n2 - 1) * w2 + MAX (w2, slider_length);
1022       w = MAX (w1, w2);
1023
1024       *minimum = MAX (*minimum, w);
1025       *natural = MAX (*natural, w);
1026     }
1027 }
1028
1029 static void
1030 gtk_scale_get_preferred_height (GtkWidget *widget,
1031                                 gint      *minimum,
1032                                 gint      *natural)
1033 {
1034   GTK_WIDGET_CLASS (gtk_scale_parent_class)->get_preferred_height (widget, minimum, natural);
1035
1036
1037   if (gtk_orientable_get_orientation (GTK_ORIENTABLE (widget)) == GTK_ORIENTATION_VERTICAL)
1038     {
1039       gint n1, w1, h1, n2, w2, h2;
1040       gint slider_length;
1041       gint h;
1042
1043       gtk_widget_style_get (widget, "slider-length", &slider_length, NULL);
1044
1045       gtk_scale_get_mark_label_size (GTK_SCALE (widget), GTK_POS_TOP, &n1, &w1, &h1, &n2, &w2, &h2);
1046       h1 = (n1 - 1) * h1 + MAX (h1, slider_length);
1047       h2 = (n2 - 1) * h1 + MAX (h2, slider_length);
1048       h = MAX (h1, h2);
1049
1050       *minimum = MAX (*minimum, h);
1051       *natural = MAX (*natural, h);
1052     }
1053 }
1054
1055 static gint
1056 find_next_pos (GtkWidget      *widget,
1057                GSList          *list,
1058                gint            *marks,
1059                GtkPositionType  pos,
1060                gint             match)
1061 {
1062   GtkAllocation allocation;
1063   GSList *m;
1064   gint i;
1065
1066   for (m = list->next, i = 1; m; m = m->next, i++)
1067     {
1068       GtkScaleMark *mark = m->data;
1069
1070       if (match == (mark->position == pos))
1071         return marks[i];
1072     }
1073
1074   gtk_widget_get_allocation (widget, &allocation);
1075   if (gtk_orientable_get_orientation (GTK_ORIENTABLE (widget)) == GTK_ORIENTATION_HORIZONTAL)
1076     return allocation.width;
1077   else
1078     return allocation.height;
1079 }
1080
1081 static gboolean
1082 gtk_scale_draw (GtkWidget *widget,
1083                 cairo_t   *cr)
1084 {
1085   GtkScale *scale = GTK_SCALE (widget);
1086   GtkScalePrivate *priv = scale->priv;
1087   GtkRange *range = GTK_RANGE (scale);
1088   GtkStyleContext *context;
1089   gint *marks;
1090   gint focus_padding;
1091   gint slider_width;
1092   gint value_spacing;
1093   gint min_sep = 4;
1094
1095   context = gtk_widget_get_style_context (widget);
1096   gtk_widget_style_get (widget,
1097                         "focus-padding", &focus_padding,
1098                         "slider-width", &slider_width,
1099                         "value-spacing", &value_spacing,
1100                         NULL);
1101
1102   /* We need to chain up _first_ so the various geometry members of
1103    * GtkRange struct are updated.
1104    */
1105   GTK_WIDGET_CLASS (gtk_scale_parent_class)->draw (widget, cr);
1106
1107   if (priv->marks)
1108     {
1109       GtkOrientation orientation;
1110       GdkRectangle range_rect;
1111       gint i;
1112       gint x1, x2, x3, y1, y2, y3;
1113       PangoLayout *layout;
1114       PangoRectangle logical_rect;
1115       GSList *m;
1116       gint min_pos_before, min_pos_after;
1117       gint min_pos, max_pos;
1118
1119       orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (range));
1120       _gtk_range_get_stop_positions (range, &marks);
1121       layout = gtk_widget_create_pango_layout (widget, NULL);
1122       gtk_range_get_range_rect (range, &range_rect);
1123
1124       min_pos_before = min_pos_after = 0;
1125
1126       for (m = priv->marks, i = 0; m; m = m->next, i++)
1127         {
1128           GtkScaleMark *mark = m->data;
1129
1130           if (orientation == GTK_ORIENTATION_HORIZONTAL)
1131             {
1132               x1 = marks[i];
1133               if (mark->position == GTK_POS_TOP)
1134                 {
1135                   y1 = range_rect.y;
1136                   y2 = y1 - slider_width / 2;
1137                   min_pos = min_pos_before;
1138                   max_pos = find_next_pos (widget, m, marks + i, GTK_POS_TOP, 1) - min_sep;
1139                 }
1140               else
1141                 {
1142                   y1 = range_rect.y + range_rect.height;
1143                   y2 = y1 + slider_width / 2;
1144                   min_pos = min_pos_after;
1145                   max_pos = find_next_pos (widget, m, marks + i, GTK_POS_BOTTOM, 1) - min_sep;
1146                 }
1147
1148               gtk_style_context_save (context);
1149               gtk_style_context_add_class (context, GTK_STYLE_CLASS_MARK);
1150
1151               gtk_render_line (context, cr, x1, y1, x1, y2);
1152
1153               if (mark->markup)
1154                 {
1155                   pango_layout_set_markup (layout, mark->markup, -1);
1156                   pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1157
1158                   x3 = x1 - logical_rect.width / 2;
1159                   if (x3 < min_pos)
1160                     x3 = min_pos;
1161                   if (x3 + logical_rect.width > max_pos)
1162                         x3 = max_pos - logical_rect.width;
1163                   if (x3 < 0)
1164                      x3 = 0;
1165                   if (mark->position == GTK_POS_TOP)
1166                     {
1167                       y3 = y2 - value_spacing - logical_rect.height;
1168                       min_pos_before = x3 + logical_rect.width + min_sep;
1169                     }
1170                   else
1171                     {
1172                       y3 = y2 + value_spacing;
1173                       min_pos_after = x3 + logical_rect.width + min_sep;
1174                     }
1175
1176                   gtk_render_layout (context, cr, x3, y3, layout);
1177                 }
1178
1179               gtk_style_context_restore (context);
1180             }
1181           else
1182             {
1183               if (mark->position == GTK_POS_TOP)
1184                 {
1185                   x1 = range_rect.x;
1186                   x2 = range_rect.x - slider_width / 2;
1187                   min_pos = min_pos_before;
1188                   max_pos = find_next_pos (widget, m, marks + i, GTK_POS_TOP, 1) - min_sep;
1189                 }
1190               else
1191                 {
1192                   x1 = range_rect.x + range_rect.width;
1193                   x2 = range_rect.x + range_rect.width + slider_width / 2;
1194                   min_pos = min_pos_after;
1195                   max_pos = find_next_pos (widget, m, marks + i, GTK_POS_BOTTOM, 1) - min_sep;
1196                 }
1197               y1 = marks[i];
1198
1199               gtk_style_context_save (context);
1200               gtk_style_context_add_class (context, GTK_STYLE_CLASS_MARK);
1201
1202               gtk_render_line (context, cr, x1, y1, x2, y1);
1203
1204               if (mark->markup)
1205                 {
1206                   pango_layout_set_markup (layout, mark->markup, -1);
1207                   pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1208
1209                   y3 = y1 - logical_rect.height / 2;
1210                   if (y3 < min_pos)
1211                     y3 = min_pos;
1212                   if (y3 + logical_rect.height > max_pos)
1213                     y3 = max_pos - logical_rect.height;
1214                   if (y3 < 0)
1215                     y3 = 0;
1216                   if (mark->position == GTK_POS_TOP)
1217                     {
1218                       x3 = x2 - value_spacing - logical_rect.width;
1219                       min_pos_before = y3 + logical_rect.height + min_sep;
1220                     }
1221                   else
1222                     {
1223                       x3 = x2 + value_spacing;
1224                       min_pos_after = y3 + logical_rect.height + min_sep;
1225                     }
1226
1227                   gtk_render_layout (context, cr, x3, y3, layout);
1228                 }
1229
1230               gtk_style_context_restore (context);
1231             }
1232         }
1233
1234       g_object_unref (layout);
1235       g_free (marks);
1236     }
1237
1238   if (priv->draw_value)
1239     {
1240       GtkAllocation allocation;
1241
1242       PangoLayout *layout;
1243       gint x, y;
1244
1245       layout = gtk_scale_get_layout (scale);
1246       gtk_scale_get_layout_offsets (scale, &x, &y);
1247       gtk_widget_get_allocation (widget, &allocation);
1248
1249       gtk_render_layout (context, cr,
1250                          x - allocation.x,
1251                          y - allocation.y,
1252                          layout);
1253     }
1254
1255   return FALSE;
1256 }
1257
1258 static void
1259 gtk_scale_real_get_layout_offsets (GtkScale *scale,
1260                                    gint     *x,
1261                                    gint     *y)
1262 {
1263   GtkScalePrivate *priv = scale->priv;
1264   GtkAllocation allocation;
1265   GtkWidget *widget = GTK_WIDGET (scale);
1266   GtkRange *range = GTK_RANGE (widget);
1267   GdkRectangle range_rect;
1268   PangoLayout *layout = gtk_scale_get_layout (scale);
1269   PangoRectangle logical_rect;
1270   gint slider_start, slider_end;
1271   gint value_spacing;
1272
1273   if (!layout)
1274     {
1275       *x = 0;
1276       *y = 0;
1277
1278       return;
1279     }
1280
1281   gtk_widget_style_get (widget, "value-spacing", &value_spacing, NULL);
1282
1283   pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1284
1285   gtk_widget_get_allocation (widget, &allocation);
1286   gtk_range_get_range_rect (range, &range_rect);
1287   gtk_range_get_slider_range (range,
1288                               &slider_start,
1289                               &slider_end);
1290
1291   if (gtk_orientable_get_orientation (GTK_ORIENTABLE (range)) == GTK_ORIENTATION_HORIZONTAL)
1292     {
1293       switch (priv->value_pos)
1294         {
1295         case GTK_POS_LEFT:
1296           *x = range_rect.x - value_spacing - logical_rect.width;
1297           *y = range_rect.y + (range_rect.height - logical_rect.height) / 2;
1298           break;
1299
1300         case GTK_POS_RIGHT:
1301           *x = range_rect.x + range_rect.width + value_spacing;
1302           *y = range_rect.y + (range_rect.height - logical_rect.height) / 2;
1303           break;
1304
1305         case GTK_POS_TOP:
1306           *x = slider_start + (slider_end - slider_start - logical_rect.width) / 2;
1307           *x = CLAMP (*x, 0, allocation.width - logical_rect.width);
1308           *y = range_rect.y - logical_rect.height - value_spacing;
1309           break;
1310
1311         case GTK_POS_BOTTOM:
1312           *x = slider_start + (slider_end - slider_start - logical_rect.width) / 2;
1313           *x = CLAMP (*x, 0, allocation.width - logical_rect.width);
1314           *y = range_rect.y + range_rect.height + value_spacing;
1315           break;
1316
1317         default:
1318           g_return_if_reached ();
1319           break;
1320         }
1321     }
1322   else
1323     {
1324       switch (priv->value_pos)
1325         {
1326         case GTK_POS_LEFT:
1327           *x = range_rect.x - logical_rect.width - value_spacing;
1328           *y = slider_start + (slider_end - slider_start - logical_rect.height) / 2;
1329           *y = CLAMP (*y, 0, allocation.height - logical_rect.height);
1330           break;
1331
1332         case GTK_POS_RIGHT:
1333           *x = range_rect.x + range_rect.width + value_spacing;
1334           *y = slider_start + (slider_end - slider_start - logical_rect.height) / 2;
1335           *y = CLAMP (*y, 0, allocation.height - logical_rect.height);
1336           break;
1337
1338         case GTK_POS_TOP:
1339           *x = range_rect.x + (range_rect.width - logical_rect.width) / 2;
1340           *y = range_rect.y - logical_rect.height - value_spacing;
1341           break;
1342
1343         case GTK_POS_BOTTOM:
1344           *x = range_rect.x + (range_rect.width - logical_rect.width) / 2;
1345           *y = range_rect.y + range_rect.height + value_spacing;
1346           break;
1347
1348         default:
1349           g_return_if_reached ();
1350         }
1351     }
1352
1353   *x += allocation.x;
1354   *y += allocation.y;
1355 }
1356
1357 /**
1358  * _gtk_scale_format_value:
1359  * @scale: a #GtkScale
1360  * @value: adjustment value
1361  *
1362  * Emits #GtkScale::format-value signal to format the value,
1363  * if no user signal handlers, falls back to a default format.
1364  *
1365  * Return value: formatted value
1366  */
1367 gchar*
1368 _gtk_scale_format_value (GtkScale *scale,
1369                          gdouble   value)
1370 {
1371   GtkScalePrivate *priv = scale->priv;
1372   gchar *fmt = NULL;
1373
1374   g_signal_emit (scale,
1375                  signals[FORMAT_VALUE],
1376                  0,
1377                  value,
1378                  &fmt);
1379
1380   if (fmt)
1381     return fmt;
1382   else
1383     return g_strdup_printf ("%0.*f", priv->digits, value);
1384 }
1385
1386 static void
1387 gtk_scale_finalize (GObject *object)
1388 {
1389   GtkScale *scale = GTK_SCALE (object);
1390
1391   _gtk_scale_clear_layout (scale);
1392   gtk_scale_clear_marks (scale);
1393
1394   G_OBJECT_CLASS (gtk_scale_parent_class)->finalize (object);
1395 }
1396
1397 /**
1398  * gtk_scale_get_layout:
1399  * @scale: A #GtkScale
1400  *
1401  * Gets the #PangoLayout used to display the scale. The returned
1402  * object is owned by the scale so does not need to be freed by
1403  * the caller.
1404  *
1405  * Return value: (transfer none): the #PangoLayout for this scale,
1406  *     or %NULL if the #GtkScale:draw-value property is %FALSE.
1407  *
1408  * Since: 2.4
1409  */
1410 PangoLayout *
1411 gtk_scale_get_layout (GtkScale *scale)
1412 {
1413   GtkScalePrivate *priv;
1414   gchar *txt;
1415
1416   g_return_val_if_fail (GTK_IS_SCALE (scale), NULL);
1417
1418   priv = scale->priv;
1419
1420   if (!priv->layout)
1421     {
1422       if (priv->draw_value)
1423         priv->layout = gtk_widget_create_pango_layout (GTK_WIDGET (scale), NULL);
1424     }
1425
1426   if (priv->draw_value)
1427     {
1428       txt = _gtk_scale_format_value (scale,
1429                                      gtk_adjustment_get_value (gtk_range_get_adjustment (GTK_RANGE (scale))));
1430       pango_layout_set_text (priv->layout, txt, -1);
1431       g_free (txt);
1432     }
1433
1434   return priv->layout;
1435 }
1436
1437 /**
1438  * gtk_scale_get_layout_offsets:
1439  * @scale: a #GtkScale
1440  * @x: (out) (allow-none): location to store X offset of layout, or %NULL
1441  * @y: (out) (allow-none): location to store Y offset of layout, or %NULL
1442  *
1443  * Obtains the coordinates where the scale will draw the
1444  * #PangoLayout representing the text in the scale. Remember
1445  * when using the #PangoLayout function you need to convert to
1446  * and from pixels using PANGO_PIXELS() or #PANGO_SCALE.
1447  *
1448  * If the #GtkScale:draw-value property is %FALSE, the return
1449  * values are undefined.
1450  *
1451  * Since: 2.4
1452  */
1453 void
1454 gtk_scale_get_layout_offsets (GtkScale *scale,
1455                               gint     *x,
1456                               gint     *y)
1457 {
1458   gint local_x = 0;
1459   gint local_y = 0;
1460
1461   g_return_if_fail (GTK_IS_SCALE (scale));
1462
1463   if (GTK_SCALE_GET_CLASS (scale)->get_layout_offsets)
1464     (GTK_SCALE_GET_CLASS (scale)->get_layout_offsets) (scale, &local_x, &local_y);
1465
1466   if (x)
1467     *x = local_x;
1468
1469   if (y)
1470     *y = local_y;
1471 }
1472
1473 void
1474 _gtk_scale_clear_layout (GtkScale *scale)
1475 {
1476   GtkScalePrivate *priv = scale->priv;
1477
1478   g_return_if_fail (GTK_IS_SCALE (scale));
1479
1480   if (priv->layout)
1481     {
1482       g_object_unref (priv->layout);
1483       priv->layout = NULL;
1484     }
1485 }
1486
1487 static void
1488 gtk_scale_mark_free (GtkScaleMark *mark)
1489 {
1490   g_free (mark->markup);
1491   g_free (mark);
1492 }
1493
1494 /**
1495  * gtk_scale_clear_marks:
1496  * @scale: a #GtkScale
1497  *
1498  * Removes any marks that have been added with gtk_scale_add_mark().
1499  *
1500  * Since: 2.16
1501  */
1502 void
1503 gtk_scale_clear_marks (GtkScale *scale)
1504 {
1505   GtkScalePrivate *priv;
1506   GtkStyleContext *context;
1507
1508   g_return_if_fail (GTK_IS_SCALE (scale));
1509
1510   priv = scale->priv;
1511
1512   g_slist_foreach (priv->marks, (GFunc)gtk_scale_mark_free, NULL);
1513   g_slist_free (priv->marks);
1514   priv->marks = NULL;
1515
1516   context = gtk_widget_get_style_context (GTK_WIDGET (scale));
1517   gtk_style_context_remove_class (context, GTK_STYLE_CLASS_SCALE_HAS_MARKS_BELOW);
1518   gtk_style_context_remove_class (context, GTK_STYLE_CLASS_SCALE_HAS_MARKS_ABOVE);
1519
1520   _gtk_range_set_stop_values (GTK_RANGE (scale), NULL, 0);
1521
1522   gtk_widget_queue_resize (GTK_WIDGET (scale));
1523 }
1524
1525 static gint
1526 compare_marks (gpointer a, gpointer b)
1527 {
1528   GtkScaleMark *ma, *mb;
1529
1530   ma = a; mb = b;
1531
1532   return (ma->value > mb->value) ? 1 : ((ma->value == mb->value) ? 0 : -1);
1533 }
1534
1535 /**
1536  * gtk_scale_add_mark:
1537  * @scale: a #GtkScale
1538  * @value: the value at which the mark is placed, must be between
1539  *   the lower and upper limits of the scales' adjustment
1540  * @position: where to draw the mark. For a horizontal scale, #GTK_POS_TOP
1541  *   and %GTK_POS_LEFT are drawn above the scale, anything else below.
1542  *   For a vertical scale, #GTK_POS_LEFT and %GTK_POS_TOP are drawn to
1543  *   the left of the scale, anything else to the right.
1544  * @markup: (allow-none): Text to be shown at the mark, using <link linkend="PangoMarkupFormat">Pango markup</link>, or %NULL
1545  *
1546  *
1547  * Adds a mark at @value.
1548  *
1549  * A mark is indicated visually by drawing a tick mark next to the scale,
1550  * and GTK+ makes it easy for the user to position the scale exactly at the
1551  * marks value.
1552  *
1553  * If @markup is not %NULL, text is shown next to the tick mark.
1554  *
1555  * To remove marks from a scale, use gtk_scale_clear_marks().
1556  *
1557  * Since: 2.16
1558  */
1559 void
1560 gtk_scale_add_mark (GtkScale        *scale,
1561                     gdouble          value,
1562                     GtkPositionType  position,
1563                     const gchar     *markup)
1564 {
1565   GtkScalePrivate *priv;
1566   GtkScaleMark *mark;
1567   GSList *m;
1568   gdouble *values;
1569   gint n, i;
1570   GtkStyleContext *context;
1571   int all_pos;
1572
1573   g_return_if_fail (GTK_IS_SCALE (scale));
1574
1575   priv = scale->priv;
1576
1577   mark = g_new (GtkScaleMark, 1);
1578   mark->value = value;
1579   mark->markup = g_strdup (markup);
1580   if (position == GTK_POS_LEFT ||
1581       position == GTK_POS_TOP)
1582     mark->position = GTK_POS_TOP;
1583   else
1584     mark->position = GTK_POS_BOTTOM;
1585
1586   priv->marks = g_slist_insert_sorted (priv->marks, mark,
1587                                        (GCompareFunc) compare_marks);
1588
1589 #define MARKS_ABOVE 1
1590 #define MARKS_BELOW 2
1591
1592   all_pos = 0;
1593   n = g_slist_length (priv->marks);
1594   values = g_new (gdouble, n);
1595   for (m = priv->marks, i = 0; m; m = m->next, i++)
1596     {
1597       mark = m->data;
1598       values[i] = mark->value;
1599       if (mark->position == GTK_POS_TOP)
1600         all_pos |= MARKS_ABOVE;
1601       else
1602         all_pos |= MARKS_BELOW;
1603     }
1604
1605   _gtk_range_set_stop_values (GTK_RANGE (scale), values, n);
1606
1607   g_free (values);
1608
1609   /* Set the style classes for the slider, so it could
1610    * point to the right direction when marks are present
1611    */
1612   context = gtk_widget_get_style_context (GTK_WIDGET (scale));
1613
1614   if (all_pos & MARKS_ABOVE)
1615     gtk_style_context_add_class (context, GTK_STYLE_CLASS_SCALE_HAS_MARKS_ABOVE);
1616   else
1617     gtk_style_context_remove_class (context, GTK_STYLE_CLASS_SCALE_HAS_MARKS_ABOVE);
1618   if (all_pos & MARKS_BELOW)
1619     gtk_style_context_add_class (context, GTK_STYLE_CLASS_SCALE_HAS_MARKS_BELOW);
1620   else
1621     gtk_style_context_remove_class (context, GTK_STYLE_CLASS_SCALE_HAS_MARKS_BELOW);
1622
1623   gtk_widget_queue_resize (GTK_WIDGET (scale));
1624 }
1625
1626 static GtkBuildableIface *parent_buildable_iface;
1627
1628 static void
1629 gtk_scale_buildable_interface_init (GtkBuildableIface *iface)
1630 {
1631   parent_buildable_iface = g_type_interface_peek_parent (iface);
1632   iface->custom_tag_start = gtk_scale_buildable_custom_tag_start;
1633   iface->custom_finished = gtk_scale_buildable_custom_finished;
1634 }
1635
1636 typedef struct
1637 {
1638   GtkScale *scale;
1639   GtkBuilder *builder;
1640   GSList *marks;
1641 } MarksSubparserData;
1642
1643 typedef struct
1644 {
1645   gdouble value;
1646   GtkPositionType position;
1647   GString *markup;
1648   gchar *context;
1649   gboolean translatable;
1650 } MarkData;
1651
1652 static void
1653 mark_data_free (MarkData *data)
1654 {
1655   g_string_free (data->markup, TRUE);
1656   g_free (data->context);
1657   g_slice_free (MarkData, data);
1658 }
1659
1660 static void
1661 marks_start_element (GMarkupParseContext *context,
1662                      const gchar         *element_name,
1663                      const gchar        **names,
1664                      const gchar        **values,
1665                      gpointer             user_data,
1666                      GError             **error)
1667 {
1668   MarksSubparserData *parser_data = (MarksSubparserData*)user_data;
1669   guint i;
1670   gint line_number, char_number;
1671
1672   if (strcmp (element_name, "marks") == 0)
1673    ;
1674   else if (strcmp (element_name, "mark") == 0)
1675     {
1676       gdouble value = 0;
1677       gboolean has_value = FALSE;
1678       GtkPositionType position = GTK_POS_BOTTOM;
1679       const gchar *msg_context = NULL;
1680       gboolean translatable = FALSE;
1681       MarkData *mark;
1682
1683       for (i = 0; names[i]; i++)
1684         {
1685           if (strcmp (names[i], "translatable") == 0)
1686             {
1687               if (!_gtk_builder_boolean_from_string (values[i], &translatable, error))
1688                 return;
1689             }
1690           else if (strcmp (names[i], "comments") == 0)
1691             {
1692               /* do nothing, comments are for translators */
1693             }
1694           else if (strcmp (names[i], "context") == 0)
1695             msg_context = values[i];
1696           else if (strcmp (names[i], "value") == 0)
1697             {
1698               GValue gvalue = G_VALUE_INIT;
1699
1700               if (!gtk_builder_value_from_string_type (parser_data->builder, G_TYPE_DOUBLE, values[i], &gvalue, error))
1701                 return;
1702
1703               value = g_value_get_double (&gvalue);
1704               has_value = TRUE;
1705             }
1706           else if (strcmp (names[i], "position") == 0)
1707             {
1708               GValue gvalue = G_VALUE_INIT;
1709
1710               if (!gtk_builder_value_from_string_type (parser_data->builder, GTK_TYPE_POSITION_TYPE, values[i], &gvalue, error))
1711                 return;
1712
1713               position = g_value_get_enum (&gvalue);
1714             }
1715           else
1716             {
1717               g_markup_parse_context_get_position (context,
1718                                                    &line_number,
1719                                                    &char_number);
1720               g_set_error (error,
1721                            GTK_BUILDER_ERROR,
1722                            GTK_BUILDER_ERROR_INVALID_ATTRIBUTE,
1723                            "%s:%d:%d '%s' is not a valid attribute of <%s>",
1724                            "<input>",
1725                            line_number, char_number, names[i], "mark");
1726               return;
1727             }
1728         }
1729
1730       if (!has_value)
1731         {
1732           g_markup_parse_context_get_position (context,
1733                                                &line_number,
1734                                                &char_number);
1735           g_set_error (error,
1736                        GTK_BUILDER_ERROR,
1737                        GTK_BUILDER_ERROR_MISSING_ATTRIBUTE,
1738                        "%s:%d:%d <%s> requires attribute \"%s\"",
1739                        "<input>",
1740                        line_number, char_number, "mark",
1741                        "value");
1742           return;
1743         }
1744
1745       mark = g_slice_new (MarkData);
1746       mark->value = value;
1747       if (position == GTK_POS_LEFT ||
1748           position == GTK_POS_TOP)
1749         mark->position = GTK_POS_TOP;
1750       else
1751         mark->position = GTK_POS_BOTTOM;
1752       mark->markup = g_string_new ("");
1753       mark->context = g_strdup (msg_context);
1754       mark->translatable = translatable;
1755
1756       parser_data->marks = g_slist_prepend (parser_data->marks, mark);
1757     }
1758   else
1759     {
1760       g_markup_parse_context_get_position (context,
1761                                            &line_number,
1762                                            &char_number);
1763       g_set_error (error,
1764                    GTK_BUILDER_ERROR,
1765                    GTK_BUILDER_ERROR_MISSING_ATTRIBUTE,
1766                    "%s:%d:%d unsupported tag for GtkScale: \"%s\"",
1767                    "<input>",
1768                    line_number, char_number, element_name);
1769       return;
1770     }
1771 }
1772
1773 static void
1774 marks_text (GMarkupParseContext  *context,
1775             const gchar          *text,
1776             gsize                 text_len,
1777             gpointer              user_data,
1778             GError              **error)
1779 {
1780   MarksSubparserData *data = (MarksSubparserData*)user_data;
1781
1782   if (strcmp (g_markup_parse_context_get_element (context), "mark") == 0)
1783     {
1784       MarkData *mark = data->marks->data;
1785
1786       g_string_append_len (mark->markup, text, text_len);
1787     }
1788 }
1789
1790 static const GMarkupParser marks_parser =
1791   {
1792     marks_start_element,
1793     NULL,
1794     marks_text,
1795   };
1796
1797
1798 static gboolean
1799 gtk_scale_buildable_custom_tag_start (GtkBuildable  *buildable,
1800                                       GtkBuilder    *builder,
1801                                       GObject       *child,
1802                                       const gchar   *tagname,
1803                                       GMarkupParser *parser,
1804                                       gpointer      *data)
1805 {
1806   MarksSubparserData *parser_data;
1807
1808   if (child)
1809     return FALSE;
1810
1811   if (strcmp (tagname, "marks") == 0)
1812     {
1813       parser_data = g_slice_new0 (MarksSubparserData);
1814       parser_data->scale = GTK_SCALE (buildable);
1815       parser_data->marks = NULL;
1816
1817       *parser = marks_parser;
1818       *data = parser_data;
1819       return TRUE;
1820     }
1821
1822   return parent_buildable_iface->custom_tag_start (buildable, builder, child,
1823                                                    tagname, parser, data);
1824 }
1825
1826 static void
1827 gtk_scale_buildable_custom_finished (GtkBuildable *buildable,
1828                                      GtkBuilder   *builder,
1829                                      GObject      *child,
1830                                      const gchar  *tagname,
1831                                      gpointer      user_data)
1832 {
1833   GtkScale *scale = GTK_SCALE (buildable);
1834   MarksSubparserData *marks_data;
1835
1836   if (strcmp (tagname, "marks") == 0)
1837     {
1838       GSList *m;
1839       gchar *markup;
1840
1841       marks_data = (MarksSubparserData *)user_data;
1842
1843       for (m = marks_data->marks; m; m = m->next)
1844         {
1845           MarkData *mdata = m->data;
1846
1847           if (mdata->translatable && mdata->markup->len)
1848             markup = _gtk_builder_parser_translate (gtk_builder_get_translation_domain (builder),
1849                                                     mdata->context,
1850                                                     mdata->markup->str);
1851           else
1852             markup = mdata->markup->str;
1853
1854           gtk_scale_add_mark (scale, mdata->value, mdata->position, markup);
1855
1856           mark_data_free (mdata);
1857         }
1858
1859       g_slist_free (marks_data->marks);
1860       g_slice_free (MarksSubparserData, marks_data);
1861     }
1862 }