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   GList       *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   GList *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                GList           *list,
1058                gint            *marks,
1059                GtkPositionType  pos)
1060 {
1061   GtkAllocation allocation;
1062   GList *m;
1063   gint i;
1064
1065   for (m = list->next, i = 1; m; m = m->next, i++)
1066     {
1067       GtkScaleMark *mark = m->data;
1068
1069       if (mark->position == pos)
1070         return marks[i];
1071     }
1072
1073   gtk_widget_get_allocation (widget, &allocation);
1074   if (gtk_orientable_get_orientation (GTK_ORIENTABLE (widget)) == GTK_ORIENTATION_HORIZONTAL)
1075     return allocation.width;
1076   else
1077     return allocation.height;
1078 }
1079
1080 static gboolean
1081 gtk_scale_draw (GtkWidget *widget,
1082                 cairo_t   *cr)
1083 {
1084   GtkScale *scale = GTK_SCALE (widget);
1085   GtkScalePrivate *priv = scale->priv;
1086   GtkRange *range = GTK_RANGE (scale);
1087   GtkStyleContext *context;
1088   gint *marks;
1089   gint focus_padding;
1090   gint slider_width;
1091   gint value_spacing;
1092   gint min_sep = 4;
1093
1094   context = gtk_widget_get_style_context (widget);
1095   gtk_widget_style_get (widget,
1096                         "focus-padding", &focus_padding,
1097                         "slider-width", &slider_width,
1098                         "value-spacing", &value_spacing,
1099                         NULL);
1100
1101   /* We need to chain up _first_ so the various geometry members of
1102    * GtkRange struct are updated.
1103    */
1104   GTK_WIDGET_CLASS (gtk_scale_parent_class)->draw (widget, cr);
1105
1106   if (priv->marks)
1107     {
1108       GtkOrientation orientation;
1109       GdkRectangle range_rect;
1110       gint i;
1111       gint x1, x2, x3, y1, y2, y3;
1112       PangoLayout *layout;
1113       PangoRectangle logical_rect;
1114       GList *m;
1115       gint min_pos_before, min_pos_after;
1116       gint min_pos, max_pos;
1117
1118       orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (range));
1119       _gtk_range_get_stop_positions (range, &marks);
1120       layout = gtk_widget_create_pango_layout (widget, NULL);
1121       gtk_range_get_range_rect (range, &range_rect);
1122
1123       min_pos_before = min_pos_after = 0;
1124
1125       for (m = priv->marks, i = 0; m; m = m->next, i++)
1126         {
1127           GtkScaleMark *mark = m->data;
1128
1129           if (orientation == GTK_ORIENTATION_HORIZONTAL)
1130             {
1131               x1 = marks[i];
1132               if (mark->position == GTK_POS_TOP)
1133                 {
1134                   y1 = range_rect.y;
1135                   y2 = y1 - slider_width / 2;
1136                   min_pos = min_pos_before;
1137                   max_pos = find_next_pos (widget, m, marks + i, GTK_POS_TOP) - min_sep;
1138                 }
1139               else
1140                 {
1141                   y1 = range_rect.y + range_rect.height;
1142                   y2 = y1 + slider_width / 2;
1143                   min_pos = min_pos_after;
1144                   max_pos = find_next_pos (widget, m, marks + i, GTK_POS_BOTTOM) - min_sep;
1145                 }
1146
1147               gtk_style_context_save (context);
1148               gtk_style_context_add_class (context, GTK_STYLE_CLASS_MARK);
1149
1150               gtk_render_line (context, cr, x1, y1, x1, y2);
1151
1152               if (mark->markup)
1153                 {
1154                   pango_layout_set_markup (layout, mark->markup, -1);
1155                   pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1156
1157                   x3 = x1 - logical_rect.width / 2;
1158                   if (x3 < min_pos)
1159                     x3 = min_pos;
1160                   if (x3 + logical_rect.width > max_pos)
1161                         x3 = max_pos - logical_rect.width;
1162                   if (x3 < 0)
1163                      x3 = 0;
1164                   if (mark->position == GTK_POS_TOP)
1165                     {
1166                       y3 = y2 - value_spacing - logical_rect.height;
1167                       min_pos_before = x3 + logical_rect.width + min_sep;
1168                     }
1169                   else
1170                     {
1171                       y3 = y2 + value_spacing;
1172                       min_pos_after = x3 + logical_rect.width + min_sep;
1173                     }
1174
1175                   gtk_render_layout (context, cr, x3, y3, layout);
1176                 }
1177
1178               gtk_style_context_restore (context);
1179             }
1180           else
1181             {
1182               if (mark->position == GTK_POS_TOP)
1183                 {
1184                   x1 = range_rect.x;
1185                   x2 = range_rect.x - slider_width / 2;
1186                   min_pos = min_pos_before;
1187                   max_pos = find_next_pos (widget, m, marks + i, GTK_POS_TOP) - min_sep;
1188                 }
1189               else
1190                 {
1191                   x1 = range_rect.x + range_rect.width;
1192                   x2 = range_rect.x + range_rect.width + slider_width / 2;
1193                   min_pos = min_pos_after;
1194                   max_pos = find_next_pos (widget, m, marks + i, GTK_POS_BOTTOM) - min_sep;
1195                 }
1196               y1 = marks[i];
1197
1198               gtk_style_context_save (context);
1199               gtk_style_context_add_class (context, GTK_STYLE_CLASS_MARK);
1200
1201               gtk_render_line (context, cr, x1, y1, x2, y1);
1202
1203               if (mark->markup)
1204                 {
1205                   pango_layout_set_markup (layout, mark->markup, -1);
1206                   pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1207
1208                   y3 = y1 - logical_rect.height / 2;
1209                   if (y3 < min_pos)
1210                     y3 = min_pos;
1211                   if (y3 + logical_rect.height > max_pos)
1212                     y3 = max_pos - logical_rect.height;
1213                   if (y3 < 0)
1214                     y3 = 0;
1215                   if (mark->position == GTK_POS_TOP)
1216                     {
1217                       x3 = x2 - value_spacing - logical_rect.width;
1218                       min_pos_before = y3 + logical_rect.height + min_sep;
1219                     }
1220                   else
1221                     {
1222                       x3 = x2 + value_spacing;
1223                       min_pos_after = y3 + logical_rect.height + min_sep;
1224                     }
1225
1226                   gtk_render_layout (context, cr, x3, y3, layout);
1227                 }
1228
1229               gtk_style_context_restore (context);
1230             }
1231         }
1232
1233       g_object_unref (layout);
1234       g_free (marks);
1235     }
1236
1237   if (priv->draw_value)
1238     {
1239       GtkAllocation allocation;
1240
1241       PangoLayout *layout;
1242       gint x, y;
1243
1244       layout = gtk_scale_get_layout (scale);
1245       gtk_scale_get_layout_offsets (scale, &x, &y);
1246       gtk_widget_get_allocation (widget, &allocation);
1247
1248       gtk_render_layout (context, cr,
1249                          x - allocation.x,
1250                          y - allocation.y,
1251                          layout);
1252     }
1253
1254   return FALSE;
1255 }
1256
1257 static void
1258 gtk_scale_real_get_layout_offsets (GtkScale *scale,
1259                                    gint     *x,
1260                                    gint     *y)
1261 {
1262   GtkScalePrivate *priv = scale->priv;
1263   GtkAllocation allocation;
1264   GtkWidget *widget = GTK_WIDGET (scale);
1265   GtkRange *range = GTK_RANGE (widget);
1266   GdkRectangle range_rect;
1267   PangoLayout *layout = gtk_scale_get_layout (scale);
1268   PangoRectangle logical_rect;
1269   gint slider_start, slider_end;
1270   gint value_spacing;
1271
1272   if (!layout)
1273     {
1274       *x = 0;
1275       *y = 0;
1276
1277       return;
1278     }
1279
1280   gtk_widget_style_get (widget, "value-spacing", &value_spacing, NULL);
1281
1282   pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1283
1284   gtk_widget_get_allocation (widget, &allocation);
1285   gtk_range_get_range_rect (range, &range_rect);
1286   gtk_range_get_slider_range (range,
1287                               &slider_start,
1288                               &slider_end);
1289
1290   if (gtk_orientable_get_orientation (GTK_ORIENTABLE (range)) == GTK_ORIENTATION_HORIZONTAL)
1291     {
1292       switch (priv->value_pos)
1293         {
1294         case GTK_POS_LEFT:
1295           *x = range_rect.x - value_spacing - logical_rect.width;
1296           *y = range_rect.y + (range_rect.height - logical_rect.height) / 2;
1297           break;
1298
1299         case GTK_POS_RIGHT:
1300           *x = range_rect.x + range_rect.width + value_spacing;
1301           *y = range_rect.y + (range_rect.height - logical_rect.height) / 2;
1302           break;
1303
1304         case GTK_POS_TOP:
1305           *x = slider_start + (slider_end - slider_start - logical_rect.width) / 2;
1306           *x = CLAMP (*x, 0, allocation.width - logical_rect.width);
1307           *y = range_rect.y - logical_rect.height - value_spacing;
1308           break;
1309
1310         case GTK_POS_BOTTOM:
1311           *x = slider_start + (slider_end - slider_start - logical_rect.width) / 2;
1312           *x = CLAMP (*x, 0, allocation.width - logical_rect.width);
1313           *y = range_rect.y + range_rect.height + value_spacing;
1314           break;
1315
1316         default:
1317           g_return_if_reached ();
1318           break;
1319         }
1320     }
1321   else
1322     {
1323       switch (priv->value_pos)
1324         {
1325         case GTK_POS_LEFT:
1326           *x = range_rect.x - logical_rect.width - value_spacing;
1327           *y = slider_start + (slider_end - slider_start - logical_rect.height) / 2;
1328           *y = CLAMP (*y, 0, allocation.height - logical_rect.height);
1329           break;
1330
1331         case GTK_POS_RIGHT:
1332           *x = range_rect.x + range_rect.width + value_spacing;
1333           *y = slider_start + (slider_end - slider_start - logical_rect.height) / 2;
1334           *y = CLAMP (*y, 0, allocation.height - logical_rect.height);
1335           break;
1336
1337         case GTK_POS_TOP:
1338           *x = range_rect.x + (range_rect.width - logical_rect.width) / 2;
1339           *y = range_rect.y - logical_rect.height - value_spacing;
1340           break;
1341
1342         case GTK_POS_BOTTOM:
1343           *x = range_rect.x + (range_rect.width - logical_rect.width) / 2;
1344           *y = range_rect.y + range_rect.height + value_spacing;
1345           break;
1346
1347         default:
1348           g_return_if_reached ();
1349         }
1350     }
1351
1352   *x += allocation.x;
1353   *y += allocation.y;
1354 }
1355
1356 /**
1357  * _gtk_scale_format_value:
1358  * @scale: a #GtkScale
1359  * @value: adjustment value
1360  *
1361  * Emits #GtkScale::format-value signal to format the value,
1362  * if no user signal handlers, falls back to a default format.
1363  *
1364  * Return value: formatted value
1365  */
1366 gchar*
1367 _gtk_scale_format_value (GtkScale *scale,
1368                          gdouble   value)
1369 {
1370   GtkScalePrivate *priv = scale->priv;
1371   gchar *fmt = NULL;
1372
1373   g_signal_emit (scale,
1374                  signals[FORMAT_VALUE],
1375                  0,
1376                  value,
1377                  &fmt);
1378
1379   if (fmt)
1380     return fmt;
1381   else
1382     return g_strdup_printf ("%0.*f", priv->digits, value);
1383 }
1384
1385 static void
1386 gtk_scale_finalize (GObject *object)
1387 {
1388   GtkScale *scale = GTK_SCALE (object);
1389
1390   _gtk_scale_clear_layout (scale);
1391   gtk_scale_clear_marks (scale);
1392
1393   G_OBJECT_CLASS (gtk_scale_parent_class)->finalize (object);
1394 }
1395
1396 /**
1397  * gtk_scale_get_layout:
1398  * @scale: A #GtkScale
1399  *
1400  * Gets the #PangoLayout used to display the scale. The returned
1401  * object is owned by the scale so does not need to be freed by
1402  * the caller.
1403  *
1404  * Return value: (transfer none): the #PangoLayout for this scale,
1405  *     or %NULL if the #GtkScale:draw-value property is %FALSE.
1406  *
1407  * Since: 2.4
1408  */
1409 PangoLayout *
1410 gtk_scale_get_layout (GtkScale *scale)
1411 {
1412   GtkScalePrivate *priv;
1413   gchar *txt;
1414
1415   g_return_val_if_fail (GTK_IS_SCALE (scale), NULL);
1416
1417   priv = scale->priv;
1418
1419   if (!priv->layout)
1420     {
1421       if (priv->draw_value)
1422         priv->layout = gtk_widget_create_pango_layout (GTK_WIDGET (scale), NULL);
1423     }
1424
1425   if (priv->draw_value)
1426     {
1427       txt = _gtk_scale_format_value (scale,
1428                                      gtk_adjustment_get_value (gtk_range_get_adjustment (GTK_RANGE (scale))));
1429       pango_layout_set_text (priv->layout, txt, -1);
1430       g_free (txt);
1431     }
1432
1433   return priv->layout;
1434 }
1435
1436 /**
1437  * gtk_scale_get_layout_offsets:
1438  * @scale: a #GtkScale
1439  * @x: (out) (allow-none): location to store X offset of layout, or %NULL
1440  * @y: (out) (allow-none): location to store Y offset of layout, or %NULL
1441  *
1442  * Obtains the coordinates where the scale will draw the
1443  * #PangoLayout representing the text in the scale. Remember
1444  * when using the #PangoLayout function you need to convert to
1445  * and from pixels using PANGO_PIXELS() or #PANGO_SCALE.
1446  *
1447  * If the #GtkScale:draw-value property is %FALSE, the return
1448  * values are undefined.
1449  *
1450  * Since: 2.4
1451  */
1452 void
1453 gtk_scale_get_layout_offsets (GtkScale *scale,
1454                               gint     *x,
1455                               gint     *y)
1456 {
1457   gint local_x = 0;
1458   gint local_y = 0;
1459
1460   g_return_if_fail (GTK_IS_SCALE (scale));
1461
1462   if (GTK_SCALE_GET_CLASS (scale)->get_layout_offsets)
1463     (GTK_SCALE_GET_CLASS (scale)->get_layout_offsets) (scale, &local_x, &local_y);
1464
1465   if (x)
1466     *x = local_x;
1467
1468   if (y)
1469     *y = local_y;
1470 }
1471
1472 void
1473 _gtk_scale_clear_layout (GtkScale *scale)
1474 {
1475   GtkScalePrivate *priv = scale->priv;
1476
1477   g_return_if_fail (GTK_IS_SCALE (scale));
1478
1479   if (priv->layout)
1480     {
1481       g_object_unref (priv->layout);
1482       priv->layout = NULL;
1483     }
1484 }
1485
1486 static void
1487 gtk_scale_mark_free (GtkScaleMark *mark)
1488 {
1489   g_free (mark->markup);
1490   g_free (mark);
1491 }
1492
1493 /**
1494  * gtk_scale_clear_marks:
1495  * @scale: a #GtkScale
1496  *
1497  * Removes any marks that have been added with gtk_scale_add_mark().
1498  *
1499  * Since: 2.16
1500  */
1501 void
1502 gtk_scale_clear_marks (GtkScale *scale)
1503 {
1504   GtkScalePrivate *priv;
1505   GtkStyleContext *context;
1506
1507   g_return_if_fail (GTK_IS_SCALE (scale));
1508
1509   priv = scale->priv;
1510
1511   g_list_foreach (priv->marks, (GFunc)gtk_scale_mark_free, NULL);
1512   g_list_free (priv->marks);
1513   priv->marks = NULL;
1514
1515   context = gtk_widget_get_style_context (GTK_WIDGET (scale));
1516   gtk_style_context_remove_class (context, GTK_STYLE_CLASS_SCALE_HAS_MARKS_BELOW);
1517   gtk_style_context_remove_class (context, GTK_STYLE_CLASS_SCALE_HAS_MARKS_ABOVE);
1518
1519   _gtk_range_set_stop_values (GTK_RANGE (scale), NULL, 0);
1520
1521   gtk_widget_queue_resize (GTK_WIDGET (scale));
1522 }
1523
1524 static gint
1525 compare_marks (gpointer a, gpointer b)
1526 {
1527   GtkScaleMark *ma, *mb;
1528
1529   ma = a; mb = b;
1530
1531   return (ma->value > mb->value) ? 1 : ((ma->value < mb->value) ? -1 : 0);
1532 }
1533
1534 /**
1535  * gtk_scale_add_mark:
1536  * @scale: a #GtkScale
1537  * @value: the value at which the mark is placed, must be between
1538  *   the lower and upper limits of the scales' adjustment
1539  * @position: where to draw the mark. For a horizontal scale, #GTK_POS_TOP
1540  *   and %GTK_POS_LEFT are drawn above the scale, anything else below.
1541  *   For a vertical scale, #GTK_POS_LEFT and %GTK_POS_TOP are drawn to
1542  *   the left of the scale, anything else to the right.
1543  * @markup: (allow-none): Text to be shown at the mark, using <link linkend="PangoMarkupFormat">Pango markup</link>, or %NULL
1544  *
1545  *
1546  * Adds a mark at @value.
1547  *
1548  * A mark is indicated visually by drawing a tick mark next to the scale,
1549  * and GTK+ makes it easy for the user to position the scale exactly at the
1550  * marks value.
1551  *
1552  * If @markup is not %NULL, text is shown next to the tick mark.
1553  *
1554  * To remove marks from a scale, use gtk_scale_clear_marks().
1555  *
1556  * Since: 2.16
1557  */
1558 void
1559 gtk_scale_add_mark (GtkScale        *scale,
1560                     gdouble          value,
1561                     GtkPositionType  position,
1562                     const gchar     *markup)
1563 {
1564   GtkScalePrivate *priv;
1565   GtkScaleMark *mark;
1566   GList *m;
1567   gdouble *values;
1568   gint n, i;
1569   GtkStyleContext *context;
1570   int all_pos;
1571
1572   g_return_if_fail (GTK_IS_SCALE (scale));
1573
1574   priv = scale->priv;
1575
1576   mark = g_new (GtkScaleMark, 1);
1577   mark->value = value;
1578   mark->markup = g_strdup (markup);
1579   if (position == GTK_POS_LEFT ||
1580       position == GTK_POS_TOP)
1581     mark->position = GTK_POS_TOP;
1582   else
1583     mark->position = GTK_POS_BOTTOM;
1584
1585   priv->marks = g_list_insert_sorted (priv->marks, mark,
1586                                       (GCompareFunc) compare_marks);
1587
1588 #define MARKS_ABOVE 1
1589 #define MARKS_BELOW 2
1590
1591   all_pos = 0;
1592   n = g_list_length (priv->marks);
1593   values = g_new (gdouble, n);
1594   for (m = priv->marks, i = 0; m; m = m->next, i++)
1595     {
1596       mark = m->data;
1597       values[i] = mark->value;
1598       if (mark->position == GTK_POS_TOP)
1599         all_pos |= MARKS_ABOVE;
1600       else
1601         all_pos |= MARKS_BELOW;
1602     }
1603
1604   _gtk_range_set_stop_values (GTK_RANGE (scale), values, n);
1605
1606   g_free (values);
1607
1608   /* Set the style classes for the slider, so it could
1609    * point to the right direction when marks are present
1610    */
1611   context = gtk_widget_get_style_context (GTK_WIDGET (scale));
1612
1613   if (all_pos & MARKS_ABOVE)
1614     gtk_style_context_add_class (context, GTK_STYLE_CLASS_SCALE_HAS_MARKS_ABOVE);
1615   else
1616     gtk_style_context_remove_class (context, GTK_STYLE_CLASS_SCALE_HAS_MARKS_ABOVE);
1617   if (all_pos & MARKS_BELOW)
1618     gtk_style_context_add_class (context, GTK_STYLE_CLASS_SCALE_HAS_MARKS_BELOW);
1619   else
1620     gtk_style_context_remove_class (context, GTK_STYLE_CLASS_SCALE_HAS_MARKS_BELOW);
1621
1622   gtk_widget_queue_resize (GTK_WIDGET (scale));
1623 }
1624
1625 static GtkBuildableIface *parent_buildable_iface;
1626
1627 static void
1628 gtk_scale_buildable_interface_init (GtkBuildableIface *iface)
1629 {
1630   parent_buildable_iface = g_type_interface_peek_parent (iface);
1631   iface->custom_tag_start = gtk_scale_buildable_custom_tag_start;
1632   iface->custom_finished = gtk_scale_buildable_custom_finished;
1633 }
1634
1635 typedef struct
1636 {
1637   GtkScale *scale;
1638   GtkBuilder *builder;
1639   GList *marks;
1640 } MarksSubparserData;
1641
1642 typedef struct
1643 {
1644   gdouble value;
1645   GtkPositionType position;
1646   GString *markup;
1647   gchar *context;
1648   gboolean translatable;
1649 } MarkData;
1650
1651 static void
1652 mark_data_free (MarkData *data)
1653 {
1654   g_string_free (data->markup, TRUE);
1655   g_free (data->context);
1656   g_slice_free (MarkData, data);
1657 }
1658
1659 static void
1660 marks_start_element (GMarkupParseContext *context,
1661                      const gchar         *element_name,
1662                      const gchar        **names,
1663                      const gchar        **values,
1664                      gpointer             user_data,
1665                      GError             **error)
1666 {
1667   MarksSubparserData *parser_data = (MarksSubparserData*)user_data;
1668   guint i;
1669   gint line_number, char_number;
1670
1671   if (strcmp (element_name, "marks") == 0)
1672    ;
1673   else if (strcmp (element_name, "mark") == 0)
1674     {
1675       gdouble value = 0;
1676       gboolean has_value = FALSE;
1677       GtkPositionType position = GTK_POS_BOTTOM;
1678       const gchar *msg_context = NULL;
1679       gboolean translatable = FALSE;
1680       MarkData *mark;
1681
1682       for (i = 0; names[i]; i++)
1683         {
1684           if (strcmp (names[i], "translatable") == 0)
1685             {
1686               if (!_gtk_builder_boolean_from_string (values[i], &translatable, error))
1687                 return;
1688             }
1689           else if (strcmp (names[i], "comments") == 0)
1690             {
1691               /* do nothing, comments are for translators */
1692             }
1693           else if (strcmp (names[i], "context") == 0)
1694             msg_context = values[i];
1695           else if (strcmp (names[i], "value") == 0)
1696             {
1697               GValue gvalue = G_VALUE_INIT;
1698
1699               if (!gtk_builder_value_from_string_type (parser_data->builder, G_TYPE_DOUBLE, values[i], &gvalue, error))
1700                 return;
1701
1702               value = g_value_get_double (&gvalue);
1703               has_value = TRUE;
1704             }
1705           else if (strcmp (names[i], "position") == 0)
1706             {
1707               GValue gvalue = G_VALUE_INIT;
1708
1709               if (!gtk_builder_value_from_string_type (parser_data->builder, GTK_TYPE_POSITION_TYPE, values[i], &gvalue, error))
1710                 return;
1711
1712               position = g_value_get_enum (&gvalue);
1713             }
1714           else
1715             {
1716               g_markup_parse_context_get_position (context,
1717                                                    &line_number,
1718                                                    &char_number);
1719               g_set_error (error,
1720                            GTK_BUILDER_ERROR,
1721                            GTK_BUILDER_ERROR_INVALID_ATTRIBUTE,
1722                            "%s:%d:%d '%s' is not a valid attribute of <%s>",
1723                            "<input>",
1724                            line_number, char_number, names[i], "mark");
1725               return;
1726             }
1727         }
1728
1729       if (!has_value)
1730         {
1731           g_markup_parse_context_get_position (context,
1732                                                &line_number,
1733                                                &char_number);
1734           g_set_error (error,
1735                        GTK_BUILDER_ERROR,
1736                        GTK_BUILDER_ERROR_MISSING_ATTRIBUTE,
1737                        "%s:%d:%d <%s> requires attribute \"%s\"",
1738                        "<input>",
1739                        line_number, char_number, "mark",
1740                        "value");
1741           return;
1742         }
1743
1744       mark = g_slice_new (MarkData);
1745       mark->value = value;
1746       if (position == GTK_POS_LEFT ||
1747           position == GTK_POS_TOP)
1748         mark->position = GTK_POS_TOP;
1749       else
1750         mark->position = GTK_POS_BOTTOM;
1751       mark->markup = g_string_new ("");
1752       mark->context = g_strdup (msg_context);
1753       mark->translatable = translatable;
1754
1755       parser_data->marks = g_list_prepend (parser_data->marks, mark);
1756     }
1757   else
1758     {
1759       g_markup_parse_context_get_position (context,
1760                                            &line_number,
1761                                            &char_number);
1762       g_set_error (error,
1763                    GTK_BUILDER_ERROR,
1764                    GTK_BUILDER_ERROR_MISSING_ATTRIBUTE,
1765                    "%s:%d:%d unsupported tag for GtkScale: \"%s\"",
1766                    "<input>",
1767                    line_number, char_number, element_name);
1768       return;
1769     }
1770 }
1771
1772 static void
1773 marks_text (GMarkupParseContext  *context,
1774             const gchar          *text,
1775             gsize                 text_len,
1776             gpointer              user_data,
1777             GError              **error)
1778 {
1779   MarksSubparserData *data = (MarksSubparserData*)user_data;
1780
1781   if (strcmp (g_markup_parse_context_get_element (context), "mark") == 0)
1782     {
1783       MarkData *mark = data->marks->data;
1784
1785       g_string_append_len (mark->markup, text, text_len);
1786     }
1787 }
1788
1789 static const GMarkupParser marks_parser =
1790   {
1791     marks_start_element,
1792     NULL,
1793     marks_text,
1794   };
1795
1796
1797 static gboolean
1798 gtk_scale_buildable_custom_tag_start (GtkBuildable  *buildable,
1799                                       GtkBuilder    *builder,
1800                                       GObject       *child,
1801                                       const gchar   *tagname,
1802                                       GMarkupParser *parser,
1803                                       gpointer      *data)
1804 {
1805   MarksSubparserData *parser_data;
1806
1807   if (child)
1808     return FALSE;
1809
1810   if (strcmp (tagname, "marks") == 0)
1811     {
1812       parser_data = g_slice_new0 (MarksSubparserData);
1813       parser_data->scale = GTK_SCALE (buildable);
1814       parser_data->marks = NULL;
1815
1816       *parser = marks_parser;
1817       *data = parser_data;
1818       return TRUE;
1819     }
1820
1821   return parent_buildable_iface->custom_tag_start (buildable, builder, child,
1822                                                    tagname, parser, data);
1823 }
1824
1825 static void
1826 gtk_scale_buildable_custom_finished (GtkBuildable *buildable,
1827                                      GtkBuilder   *builder,
1828                                      GObject      *child,
1829                                      const gchar  *tagname,
1830                                      gpointer      user_data)
1831 {
1832   GtkScale *scale = GTK_SCALE (buildable);
1833   MarksSubparserData *marks_data;
1834
1835   if (strcmp (tagname, "marks") == 0)
1836     {
1837       GList *m;
1838       gchar *markup;
1839
1840       marks_data = (MarksSubparserData *)user_data;
1841
1842       for (m = marks_data->marks; m; m = m->next)
1843         {
1844           MarkData *mdata = m->data;
1845
1846           if (mdata->translatable && mdata->markup->len)
1847             markup = _gtk_builder_parser_translate (gtk_builder_get_translation_domain (builder),
1848                                                     mdata->context,
1849                                                     mdata->markup->str);
1850           else
1851             markup = mdata->markup->str;
1852
1853           gtk_scale_add_mark (scale, mdata->value, mdata->position, markup);
1854
1855           mark_data_free (mdata);
1856         }
1857
1858       g_list_free (marks_data->marks);
1859       g_slice_free (MarksSubparserData, marks_data);
1860     }
1861 }