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