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   GtkScalePrivate *priv;
 714
 715   g_return_if_fail (GTK_IS_SCALE (scale));
 716
 717   priv = scale->priv;
 718
 719   has_origin = has_origin != FALSE;
 720
 721   if (_gtk_range_get_has_origin (GTK_RANGE (scale)) != has_origin)
 722     {
 723       _gtk_range_set_has_origin (GTK_RANGE (scale), has_origin);
 724
 725       gtk_widget_queue_draw (GTK_WIDGET (scale));
 726
 727       g_object_notify (G_OBJECT (scale), "has-origin");
 728     }
 729 }
 730
 731 /**
 732  * gtk_scale_get_has_origin:
 733  * @scale: a #GtkScale
 734  *
 735  * Returns whether the scale has an origin.
 736  *
 737  * Returns: %TRUE if the scale has an origin.
 738  *
 739  * Since: 3.4
 740  */
 741 gboolean
 742 gtk_scale_get_has_origin (GtkScale *scale)
 743 {
 744   g_return_val_if_fail (GTK_IS_SCALE (scale), FALSE);
 745
 746   return _gtk_range_get_has_origin (GTK_RANGE (scale));
 747 }
 748
 749 /**
 750  * gtk_scale_set_value_pos:
 751  * @scale: a #GtkScale
 752  * @pos: the position in which the current value is displayed
 753  *
 754  * Sets the position in which the current value is displayed.
 755  */
 756 void
 757 gtk_scale_set_value_pos (GtkScale        *scale,
 758                          GtkPositionType  pos)
 759 {
 760   GtkScalePrivate *priv;
 761   GtkWidget *widget;
 762
 763   g_return_if_fail (GTK_IS_SCALE (scale));
 764
 765   priv = scale->priv;
 766
 767   if (priv->value_pos != pos)
 768     {
 769       priv->value_pos = pos;
 770       widget = GTK_WIDGET (scale);
 771
 772       _gtk_scale_clear_layout (scale);
 773       if (gtk_widget_get_visible (widget) && gtk_widget_get_mapped (widget))
 774         gtk_widget_queue_resize (widget);
 775
 776       g_object_notify (G_OBJECT (scale), "value-pos");
 777     }
 778 }
 779
 780 /**
 781  * gtk_scale_get_value_pos:
 782  * @scale: a #GtkScale
 783  *
 784  * Gets the position in which the current value is displayed.
 785  *
 786  * Returns: the position in which the current value is displayed
 787  */
 788 GtkPositionType
 789 gtk_scale_get_value_pos (GtkScale *scale)
 790 {
 791   g_return_val_if_fail (GTK_IS_SCALE (scale), 0);
 792
 793   return scale->priv->value_pos;
 794 }
 795
 796 static void
 797 gtk_scale_get_range_border (GtkRange  *range,
 798                             GtkBorder *border)
 799 {
 800   GtkScalePrivate *priv;
 801   GtkWidget *widget;
 802   GtkScale *scale;
 803   gint w, h;
 804
 805   widget = GTK_WIDGET (range);
 806   scale = GTK_SCALE (range);
 807   priv = scale->priv;
 808
 809   _gtk_scale_get_value_size (scale, &w, &h);
 810
 811   border->left = 0;
 812   border->right = 0;
 813   border->top = 0;
 814   border->bottom = 0;
 815
 816   if (priv->draw_value)
 817     {
 818       gint value_spacing;
 819       gtk_widget_style_get (widget, "value-spacing", &value_spacing, NULL);
 820
 821       switch (priv->value_pos)
 822         {
 823         case GTK_POS_LEFT:
 824           border->left += w + value_spacing;
 825           break;
 826         case GTK_POS_RIGHT:
 827           border->right += w + value_spacing;
 828           break;
 829         case GTK_POS_TOP:
 830           border->top += h + value_spacing;
 831           break;
 832         case GTK_POS_BOTTOM:
 833           border->bottom += h + value_spacing;
 834           break;
 835         }
 836     }
 837
 838   if (priv->marks)
 839     {
 840       gint slider_width;
 841       gint value_spacing;
 842       gint n1, w1, h1, n2, w2, h2;
 843
 844       gtk_widget_style_get (widget,
 845                             "slider-width", &slider_width,
 846                             "value-spacing", &value_spacing,
 847                             NULL);
 848
 849
 850       gtk_scale_get_mark_label_size (scale, GTK_POS_TOP, &n1, &w1, &h1, &n2, &w2, &h2);
 851
 852       if (gtk_orientable_get_orientation (GTK_ORIENTABLE (scale)) == GTK_ORIENTATION_HORIZONTAL)
 853         {
 854           if (n1 > 0)
 855             border->top += h1 + value_spacing + slider_width / 2;
 856           if (n2 > 0)
 857             border->bottom += h2 + value_spacing + slider_width / 2;
 858         }
 859       else
 860         {
 861           if (n1 > 0)
 862             border->left += w1 + value_spacing + slider_width / 2;
 863           if (n2 > 0)
 864             border->right += w2 + value_spacing + slider_width / 2;
 865         }
 866     }
 867 }
 868
 869 /* FIXME this could actually be static at the moment. */
 870 void
 871 _gtk_scale_get_value_size (GtkScale *scale,
 872                            gint     *width,
 873                            gint     *height)
 874 {
 875   GtkScalePrivate *priv = scale->priv;
 876   GtkRange *range;
 877
 878   if (priv->draw_value)
 879     {
 880       GtkAdjustment *adjustment;
 881       PangoLayout *layout;
 882       PangoRectangle logical_rect;
 883       gchar *txt;
 884
 885       range = GTK_RANGE (scale);
 886
 887       layout = gtk_widget_create_pango_layout (GTK_WIDGET (scale), NULL);
 888       adjustment = gtk_range_get_adjustment (range);
 889
 890       txt = _gtk_scale_format_value (scale, gtk_adjustment_get_lower (adjustment));
 891       pango_layout_set_text (layout, txt, -1);
 892       g_free (txt);
 893
 894       pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
 895
 896       if (width)
 897         *width = logical_rect.width;
 898       if (height)
 899         *height = logical_rect.height;
 900
 901       txt = _gtk_scale_format_value (scale, gtk_adjustment_get_upper (adjustment));
 902       pango_layout_set_text (layout, txt, -1);
 903       g_free (txt);
 904
 905       pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
 906
 907       if (width)
 908         *width = MAX (*width, logical_rect.width);
 909       if (height)
 910         *height = MAX (*height, logical_rect.height);
 911
 912       g_object_unref (layout);
 913     }
 914   else
 915     {
 916       if (width)
 917         *width = 0;
 918       if (height)
 919         *height = 0;
 920     }
 921
 922 }
 923
 924 static void
 925 gtk_scale_get_mark_label_size (GtkScale        *scale,
 926                                GtkPositionType  position,
 927                                gint            *count1,
 928                                gint            *width1,
 929                                gint            *height1,
 930                                gint            *count2,
 931                                gint            *width2,
 932                                gint            *height2)
 933 {
 934   GtkScalePrivate *priv = scale->priv;
 935   PangoLayout *layout;
 936   PangoRectangle logical_rect;
 937   GSList *m;
 938   gint w, h;
 939
 940   *count1 = *count2 = 0;
 941   *width1 = *width2 = 0;
 942   *height1 = *height2 = 0;
 943
 944   layout = gtk_widget_create_pango_layout (GTK_WIDGET (scale), NULL);
 945
 946   for (m = priv->marks; m; m = m->next)
 947     {
 948       GtkScaleMark *mark = m->data;
 949
 950       if (mark->markup && *mark->markup)
 951         {
 952           pango_layout_set_markup (layout, mark->markup, -1);
 953           pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
 954
 955           w = logical_rect.width;
 956           h = logical_rect.height;
 957         }
 958       else
 959         {
 960           w = 0;
 961           h = 0;
 962         }
 963
 964       if (mark->position == position)
 965         {
 966           (*count1)++;
 967           *width1 = MAX (*width1, w);
 968           *height1 = MAX (*height1, h);
 969         }
 970       else
 971         {
 972           (*count2)++;
 973           *width2 = MAX (*width2, w);
 974           *height2 = MAX (*height2, h);
 975         }
 976     }
 977
 978   g_object_unref (layout);
 979 }
 980
 981 static void
 982 gtk_scale_style_updated (GtkWidget *widget)
 983 {
 984   gint slider_length;
 985   GtkRange *range;
 986
 987   range = GTK_RANGE (widget);
 988
 989   gtk_widget_style_get (widget,
 990                         "slider-length", &slider_length,
 991                         NULL);
 992
 993   gtk_range_set_min_slider_size (range, slider_length);
 994
 995   _gtk_scale_clear_layout (GTK_SCALE (widget));
 996
 997   GTK_WIDGET_CLASS (gtk_scale_parent_class)->style_updated (widget);
 998 }
 999
1000 static void
1001 gtk_scale_screen_changed (GtkWidget *widget,
1002                           GdkScreen *old_screen)
1003 {
1004   _gtk_scale_clear_layout (GTK_SCALE (widget));
1005 }
1006
1007 static void
1008 gtk_scale_get_preferred_width (GtkWidget *widget,
1009                                gint      *minimum,
1010                                gint      *natural)
1011 {
1012   GTK_WIDGET_CLASS (gtk_scale_parent_class)->get_preferred_width (widget, minimum, natural);
1013
1014   if (gtk_orientable_get_orientation (GTK_ORIENTABLE (widget)) == GTK_ORIENTATION_HORIZONTAL)
1015     {
1016       gint n1, w1, h1, n2, w2, h2;
1017       gint slider_length;
1018       gint w;
1019
1020       gtk_widget_style_get (widget, "slider-length", &slider_length, NULL);
1021
1022       gtk_scale_get_mark_label_size (GTK_SCALE (widget), GTK_POS_TOP, &n1, &w1, &h1, &n2, &w2, &h2);
1023
1024       w1 = (n1 - 1) * w1 + MAX (w1, slider_length);
1025       w2 = (n2 - 1) * w2 + MAX (w2, slider_length);
1026       w = MAX (w1, w2);
1027
1028       *minimum = MAX (*minimum, w);
1029       *natural = MAX (*natural, w);
1030     }
1031 }
1032
1033 static void
1034 gtk_scale_get_preferred_height (GtkWidget *widget,
1035                                 gint      *minimum,
1036                                 gint      *natural)
1037 {
1038   GTK_WIDGET_CLASS (gtk_scale_parent_class)->get_preferred_height (widget, minimum, natural);
1039
1040
1041   if (gtk_orientable_get_orientation (GTK_ORIENTABLE (widget)) == GTK_ORIENTATION_VERTICAL)
1042     {
1043       gint n1, w1, h1, n2, w2, h2;
1044       gint slider_length;
1045       gint h;
1046
1047       gtk_widget_style_get (widget, "slider-length", &slider_length, NULL);
1048
1049       gtk_scale_get_mark_label_size (GTK_SCALE (widget), GTK_POS_TOP, &n1, &w1, &h1, &n2, &w2, &h2);
1050       h1 = (n1 - 1) * h1 + MAX (h1, slider_length);
1051       h2 = (n2 - 1) * h1 + MAX (h2, slider_length);
1052       h = MAX (h1, h2);
1053
1054       *minimum = MAX (*minimum, h);
1055       *natural = MAX (*natural, h);
1056     }
1057 }
1058
1059 static gint
1060 find_next_pos (GtkWidget      *widget,
1061                GSList          *list,
1062                gint            *marks,
1063                GtkPositionType  pos,
1064                gint             match)
1065 {
1066   GtkAllocation allocation;
1067   GSList *m;
1068   gint i;
1069
1070   for (m = list->next, i = 1; m; m = m->next, i++)
1071     {
1072       GtkScaleMark *mark = m->data;
1073
1074       if (match == (mark->position == pos))
1075         return marks[i];
1076     }
1077
1078   gtk_widget_get_allocation (widget, &allocation);
1079   if (gtk_orientable_get_orientation (GTK_ORIENTABLE (widget)) == GTK_ORIENTATION_HORIZONTAL)
1080     return allocation.width;
1081   else
1082     return allocation.height;
1083 }
1084
1085 static gboolean
1086 gtk_scale_draw (GtkWidget *widget,
1087                 cairo_t   *cr)
1088 {
1089   GtkScale *scale = GTK_SCALE (widget);
1090   GtkScalePrivate *priv = scale->priv;
1091   GtkRange *range = GTK_RANGE (scale);
1092   GtkStateFlags state = 0;
1093   GtkStyleContext *context;
1094   gint *marks;
1095   gint focus_padding;
1096   gint slider_width;
1097   gint value_spacing;
1098   gint min_sep = 4;
1099
1100   context = gtk_widget_get_style_context (widget);
1101   gtk_widget_style_get (widget,
1102                         "focus-padding", &focus_padding,
1103                         "slider-width", &slider_width,
1104                         "value-spacing", &value_spacing,
1105                         NULL);
1106
1107   /* We need to chain up _first_ so the various geometry members of
1108    * GtkRange struct are updated.
1109    */
1110   GTK_WIDGET_CLASS (gtk_scale_parent_class)->draw (widget, cr);
1111
1112   if (!gtk_widget_is_sensitive (widget))
1113     state |= GTK_STATE_FLAG_INSENSITIVE;
1114
1115   if (priv->marks)
1116     {
1117       GtkOrientation orientation;
1118       GdkRectangle range_rect;
1119       gint i;
1120       gint x1, x2, x3, y1, y2, y3;
1121       PangoLayout *layout;
1122       PangoRectangle logical_rect;
1123       GSList *m;
1124       gint min_pos_before, min_pos_after;
1125       gint min_pos, max_pos;
1126
1127       orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (range));
1128       _gtk_range_get_stop_positions (range, &marks);
1129       layout = gtk_widget_create_pango_layout (widget, NULL);
1130       gtk_range_get_range_rect (range, &range_rect);
1131
1132       min_pos_before = min_pos_after = 0;
1133
1134       for (m = priv->marks, i = 0; m; m = m->next, i++)
1135         {
1136           GtkScaleMark *mark = m->data;
1137
1138           if (orientation == GTK_ORIENTATION_HORIZONTAL)
1139             {
1140               x1 = marks[i];
1141               if (mark->position == GTK_POS_TOP)
1142                 {
1143                   y1 = range_rect.y;
1144                   y2 = y1 - slider_width / 2;
1145                   min_pos = min_pos_before;
1146                   max_pos = find_next_pos (widget, m, marks + i, GTK_POS_TOP, 1) - min_sep;
1147                 }
1148               else
1149                 {
1150                   y1 = range_rect.y + range_rect.height;
1151                   y2 = y1 + slider_width / 2;
1152                   min_pos = min_pos_after;
1153                   max_pos = find_next_pos (widget, m, marks + i, GTK_POS_BOTTOM, 1) - min_sep;
1154                 }
1155
1156               gtk_style_context_save (context);
1157               gtk_style_context_add_class (context, GTK_STYLE_CLASS_MARK);
1158               gtk_style_context_set_state (context, state);
1159
1160               gtk_render_line (context, cr, x1, y1, x1, y2);
1161
1162               if (mark->markup)
1163                 {
1164                   pango_layout_set_markup (layout, mark->markup, -1);
1165                   pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1166
1167                   x3 = x1 - logical_rect.width / 2;
1168                   if (x3 < min_pos)
1169                     x3 = min_pos;
1170                   if (x3 + logical_rect.width > max_pos)
1171                         x3 = max_pos - logical_rect.width;
1172                   if (x3 < 0)
1173                      x3 = 0;
1174                   if (mark->position == GTK_POS_TOP)
1175                     {
1176                       y3 = y2 - value_spacing - logical_rect.height;
1177                       min_pos_before = x3 + logical_rect.width + min_sep;
1178                     }
1179                   else
1180                     {
1181                       y3 = y2 + value_spacing;
1182                       min_pos_after = x3 + logical_rect.width + min_sep;
1183                     }
1184
1185                   gtk_render_layout (context, cr, x3, y3, layout);
1186                 }
1187
1188               gtk_style_context_restore (context);
1189             }
1190           else
1191             {
1192               if (mark->position == GTK_POS_TOP)
1193                 {
1194                   x1 = range_rect.x;
1195                   x2 = range_rect.x - slider_width / 2;
1196                   min_pos = min_pos_before;
1197                   max_pos = find_next_pos (widget, m, marks + i, GTK_POS_TOP, 1) - min_sep;
1198                 }
1199               else
1200                 {
1201                   x1 = range_rect.x + range_rect.width;
1202                   x2 = range_rect.x + range_rect.width + slider_width / 2;
1203                   min_pos = min_pos_after;
1204                   max_pos = find_next_pos (widget, m, marks + i, GTK_POS_BOTTOM, 1) - min_sep;
1205                 }
1206               y1 = marks[i];
1207
1208               gtk_style_context_save (context);
1209               gtk_style_context_add_class (context, GTK_STYLE_CLASS_MARK);
1210               gtk_style_context_set_state (context, state);
1211
1212               gtk_render_line (context, cr, x1, y1, x2, y1);
1213
1214               if (mark->markup)
1215                 {
1216                   pango_layout_set_markup (layout, mark->markup, -1);
1217                   pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1218
1219                   y3 = y1 - logical_rect.height / 2;
1220                   if (y3 < min_pos)
1221                     y3 = min_pos;
1222                   if (y3 + logical_rect.height > max_pos)
1223                     y3 = max_pos - logical_rect.height;
1224                   if (y3 < 0)
1225                     y3 = 0;
1226                   if (mark->position == GTK_POS_TOP)
1227                     {
1228                       x3 = x2 - value_spacing - logical_rect.width;
1229                       min_pos_before = y3 + logical_rect.height + min_sep;
1230                     }
1231                   else
1232                     {
1233                       x3 = x2 + value_spacing;
1234                       min_pos_after = y3 + logical_rect.height + min_sep;
1235                     }
1236
1237                   gtk_render_layout (context, cr, x3, y3, layout);
1238                 }
1239
1240               gtk_style_context_restore (context);
1241             }
1242         }
1243
1244       g_object_unref (layout);
1245       g_free (marks);
1246     }
1247
1248   if (priv->draw_value)
1249     {
1250       GtkAllocation allocation;
1251
1252       PangoLayout *layout;
1253       gint x, y;
1254
1255       layout = gtk_scale_get_layout (scale);
1256       gtk_scale_get_layout_offsets (scale, &x, &y);
1257       gtk_widget_get_allocation (widget, &allocation);
1258
1259       gtk_render_layout (context, cr,
1260                          x - allocation.x,
1261                          y - allocation.y,
1262                          layout);
1263     }
1264
1265   return FALSE;
1266 }
1267
1268 static void
1269 gtk_scale_real_get_layout_offsets (GtkScale *scale,
1270                                    gint     *x,
1271                                    gint     *y)
1272 {
1273   GtkScalePrivate *priv = scale->priv;
1274   GtkAllocation allocation;
1275   GtkWidget *widget = GTK_WIDGET (scale);
1276   GtkRange *range = GTK_RANGE (widget);
1277   GdkRectangle range_rect;
1278   PangoLayout *layout = gtk_scale_get_layout (scale);
1279   PangoRectangle logical_rect;
1280   gint slider_start, slider_end;
1281   gint value_spacing;
1282
1283   if (!layout)
1284     {
1285       *x = 0;
1286       *y = 0;
1287
1288       return;
1289     }
1290
1291   gtk_widget_style_get (widget, "value-spacing", &value_spacing, NULL);
1292
1293   pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1294
1295   gtk_widget_get_allocation (widget, &allocation);
1296   gtk_range_get_range_rect (range, &range_rect);
1297   gtk_range_get_slider_range (range,
1298                               &slider_start,
1299                               &slider_end);
1300
1301   if (gtk_orientable_get_orientation (GTK_ORIENTABLE (range)) == GTK_ORIENTATION_HORIZONTAL)
1302     {
1303       switch (priv->value_pos)
1304         {
1305         case GTK_POS_LEFT:
1306           *x = range_rect.x - value_spacing - logical_rect.width;
1307           *y = range_rect.y + (range_rect.height - logical_rect.height) / 2;
1308           break;
1309
1310         case GTK_POS_RIGHT:
1311           *x = range_rect.x + range_rect.width + value_spacing;
1312           *y = range_rect.y + (range_rect.height - logical_rect.height) / 2;
1313           break;
1314
1315         case GTK_POS_TOP:
1316           *x = slider_start + (slider_end - slider_start - logical_rect.width) / 2;
1317           *x = CLAMP (*x, 0, allocation.width - logical_rect.width);
1318           *y = range_rect.y - logical_rect.height - value_spacing;
1319           break;
1320
1321         case GTK_POS_BOTTOM:
1322           *x = slider_start + (slider_end - slider_start - logical_rect.width) / 2;
1323           *x = CLAMP (*x, 0, allocation.width - logical_rect.width);
1324           *y = range_rect.y + range_rect.height + value_spacing;
1325           break;
1326
1327         default:
1328           g_return_if_reached ();
1329           break;
1330         }
1331     }
1332   else
1333     {
1334       switch (priv->value_pos)
1335         {
1336         case GTK_POS_LEFT:
1337           *x = range_rect.x - logical_rect.width - value_spacing;
1338           *y = slider_start + (slider_end - slider_start - logical_rect.height) / 2;
1339           *y = CLAMP (*y, 0, allocation.height - logical_rect.height);
1340           break;
1341
1342         case GTK_POS_RIGHT:
1343           *x = range_rect.x + range_rect.width + value_spacing;
1344           *y = slider_start + (slider_end - slider_start - logical_rect.height) / 2;
1345           *y = CLAMP (*y, 0, allocation.height - logical_rect.height);
1346           break;
1347
1348         case GTK_POS_TOP:
1349           *x = range_rect.x + (range_rect.width - logical_rect.width) / 2;
1350           *y = range_rect.y - logical_rect.height - value_spacing;
1351           break;
1352
1353         case GTK_POS_BOTTOM:
1354           *x = range_rect.x + (range_rect.width - logical_rect.width) / 2;
1355           *y = range_rect.y + range_rect.height + value_spacing;
1356           break;
1357
1358         default:
1359           g_return_if_reached ();
1360         }
1361     }
1362
1363   *x += allocation.x;
1364   *y += allocation.y;
1365 }
1366
1367 /**
1368  * _gtk_scale_format_value:
1369  * @scale: a #GtkScale
1370  * @value: adjustment value
1371  *
1372  * Emits #GtkScale::format-value signal to format the value,
1373  * if no user signal handlers, falls back to a default format.
1374  *
1375  * Return value: formatted value
1376  */
1377 gchar*
1378 _gtk_scale_format_value (GtkScale *scale,
1379                          gdouble   value)
1380 {
1381   GtkScalePrivate *priv = scale->priv;
1382   gchar *fmt = NULL;
1383
1384   g_signal_emit (scale,
1385                  signals[FORMAT_VALUE],
1386                  0,
1387                  value,
1388                  &fmt);
1389
1390   if (fmt)
1391     return fmt;
1392   else
1393     return g_strdup_printf ("%0.*f", priv->digits, value);
1394 }
1395
1396 static void
1397 gtk_scale_finalize (GObject *object)
1398 {
1399   GtkScale *scale = GTK_SCALE (object);
1400
1401   _gtk_scale_clear_layout (scale);
1402   gtk_scale_clear_marks (scale);
1403
1404   G_OBJECT_CLASS (gtk_scale_parent_class)->finalize (object);
1405 }
1406
1407 /**
1408  * gtk_scale_get_layout:
1409  * @scale: A #GtkScale
1410  *
1411  * Gets the #PangoLayout used to display the scale. The returned
1412  * object is owned by the scale so does not need to be freed by
1413  * the caller.
1414  *
1415  * Return value: (transfer none): the #PangoLayout for this scale,
1416  *     or %NULL if the #GtkScale:draw-value property is %FALSE.
1417  *
1418  * Since: 2.4
1419  */
1420 PangoLayout *
1421 gtk_scale_get_layout (GtkScale *scale)
1422 {
1423   GtkScalePrivate *priv;
1424   gchar *txt;
1425
1426   g_return_val_if_fail (GTK_IS_SCALE (scale), NULL);
1427
1428   priv = scale->priv;
1429
1430   if (!priv->layout)
1431     {
1432       if (priv->draw_value)
1433         priv->layout = gtk_widget_create_pango_layout (GTK_WIDGET (scale), NULL);
1434     }
1435
1436   if (priv->draw_value)
1437     {
1438       txt = _gtk_scale_format_value (scale,
1439                                      gtk_adjustment_get_value (gtk_range_get_adjustment (GTK_RANGE (scale))));
1440       pango_layout_set_text (priv->layout, txt, -1);
1441       g_free (txt);
1442     }
1443
1444   return priv->layout;
1445 }
1446
1447 /**
1448  * gtk_scale_get_layout_offsets:
1449  * @scale: a #GtkScale
1450  * @x: (out) (allow-none): location to store X offset of layout, or %NULL
1451  * @y: (out) (allow-none): location to store Y offset of layout, or %NULL
1452  *
1453  * Obtains the coordinates where the scale will draw the
1454  * #PangoLayout representing the text in the scale. Remember
1455  * when using the #PangoLayout function you need to convert to
1456  * and from pixels using PANGO_PIXELS() or #PANGO_SCALE.
1457  *
1458  * If the #GtkScale:draw-value property is %FALSE, the return
1459  * values are undefined.
1460  *
1461  * Since: 2.4
1462  */
1463 void
1464 gtk_scale_get_layout_offsets (GtkScale *scale,
1465                               gint     *x,
1466                               gint     *y)
1467 {
1468   gint local_x = 0;
1469   gint local_y = 0;
1470
1471   g_return_if_fail (GTK_IS_SCALE (scale));
1472
1473   if (GTK_SCALE_GET_CLASS (scale)->get_layout_offsets)
1474     (GTK_SCALE_GET_CLASS (scale)->get_layout_offsets) (scale, &local_x, &local_y);
1475
1476   if (x)
1477     *x = local_x;
1478
1479   if (y)
1480     *y = local_y;
1481 }
1482
1483 void
1484 _gtk_scale_clear_layout (GtkScale *scale)
1485 {
1486   GtkScalePrivate *priv = scale->priv;
1487
1488   g_return_if_fail (GTK_IS_SCALE (scale));
1489
1490   if (priv->layout)
1491     {
1492       g_object_unref (priv->layout);
1493       priv->layout = NULL;
1494     }
1495 }
1496
1497 static void
1498 gtk_scale_mark_free (GtkScaleMark *mark)
1499 {
1500   g_free (mark->markup);
1501   g_free (mark);
1502 }
1503
1504 /**
1505  * gtk_scale_clear_marks:
1506  * @scale: a #GtkScale
1507  *
1508  * Removes any marks that have been added with gtk_scale_add_mark().
1509  *
1510  * Since: 2.16
1511  */
1512 void
1513 gtk_scale_clear_marks (GtkScale *scale)
1514 {
1515   GtkScalePrivate *priv;
1516   GtkStyleContext *context;
1517
1518   g_return_if_fail (GTK_IS_SCALE (scale));
1519
1520   priv = scale->priv;
1521
1522   g_slist_foreach (priv->marks, (GFunc)gtk_scale_mark_free, NULL);
1523   g_slist_free (priv->marks);
1524   priv->marks = NULL;
1525
1526   context = gtk_widget_get_style_context (GTK_WIDGET (scale));
1527   gtk_style_context_remove_class (context, GTK_STYLE_CLASS_SCALE_HAS_MARKS_BELOW);
1528   gtk_style_context_remove_class (context, GTK_STYLE_CLASS_SCALE_HAS_MARKS_ABOVE);
1529
1530   _gtk_range_set_stop_values (GTK_RANGE (scale), NULL, 0);
1531
1532   gtk_widget_queue_resize (GTK_WIDGET (scale));
1533 }
1534
1535 static gint
1536 compare_marks (gpointer a, gpointer b)
1537 {
1538   GtkScaleMark *ma, *mb;
1539
1540   ma = a; mb = b;
1541
1542   return (gint) (ma->value - mb->value);
1543 }
1544
1545 /**
1546  * gtk_scale_add_mark:
1547  * @scale: a #GtkScale
1548  * @value: the value at which the mark is placed, must be between
1549  *   the lower and upper limits of the scales' adjustment
1550  * @position: where to draw the mark. For a horizontal scale, #GTK_POS_TOP
1551  *   and %GTK_POS_LEFT are drawn above the scale, anything else below.
1552  *   For a vertical scale, #GTK_POS_LEFT and %GTK_POS_TOP are drawn to
1553  *   the left of the scale, anything else to the right.
1554  * @markup: (allow-none): Text to be shown at the mark, using <link linkend="PangoMarkupFormat">Pango markup</link>, or %NULL
1555  *
1556  *
1557  * Adds a mark at @value.
1558  *
1559  * A mark is indicated visually by drawing a tick mark next to the scale,
1560  * and GTK+ makes it easy for the user to position the scale exactly at the
1561  * marks value.
1562  *
1563  * If @markup is not %NULL, text is shown next to the tick mark.
1564  *
1565  * To remove marks from a scale, use gtk_scale_clear_marks().
1566  *
1567  * Since: 2.16
1568  */
1569 void
1570 gtk_scale_add_mark (GtkScale        *scale,
1571                     gdouble          value,
1572                     GtkPositionType  position,
1573                     const gchar     *markup)
1574 {
1575   GtkScalePrivate *priv;
1576   GtkScaleMark *mark;
1577   GSList *m;
1578   gdouble *values;
1579   gint n, i;
1580   GtkStyleContext *context;
1581   int all_pos;
1582
1583   g_return_if_fail (GTK_IS_SCALE (scale));
1584
1585   priv = scale->priv;
1586
1587   mark = g_new (GtkScaleMark, 1);
1588   mark->value = value;
1589   mark->markup = g_strdup (markup);
1590   if (position == GTK_POS_LEFT ||
1591       position == GTK_POS_TOP)
1592     mark->position = GTK_POS_TOP;
1593   else
1594     mark->position = GTK_POS_BOTTOM;
1595
1596   priv->marks = g_slist_insert_sorted (priv->marks, mark,
1597                                        (GCompareFunc) compare_marks);
1598
1599 #define MARKS_ABOVE 1
1600 #define MARKS_BELOW 2
1601
1602   all_pos = 0;
1603   n = g_slist_length (priv->marks);
1604   values = g_new (gdouble, n);
1605   for (m = priv->marks, i = 0; m; m = m->next, i++)
1606     {
1607       mark = m->data;
1608       values[i] = mark->value;
1609       if (mark->position == GTK_POS_TOP)
1610         all_pos |= MARKS_ABOVE;
1611       else
1612         all_pos |= MARKS_BELOW;
1613     }
1614
1615   _gtk_range_set_stop_values (GTK_RANGE (scale), values, n);
1616
1617   g_free (values);
1618
1619   /* Set the style classes for the slider, so it could
1620    * point to the right direction when marks are present
1621    */
1622   context = gtk_widget_get_style_context (GTK_WIDGET (scale));
1623
1624   if (all_pos & MARKS_ABOVE)
1625     gtk_style_context_add_class (context, GTK_STYLE_CLASS_SCALE_HAS_MARKS_ABOVE);
1626   else
1627     gtk_style_context_remove_class (context, GTK_STYLE_CLASS_SCALE_HAS_MARKS_ABOVE);
1628   if (all_pos & MARKS_BELOW)
1629     gtk_style_context_add_class (context, GTK_STYLE_CLASS_SCALE_HAS_MARKS_BELOW);
1630   else
1631     gtk_style_context_remove_class (context, GTK_STYLE_CLASS_SCALE_HAS_MARKS_BELOW);
1632
1633   gtk_widget_queue_resize (GTK_WIDGET (scale));
1634 }
1635
1636 static GtkBuildableIface *parent_buildable_iface;
1637
1638 static void
1639 gtk_scale_buildable_interface_init (GtkBuildableIface *iface)
1640 {
1641   parent_buildable_iface = g_type_interface_peek_parent (iface);
1642   iface->custom_tag_start = gtk_scale_buildable_custom_tag_start;
1643   iface->custom_finished = gtk_scale_buildable_custom_finished;
1644 }
1645
1646 typedef struct
1647 {
1648   GtkScale *scale;
1649   GtkBuilder *builder;
1650   GSList *marks;
1651 } MarksSubparserData;
1652
1653 typedef struct
1654 {
1655   gdouble value;
1656   GtkPositionType position;
1657   GString *markup;
1658   gchar *context;
1659   gboolean translatable;
1660 } MarkData;
1661
1662 static void
1663 mark_data_free (MarkData *data)
1664 {
1665   g_string_free (data->markup, TRUE);
1666   g_free (data->context);
1667   g_slice_free (MarkData, data);
1668 }
1669
1670 static void
1671 marks_start_element (GMarkupParseContext *context,
1672                      const gchar         *element_name,
1673                      const gchar        **names,
1674                      const gchar        **values,
1675                      gpointer             user_data,
1676                      GError             **error)
1677 {
1678   MarksSubparserData *parser_data = (MarksSubparserData*)user_data;
1679   guint i;
1680   gint line_number, char_number;
1681
1682   if (strcmp (element_name, "marks") == 0)
1683    ;
1684   else if (strcmp (element_name, "mark") == 0)
1685     {
1686       gdouble value = 0;
1687       gboolean has_value = FALSE;
1688       GtkPositionType position = GTK_POS_BOTTOM;
1689       const gchar *msg_context = NULL;
1690       gboolean translatable = FALSE;
1691       MarkData *mark;
1692
1693       for (i = 0; names[i]; i++)
1694         {
1695           if (strcmp (names[i], "translatable") == 0)
1696             {
1697               if (!_gtk_builder_boolean_from_string (values[i], &translatable, error))
1698                 return;
1699             }
1700           else if (strcmp (names[i], "comments") == 0)
1701             {
1702               /* do nothing, comments are for translators */
1703             }
1704           else if (strcmp (names[i], "context") == 0)
1705             msg_context = values[i];
1706           else if (strcmp (names[i], "value") == 0)
1707             {
1708               GValue gvalue = G_VALUE_INIT;
1709
1710               if (!gtk_builder_value_from_string_type (parser_data->builder, G_TYPE_DOUBLE, values[i], &gvalue, error))
1711                 return;
1712
1713               value = g_value_get_double (&gvalue);
1714               has_value = TRUE;
1715             }
1716           else if (strcmp (names[i], "position") == 0)
1717             {
1718               GValue gvalue = G_VALUE_INIT;
1719
1720               if (!gtk_builder_value_from_string_type (parser_data->builder, GTK_TYPE_POSITION_TYPE, values[i], &gvalue, error))
1721                 return;
1722
1723               position = g_value_get_enum (&gvalue);
1724             }
1725           else
1726             {
1727               g_markup_parse_context_get_position (context,
1728                                                    &line_number,
1729                                                    &char_number);
1730               g_set_error (error,
1731                            GTK_BUILDER_ERROR,
1732                            GTK_BUILDER_ERROR_INVALID_ATTRIBUTE,
1733                            "%s:%d:%d '%s' is not a valid attribute of <%s>",
1734                            "<input>",
1735                            line_number, char_number, names[i], "mark");
1736               return;
1737             }
1738         }
1739
1740       if (!has_value)
1741         {
1742           g_markup_parse_context_get_position (context,
1743                                                &line_number,
1744                                                &char_number);
1745           g_set_error (error,
1746                        GTK_BUILDER_ERROR,
1747                        GTK_BUILDER_ERROR_MISSING_ATTRIBUTE,
1748                        "%s:%d:%d <%s> requires attribute \"%s\"",
1749                        "<input>",
1750                        line_number, char_number, "mark",
1751                        "value");
1752           return;
1753         }
1754
1755       mark = g_slice_new (MarkData);
1756       mark->value = value;
1757       if (position == GTK_POS_LEFT ||
1758           position == GTK_POS_TOP)
1759         mark->position = GTK_POS_TOP;
1760       else
1761         mark->position = GTK_POS_BOTTOM;
1762       mark->markup = g_string_new ("");
1763       mark->context = g_strdup (msg_context);
1764       mark->translatable = translatable;
1765
1766       parser_data->marks = g_slist_prepend (parser_data->marks, mark);
1767     }
1768   else
1769     {
1770       g_markup_parse_context_get_position (context,
1771                                            &line_number,
1772                                            &char_number);
1773       g_set_error (error,
1774                    GTK_BUILDER_ERROR,
1775                    GTK_BUILDER_ERROR_MISSING_ATTRIBUTE,
1776                    "%s:%d:%d unsupported tag for GtkScale: \"%s\"",
1777                    "<input>",
1778                    line_number, char_number, element_name);
1779       return;
1780     }
1781 }
1782
1783 static void
1784 marks_text (GMarkupParseContext  *context,
1785             const gchar          *text,
1786             gsize                 text_len,
1787             gpointer              user_data,
1788             GError              **error)
1789 {
1790   MarksSubparserData *data = (MarksSubparserData*)user_data;
1791
1792   if (strcmp (g_markup_parse_context_get_element (context), "mark") == 0)
1793     {
1794       MarkData *mark = data->marks->data;
1795
1796       g_string_append_len (mark->markup, text, text_len);
1797     }
1798 }
1799
1800 static const GMarkupParser marks_parser =
1801   {
1802     marks_start_element,
1803     NULL,
1804     marks_text,
1805   };
1806
1807
1808 static gboolean
1809 gtk_scale_buildable_custom_tag_start (GtkBuildable  *buildable,
1810                                       GtkBuilder    *builder,
1811                                       GObject       *child,
1812                                       const gchar   *tagname,
1813                                       GMarkupParser *parser,
1814                                       gpointer      *data)
1815 {
1816   MarksSubparserData *parser_data;
1817
1818   if (child)
1819     return FALSE;
1820
1821   if (strcmp (tagname, "marks") == 0)
1822     {
1823       parser_data = g_slice_new0 (MarksSubparserData);
1824       parser_data->scale = GTK_SCALE (buildable);
1825       parser_data->marks = NULL;
1826
1827       *parser = marks_parser;
1828       *data = parser_data;
1829       return TRUE;
1830     }
1831
1832   return parent_buildable_iface->custom_tag_start (buildable, builder, child,
1833                                                    tagname, parser, data);
1834 }
1835
1836 static void
1837 gtk_scale_buildable_custom_finished (GtkBuildable *buildable,
1838                                      GtkBuilder   *builder,
1839                                      GObject      *child,
1840                                      const gchar  *tagname,
1841                                      gpointer      user_data)
1842 {
1843   GtkScale *scale = GTK_SCALE (buildable);
1844   MarksSubparserData *marks_data;
1845
1846   if (strcmp (tagname, "marks") == 0)
1847     {
1848       GSList *m;
1849       gchar *markup;
1850
1851       marks_data = (MarksSubparserData *)user_data;
1852
1853       for (m = marks_data->marks; m; m = m->next)
1854         {
1855           MarkData *mdata = m->data;
1856
1857           if (mdata->translatable && mdata->markup->len)
1858             markup = _gtk_builder_parser_translate (gtk_builder_get_translation_domain (builder),
1859                                                     mdata->context,
1860                                                     mdata->markup->str);
1861           else
1862             markup = mdata->markup->str;
1863
1864           gtk_scale_add_mark (scale, mdata->value, mdata->position, markup);
1865
1866           mark_data_free (mdata);
1867         }
1868
1869       g_slist_free (marks_data->marks);
1870       g_slice_free (MarksSubparserData, marks_data);
1871     }
1872 }