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