Pileus Git - ~andy/gtk/blob - gtk/gtkscale.c

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