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 gint
 929 find_next_pos (GtkWidget      *widget,
 930                GSList          *list,
 931                gint            *marks,
 932                GtkPositionType  pos,
 933                gint             match)
 934 {
 935   GSList *m;
 936   gint i;
 937
 938   for (m = list->next, i = 1; m; m = m->next, i++)
 939     {
 940       GtkScaleMark *mark = m->data;
 941
 942       if (match == (mark->position == pos))
 943         return marks[i];
 944     }
 945
 946   return widget->allocation.width;
 947 }
 948
 949 static gboolean
 950 gtk_scale_expose (GtkWidget      *widget,
 951                   GdkEventExpose *event)
 952 {
 953   GtkScale *scale = GTK_SCALE (widget);
 954   GtkScalePrivate *priv = GTK_SCALE_GET_PRIVATE (scale);
 955   GtkRange *range = GTK_RANGE (scale);
 956   GtkStateType state_type;
 957   gint n_marks;
 958   gint *marks;
 959   gint focus_padding;
 960   gint slider_width;
 961   gint value_spacing;
 962   gint min_sep = 4;
 963
 964   gtk_widget_style_get (widget,
 965                         "focus-padding", &focus_padding,
 966                         "slider-width", &slider_width,
 967                         "value-spacing", &value_spacing,
 968                         NULL);
 969
 970   /* We need to chain up _first_ so the various geometry members of
 971    * GtkRange struct are updated.
 972    */
 973   GTK_WIDGET_CLASS (gtk_scale_parent_class)->expose_event (widget, event);
 974
 975   state_type = GTK_STATE_NORMAL;
 976   if (!gtk_widget_is_sensitive (widget))
 977     state_type = GTK_STATE_INSENSITIVE;
 978
 979   if (priv->marks)
 980     {
 981       gint i;
 982       gint x1, x2, x3, y1, y2, y3;
 983       PangoLayout *layout;
 984       PangoRectangle logical_rect;
 985       GSList *m;
 986       gint min_pos_before, min_pos_after;
 987       gint min_pos, max_pos;
 988
 989       n_marks = _gtk_range_get_stop_positions (range, &marks);
 990       layout = gtk_widget_create_pango_layout (widget, NULL);
 991
 992       if (range->orientation == GTK_ORIENTATION_HORIZONTAL)
 993         min_pos_before = min_pos_after = widget->allocation.x;
 994       else
 995         min_pos_before = min_pos_after = widget->allocation.y;
 996       for (m = priv->marks, i = 0; m; m = m->next, i++)
 997         {
 998           GtkScaleMark *mark = m->data;
 999
1000           if (range->orientation == GTK_ORIENTATION_HORIZONTAL)
1001             {
1002               x1 = widget->allocation.x + marks[i];
1003               if (mark->position == GTK_POS_TOP)
1004                 {
1005                   y1 = widget->allocation.y + range->range_rect.y;
1006                   y2 = y1 - slider_width / 2;
1007                   min_pos = min_pos_before;
1008                   max_pos = widget->allocation.x + find_next_pos (widget, m, marks + i, GTK_POS_TOP, 1) - min_sep;
1009                 }
1010               else
1011                 {
1012                   y1 = widget->allocation.y + range->range_rect.y + range->range_rect.height;
1013                   y2 = y1 + slider_width / 2;
1014                   min_pos = min_pos_after;
1015                   max_pos = widget->allocation.x + find_next_pos (widget, m, marks + i, GTK_POS_TOP, 0) - min_sep;
1016                 }
1017
1018               gtk_paint_vline (widget->style, widget->window, state_type,
1019                                NULL, widget, "scale-mark", y1, y2, x1);
1020
1021               if (mark->markup)
1022                 {
1023                   pango_layout_set_markup (layout, mark->markup, -1);
1024                   pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1025
1026                   x3 = x1 - logical_rect.width / 2;
1027                   if (x3 < min_pos)
1028                     x3 = min_pos;
1029                   if (x3 + logical_rect.width > max_pos)
1030                         x3 = max_pos - logical_rect.width;
1031                   if (x3 < widget->allocation.x)
1032                      x3 = widget->allocation.x;
1033                   if (mark->position == GTK_POS_TOP)
1034                     {
1035                       y3 = y2 - value_spacing - logical_rect.height;
1036                       min_pos_before = x3 + logical_rect.width + min_sep;
1037                     }
1038                   else
1039                     {
1040                       y3 = y2 + value_spacing;
1041                       min_pos_after = x3 + logical_rect.width + min_sep;
1042                     }
1043
1044                   gtk_paint_layout (widget->style, widget->window, state_type,
1045                                     FALSE, NULL, widget, "scale-mark",
1046                                     x3, y3, layout);
1047                 }
1048             }
1049           else
1050             {
1051               if (mark->position == GTK_POS_LEFT)
1052                 {
1053                   x1 = widget->allocation.x + range->range_rect.x;
1054                   x2 = widget->allocation.x + range->range_rect.x - slider_width / 2;
1055                   min_pos = min_pos_before;
1056                   max_pos = widget->allocation.y + find_next_pos (widget, m, marks + i, GTK_POS_LEFT, 1) - min_sep;
1057                 }
1058               else
1059                 {
1060                   x1 = widget->allocation.x + range->range_rect.x + range->range_rect.width;
1061                   x2 = widget->allocation.x + range->range_rect.x + range->range_rect.width + slider_width / 2;
1062                   min_pos = min_pos_after;
1063                   max_pos = widget->allocation.y + find_next_pos (widget, m, marks + i, GTK_POS_LEFT, 0) - min_sep;
1064                 }
1065               y1 = widget->allocation.y + marks[i];
1066
1067               gtk_paint_hline (widget->style, widget->window, state_type,
1068                                NULL, widget, "range-mark", x1, x2, y1);
1069
1070               if (mark->markup)
1071                 {
1072                   pango_layout_set_markup (layout, mark->markup, -1);
1073                   pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1074
1075                   y3 = y1 - logical_rect.height / 2;
1076                   if (y3 < min_pos)
1077                     y3 = min_pos;
1078                   if (y3 + logical_rect.height > max_pos)
1079                     y3 = max_pos - logical_rect.height;
1080                   if (y3 < widget->allocation.y)
1081                     y3 = widget->allocation.y;
1082                   if (mark->position == GTK_POS_LEFT)
1083                     {
1084                       x3 = x2 - value_spacing - logical_rect.width;
1085                       min_pos_before = y3 + logical_rect.height + min_sep;
1086                     }
1087                   else
1088                     {
1089                       x3 = x2 + value_spacing;
1090                       min_pos_after = y3 + logical_rect.height + min_sep;
1091                     }
1092
1093                   gtk_paint_layout (widget->style, widget->window, state_type,
1094                                     FALSE, NULL, widget, "scale-mark",
1095                                     x3, y3, layout);
1096                 }
1097             }
1098         }
1099
1100       g_object_unref (layout);
1101       g_free (marks);
1102     }
1103
1104   if (scale->draw_value)
1105     {
1106       PangoLayout *layout;
1107       gint x, y;
1108
1109       layout = gtk_scale_get_layout (scale);
1110       gtk_scale_get_layout_offsets (scale, &x, &y);
1111
1112       gtk_paint_layout (widget->style,
1113                         widget->window,
1114                         state_type,
1115                         FALSE,
1116                         NULL,
1117                         widget,
1118                         range->orientation == GTK_ORIENTATION_HORIZONTAL ?
1119                         "hscale" : "vscale",
1120                         x, y,
1121                         layout);
1122
1123     }
1124
1125   return FALSE;
1126 }
1127
1128 static void
1129 gtk_scale_real_get_layout_offsets (GtkScale *scale,
1130                                    gint     *x,
1131                                    gint     *y)
1132 {
1133   GtkWidget *widget = GTK_WIDGET (scale);
1134   GtkRange *range = GTK_RANGE (widget);
1135   PangoLayout *layout = gtk_scale_get_layout (scale);
1136   PangoRectangle logical_rect;
1137   gint value_spacing;
1138
1139   if (!layout)
1140     {
1141       *x = 0;
1142       *y = 0;
1143
1144       return;
1145     }
1146
1147   gtk_widget_style_get (widget, "value-spacing", &value_spacing, NULL);
1148
1149   pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
1150
1151   if (range->orientation == GTK_ORIENTATION_HORIZONTAL)
1152     {
1153       switch (scale->value_pos)
1154         {
1155         case GTK_POS_LEFT:
1156           *x = range->range_rect.x - value_spacing - logical_rect.width;
1157           *y = range->range_rect.y + (range->range_rect.height - logical_rect.height) / 2;
1158           break;
1159
1160         case GTK_POS_RIGHT:
1161           *x = range->range_rect.x + range->range_rect.width + value_spacing;
1162           *y = range->range_rect.y + (range->range_rect.height - logical_rect.height) / 2;
1163           break;
1164
1165         case GTK_POS_TOP:
1166           *x = range->slider_start +
1167             (range->slider_end - range->slider_start - logical_rect.width) / 2;
1168           *x = CLAMP (*x, 0, widget->allocation.width - logical_rect.width);
1169           *y = range->range_rect.y - logical_rect.height - value_spacing;
1170           break;
1171
1172         case GTK_POS_BOTTOM:
1173           *x = range->slider_start +
1174             (range->slider_end - range->slider_start - logical_rect.width) / 2;
1175           *x = CLAMP (*x, 0, widget->allocation.width - logical_rect.width);
1176           *y = range->range_rect.y + range->range_rect.height + value_spacing;
1177           break;
1178
1179         default:
1180           g_return_if_reached ();
1181           break;
1182         }
1183     }
1184   else
1185     {
1186       switch (scale->value_pos)
1187         {
1188         case GTK_POS_LEFT:
1189           *x = range->range_rect.x - logical_rect.width - value_spacing;
1190           *y = range->slider_start + (range->slider_end - range->slider_start - logical_rect.height) / 2;
1191           *y = CLAMP (*y, 0, widget->allocation.height - logical_rect.height);
1192           break;
1193
1194         case GTK_POS_RIGHT:
1195           *x = range->range_rect.x + range->range_rect.width + value_spacing;
1196           *y = range->slider_start + (range->slider_end - range->slider_start - logical_rect.height) / 2;
1197           *y = CLAMP (*y, 0, widget->allocation.height - logical_rect.height);
1198           break;
1199
1200         case GTK_POS_TOP:
1201           *x = range->range_rect.x + (range->range_rect.width - logical_rect.width) / 2;
1202           *y = range->range_rect.y - logical_rect.height - value_spacing;
1203           break;
1204
1205         case GTK_POS_BOTTOM:
1206           *x = range->range_rect.x + (range->range_rect.width - logical_rect.width) / 2;
1207           *y = range->range_rect.y + range->range_rect.height + value_spacing;
1208           break;
1209
1210         default:
1211           g_return_if_reached ();
1212         }
1213     }
1214
1215   *x += widget->allocation.x;
1216   *y += widget->allocation.y;
1217 }
1218
1219 /**
1220  * _gtk_scale_format_value:
1221  * @scale: a #GtkScale
1222  * @value: adjustment value
1223  *
1224  * Emits #GtkScale::format-value signal to format the value,
1225  * if no user signal handlers, falls back to a default format.
1226  *
1227  * Return value: formatted value
1228  */
1229 gchar*
1230 _gtk_scale_format_value (GtkScale *scale,
1231                          gdouble   value)
1232 {
1233   gchar *fmt = NULL;
1234
1235   g_signal_emit (scale,
1236                  signals[FORMAT_VALUE],
1237                  0,
1238                  value,
1239                  &fmt);
1240
1241   if (fmt)
1242     return fmt;
1243   else
1244     /* insert a LRM, to prevent -20 to come out as 20- in RTL locales */
1245     return g_strdup_printf ("\342\200\216%0.*f", scale->digits, value);
1246 }
1247
1248 static void
1249 gtk_scale_finalize (GObject *object)
1250 {
1251   GtkScale *scale = GTK_SCALE (object);
1252
1253   _gtk_scale_clear_layout (scale);
1254   gtk_scale_clear_marks (scale);
1255
1256   G_OBJECT_CLASS (gtk_scale_parent_class)->finalize (object);
1257 }
1258
1259 /**
1260  * gtk_scale_get_layout:
1261  * @scale: A #GtkScale
1262  *
1263  * Gets the #PangoLayout used to display the scale.
1264  * The returned object is owned by the scale so does
1265  * not need to be freed by the caller.
1266  *
1267  * Return value: the #PangoLayout for this scale, or %NULL
1268  *    if the #GtkScale:draw-value property is %FALSE.
1269  *
1270  * Since: 2.4
1271  */
1272 PangoLayout *
1273 gtk_scale_get_layout (GtkScale *scale)
1274 {
1275   GtkScalePrivate *priv = GTK_SCALE_GET_PRIVATE (scale);
1276   gchar *txt;
1277
1278   g_return_val_if_fail (GTK_IS_SCALE (scale), NULL);
1279
1280   if (!priv->layout)
1281     {
1282       if (scale->draw_value)
1283         priv->layout = gtk_widget_create_pango_layout (GTK_WIDGET (scale), NULL);
1284     }
1285
1286   if (scale->draw_value)
1287     {
1288       txt = _gtk_scale_format_value (scale,
1289                                      GTK_RANGE (scale)->adjustment->value);
1290       pango_layout_set_text (priv->layout, txt, -1);
1291       g_free (txt);
1292     }
1293
1294   return priv->layout;
1295 }
1296
1297 /**
1298  * gtk_scale_get_layout_offsets:
1299  * @scale: a #GtkScale
1300  * @x: (allow-none): location to store X offset of layout, or %NULL
1301  * @y: (allow-none): location to store Y offset of layout, or %NULL
1302  *
1303  * Obtains the coordinates where the scale will draw the
1304  * #PangoLayout representing the text in the scale. Remember
1305  * when using the #PangoLayout function you need to convert to
1306  * and from pixels using PANGO_PIXELS() or #PANGO_SCALE.
1307  *
1308  * If the #GtkScale:draw-value property is %FALSE, the return
1309  * values are undefined.
1310  *
1311  * Since: 2.4
1312  */
1313 void
1314 gtk_scale_get_layout_offsets (GtkScale *scale,
1315                               gint     *x,
1316                               gint     *y)
1317 {
1318   gint local_x = 0;
1319   gint local_y = 0;
1320
1321   g_return_if_fail (GTK_IS_SCALE (scale));
1322
1323   if (GTK_SCALE_GET_CLASS (scale)->get_layout_offsets)
1324     (GTK_SCALE_GET_CLASS (scale)->get_layout_offsets) (scale, &local_x, &local_y);
1325
1326   if (x)
1327     *x = local_x;
1328
1329   if (y)
1330     *y = local_y;
1331 }
1332
1333 void
1334 _gtk_scale_clear_layout (GtkScale *scale)
1335 {
1336   GtkScalePrivate *priv = GTK_SCALE_GET_PRIVATE (scale);
1337
1338   g_return_if_fail (GTK_IS_SCALE (scale));
1339
1340   if (priv->layout)
1341     {
1342       g_object_unref (priv->layout);
1343       priv->layout = NULL;
1344     }
1345 }
1346
1347 static void
1348 gtk_scale_mark_free (GtkScaleMark *mark)
1349 {
1350   g_free (mark->markup);
1351   g_free (mark);
1352 }
1353
1354 /**
1355  * gtk_scale_clear_marks:
1356  * @scale: a #GtkScale
1357  *
1358  * Removes any marks that have been added with gtk_scale_add_mark().
1359  *
1360  * Since: 2.16
1361  */
1362 void
1363 gtk_scale_clear_marks (GtkScale *scale)
1364 {
1365   GtkScalePrivate *priv = GTK_SCALE_GET_PRIVATE (scale);
1366
1367   g_return_if_fail (GTK_IS_SCALE (scale));
1368
1369   g_slist_foreach (priv->marks, (GFunc)gtk_scale_mark_free, NULL);
1370   g_slist_free (priv->marks);
1371   priv->marks = NULL;
1372
1373   _gtk_range_set_stop_values (GTK_RANGE (scale), NULL, 0);
1374
1375   gtk_widget_queue_resize (GTK_WIDGET (scale));
1376 }
1377
1378 static gint
1379 compare_marks (gpointer a, gpointer b)
1380 {
1381   GtkScaleMark *ma, *mb;
1382
1383   ma = a; mb = b;
1384
1385   return (gint) (ma->value - mb->value);
1386 }
1387
1388 /**
1389  * gtk_scale_add_mark:
1390  * @scale: a #GtkScale
1391  * @value: the value at which the mark is placed, must be between
1392  *   the lower and upper limits of the scales' adjustment
1393  * @position: where to draw the mark. For a horizontal scale, #GTK_POS_TOP
1394  *   is drawn above the scale, anything else below. For a vertical scale,
1395  *   #GTK_POS_LEFT is drawn to the left of the scale, anything else to the
1396  *   right.
1397  * @markup: (allow-none): Text to be shown at the mark, using <link linkend="PangoMarkupFormat">Pango markup</link>, or %NULL
1398  *
1399  *
1400  * Adds a mark at @value.
1401  *
1402  * A mark is indicated visually by drawing a tick mark next to the scale,
1403  * and GTK+ makes it easy for the user to position the scale exactly at the
1404  * marks value.
1405  *
1406  * If @markup is not %NULL, text is shown next to the tick mark.
1407  *
1408  * To remove marks from a scale, use gtk_scale_clear_marks().
1409  *
1410  * Since: 2.16
1411  */
1412 void
1413 gtk_scale_add_mark (GtkScale        *scale,
1414                     gdouble          value,
1415                     GtkPositionType  position,
1416                     const gchar     *markup)
1417 {
1418   GtkScalePrivate *priv = GTK_SCALE_GET_PRIVATE (scale);
1419   GtkScaleMark *mark;
1420   GSList *m;
1421   gdouble *values;
1422   gint n, i;
1423
1424   mark = g_new (GtkScaleMark, 1);
1425   mark->value = value;
1426   mark->markup = g_strdup (markup);
1427   mark->position = position;
1428
1429   priv->marks = g_slist_insert_sorted (priv->marks, mark,
1430                                        (GCompareFunc) compare_marks);
1431
1432   n = g_slist_length (priv->marks);
1433   values = g_new (gdouble, n);
1434   for (m = priv->marks, i = 0; m; m = m->next, i++)
1435     {
1436       mark = m->data;
1437       values[i] = mark->value;
1438     }
1439
1440   _gtk_range_set_stop_values (GTK_RANGE (scale), values, n);
1441
1442   g_free (values);
1443
1444   gtk_widget_queue_resize (GTK_WIDGET (scale));
1445 }
1446
1447 static GtkBuildableIface *parent_buildable_iface;
1448
1449 static void
1450 gtk_scale_buildable_interface_init (GtkBuildableIface *iface)
1451 {
1452   parent_buildable_iface = g_type_interface_peek_parent (iface);
1453   iface->custom_tag_start = gtk_scale_buildable_custom_tag_start;
1454   iface->custom_finished = gtk_scale_buildable_custom_finished;
1455 }
1456
1457 typedef struct
1458 {
1459   GtkScale *scale;
1460   GtkBuilder *builder;
1461   GSList *marks;
1462 } MarksSubparserData;
1463
1464 typedef struct
1465 {
1466   gdouble value;
1467   GtkPositionType position;
1468   GString *markup;
1469   gchar *context;
1470   gboolean translatable;
1471 } MarkData;
1472
1473 static void
1474 mark_data_free (MarkData *data)
1475 {
1476   g_string_free (data->markup, TRUE);
1477   g_free (data->context);
1478   g_slice_free (MarkData, data);
1479 }
1480
1481 static void
1482 marks_start_element (GMarkupParseContext *context,
1483                      const gchar         *element_name,
1484                      const gchar        **names,
1485                      const gchar        **values,
1486                      gpointer             user_data,
1487                      GError             **error)
1488 {
1489   MarksSubparserData *parser_data = (MarksSubparserData*)user_data;
1490   guint i;
1491   gint line_number, char_number;
1492
1493   if (strcmp (element_name, "marks") == 0)
1494    ;
1495   else if (strcmp (element_name, "mark") == 0)
1496     {
1497       gdouble value = 0;
1498       gboolean has_value = FALSE;
1499       GtkPositionType position = GTK_POS_BOTTOM;
1500       const gchar *msg_context = NULL;
1501       gboolean translatable = FALSE;
1502       MarkData *mark;
1503
1504       for (i = 0; names[i]; i++)
1505         {
1506           if (strcmp (names[i], "translatable") == 0)
1507             {
1508               if (!_gtk_builder_boolean_from_string (values[i], &translatable, error))
1509                 return;
1510             }
1511           else if (strcmp (names[i], "comments") == 0)
1512             {
1513               /* do nothing, comments are for translators */
1514             }
1515           else if (strcmp (names[i], "context") == 0)
1516             msg_context = values[i];
1517           else if (strcmp (names[i], "value") == 0)
1518             {
1519               GValue gvalue = { 0, };
1520
1521               if (!gtk_builder_value_from_string_type (parser_data->builder, G_TYPE_DOUBLE, values[i], &gvalue, error))
1522                 return;
1523
1524               value = g_value_get_double (&gvalue);
1525               has_value = TRUE;
1526             }
1527           else if (strcmp (names[i], "position") == 0)
1528             {
1529               GValue gvalue = { 0, };
1530
1531               if (!gtk_builder_value_from_string_type (parser_data->builder, GTK_TYPE_POSITION_TYPE, values[i], &gvalue, error))
1532                 return;
1533
1534               position = g_value_get_enum (&gvalue);
1535             }
1536           else
1537             {
1538               g_markup_parse_context_get_position (context,
1539                                                    &line_number,
1540                                                    &char_number);
1541               g_set_error (error,
1542                            GTK_BUILDER_ERROR,
1543                            GTK_BUILDER_ERROR_INVALID_ATTRIBUTE,
1544                            "%s:%d:%d '%s' is not a valid attribute of <%s>",
1545                            "<input>",
1546                            line_number, char_number, names[i], "mark");
1547               return;
1548             }
1549         }
1550
1551       if (!has_value)
1552         {
1553           g_markup_parse_context_get_position (context,
1554                                                &line_number,
1555                                                &char_number);
1556           g_set_error (error,
1557                        GTK_BUILDER_ERROR,
1558                        GTK_BUILDER_ERROR_MISSING_ATTRIBUTE,
1559                        "%s:%d:%d <%s> requires attribute \"%s\"",
1560                        "<input>",
1561                        line_number, char_number, "mark",
1562                        "value");
1563           return;
1564         }
1565
1566       mark = g_slice_new (MarkData);
1567       mark->value = value;
1568       mark->position = position;
1569       mark->markup = g_string_new ("");
1570       mark->context = g_strdup (msg_context);
1571       mark->translatable = translatable;
1572
1573       parser_data->marks = g_slist_prepend (parser_data->marks, mark);
1574     }
1575   else
1576     {
1577       g_markup_parse_context_get_position (context,
1578                                            &line_number,
1579                                            &char_number);
1580       g_set_error (error,
1581                    GTK_BUILDER_ERROR,
1582                    GTK_BUILDER_ERROR_MISSING_ATTRIBUTE,
1583                    "%s:%d:%d unsupported tag for GtkScale: \"%s\"",
1584                    "<input>",
1585                    line_number, char_number, element_name);
1586       return;
1587     }
1588 }
1589
1590 static void
1591 marks_text (GMarkupParseContext  *context,
1592             const gchar          *text,
1593             gsize                 text_len,
1594             gpointer              user_data,
1595             GError              **error)
1596 {
1597   MarksSubparserData *data = (MarksSubparserData*)user_data;
1598
1599   if (strcmp (g_markup_parse_context_get_element (context), "mark") == 0)
1600     {
1601       MarkData *mark = data->marks->data;
1602
1603       g_string_append_len (mark->markup, text, text_len);
1604     }
1605 }
1606
1607 static const GMarkupParser marks_parser =
1608   {
1609     marks_start_element,
1610     NULL,
1611     marks_text,
1612   };
1613
1614
1615 static gboolean
1616 gtk_scale_buildable_custom_tag_start (GtkBuildable  *buildable,
1617                                       GtkBuilder    *builder,
1618                                       GObject       *child,
1619                                       const gchar   *tagname,
1620                                       GMarkupParser *parser,
1621                                       gpointer      *data)
1622 {
1623   MarksSubparserData *parser_data;
1624
1625   if (child)
1626     return FALSE;
1627
1628   if (strcmp (tagname, "marks") == 0)
1629     {
1630       parser_data = g_slice_new0 (MarksSubparserData);
1631       parser_data->scale = GTK_SCALE (buildable);
1632       parser_data->marks = NULL;
1633
1634       *parser = marks_parser;
1635       *data = parser_data;
1636       return TRUE;
1637     }
1638
1639   return parent_buildable_iface->custom_tag_start (buildable, builder, child,
1640                                                    tagname, parser, data);
1641 }
1642
1643 static void
1644 gtk_scale_buildable_custom_finished (GtkBuildable *buildable,
1645                                      GtkBuilder   *builder,
1646                                      GObject      *child,
1647                                      const gchar  *tagname,
1648                                      gpointer      user_data)
1649 {
1650   GtkScale *scale = GTK_SCALE (buildable);
1651   MarksSubparserData *marks_data;
1652
1653   if (strcmp (tagname, "marks") == 0)
1654     {
1655       GSList *m;
1656       gchar *markup;
1657
1658       marks_data = (MarksSubparserData *)user_data;
1659
1660       for (m = marks_data->marks; m; m = m->next)
1661         {
1662           MarkData *mdata = m->data;
1663
1664           if (mdata->translatable && mdata->markup->len)
1665             markup = _gtk_builder_parser_translate (gtk_builder_get_translation_domain (builder),
1666                                                     mdata->context,
1667                                                     mdata->markup->str);
1668           else
1669             markup = mdata->markup->str;
1670
1671           gtk_scale_add_mark (scale, mdata->value, mdata->position, markup);
1672
1673           mark_data_free (mdata);
1674         }
1675
1676       g_slist_free (marks_data->marks);
1677       g_slice_free (MarksSubparserData, marks_data);
1678     }
1679 }
1680
1681 #define __GTK_SCALE_C__
1682 #include "gtkaliasdef.c"