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 #include <math.h>
  30 #include "gtkalias.h"
  31 #include "gtkintl.h"
  32 #include "gtkscale.h"
  33 #include "gtkmarshalers.h"
  34 #include "gdk/gdkkeysyms.h"
  35 #include "gtkbindings.h"
  36
  37
  38 #define MAX_DIGITS      (64)    /* don't change this,
  39                                  * a) you don't need to and
  40                                  * b) you might cause buffer owerflows in
  41                                  *    unrelated code portions otherwise
  42                                  */
  43
  44 #define GTK_SCALE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_SCALE, GtkScalePrivate))
  45
  46 typedef struct _GtkScalePrivate GtkScalePrivate;
  47
  48 struct _GtkScalePrivate
  49 {
  50   PangoLayout *layout;
  51 };
  52
  53 enum {
  54   PROP_0,
  55   PROP_DIGITS,
  56   PROP_DRAW_VALUE,
  57   PROP_VALUE_POS
  58 };
  59
  60 enum {
  61   FORMAT_VALUE,
  62   LAST_SIGNAL
  63 };
  64
  65 static guint signals[LAST_SIGNAL];
  66 static GtkRangeClass *parent_class = NULL;
  67
  68 static void gtk_scale_class_init       (GtkScaleClass *klass);
  69 static void gtk_scale_init             (GtkScale      *scale);
  70 static void gtk_scale_set_property     (GObject       *object,
  71                                         guint          prop_id,
  72                                         const GValue  *value,
  73                                         GParamSpec    *pspec);
  74 static void gtk_scale_get_property     (GObject       *object,
  75                                         guint          prop_id,
  76                                         GValue        *value,
  77                                         GParamSpec    *pspec);
  78 static void gtk_scale_style_set        (GtkWidget     *widget,
  79                                         GtkStyle      *previous);
  80 static void gtk_scale_get_range_border (GtkRange      *range,
  81                                         GtkBorder     *border);
  82 static void gtk_scale_finalize         (GObject       *object);
  83 static void gtk_scale_screen_changed   (GtkWidget     *widget,
  84                                         GdkScreen     *old_screen);
  85
  86 GType
  87 gtk_scale_get_type (void)
  88 {
  89   static GType scale_type = 0;
  90
  91   if (!scale_type)
  92     {
  93       static const GTypeInfo scale_info =
  94       {
  95         sizeof (GtkScaleClass),
  96         NULL,           /* base_init */
  97         NULL,           /* base_finalize */
  98         (GClassInitFunc) gtk_scale_class_init,
  99         NULL,           /* class_finalize */
 100         NULL,           /* class_data */
 101         sizeof (GtkScale),
 102         0,              /* n_preallocs */
 103         (GInstanceInitFunc) gtk_scale_init,
 104         NULL,           /* value_table */
 105       };
 106
 107       scale_type = g_type_register_static (GTK_TYPE_RANGE, "GtkScale",
 108                                            &scale_info, G_TYPE_FLAG_ABSTRACT);
 109     }
 110
 111   return scale_type;
 112 }
 113
 114 static gboolean
 115 single_string_accumulator (GSignalInvocationHint *ihint,
 116                            GValue                *return_accu,
 117                            const GValue          *handler_return,
 118                            gpointer               dummy)
 119 {
 120   gboolean continue_emission;
 121   const gchar *str;
 122
 123   str = g_value_get_string (handler_return);
 124   g_value_set_string (return_accu, str);
 125   continue_emission = str == NULL;
 126
 127   return continue_emission;
 128 }
 129
 130
 131 #define add_slider_binding(binding_set, keyval, mask, scroll)          \
 132   gtk_binding_entry_add_signal (binding_set, keyval, mask,             \
 133                                 "move_slider", 1,                      \
 134                                 GTK_TYPE_SCROLL_TYPE, scroll)
 135
 136 static void
 137 gtk_scale_class_init (GtkScaleClass *class)
 138 {
 139   GObjectClass   *gobject_class;
 140   GtkWidgetClass *widget_class;
 141   GtkRangeClass  *range_class;
 142   GtkBindingSet  *binding_set;
 143
 144   gobject_class = G_OBJECT_CLASS (class);
 145   range_class = (GtkRangeClass*) class;
 146   widget_class = (GtkWidgetClass*) class;
 147
 148   parent_class = g_type_class_peek_parent (class);
 149
 150   gobject_class->set_property = gtk_scale_set_property;
 151   gobject_class->get_property = gtk_scale_get_property;
 152   gobject_class->finalize = gtk_scale_finalize;
 153
 154   widget_class->style_set = gtk_scale_style_set;
 155   widget_class->screen_changed = gtk_scale_screen_changed;
 156
 157   range_class->get_range_border = gtk_scale_get_range_border;
 158
 159   signals[FORMAT_VALUE] =
 160     g_signal_new ("format_value",
 161                   G_TYPE_FROM_CLASS (gobject_class),
 162                   G_SIGNAL_RUN_LAST,
 163                   G_STRUCT_OFFSET (GtkScaleClass, format_value),
 164                   single_string_accumulator, NULL,
 165                   _gtk_marshal_STRING__DOUBLE,
 166                   G_TYPE_STRING, 1,
 167                   G_TYPE_DOUBLE);
 168
 169   g_object_class_install_property (gobject_class,
 170                                    PROP_DIGITS,
 171                                    g_param_spec_int ("digits",
 172                                                      P_("Digits"),
 173                                                      P_("The number of decimal places that are displayed in the value"),
 174                                                      -1,
 175                                                      MAX_DIGITS,
 176                                                      1,
 177                                                      G_PARAM_READWRITE));
 178
 179   g_object_class_install_property (gobject_class,
 180                                    PROP_DRAW_VALUE,
 181                                    g_param_spec_boolean ("draw-value",
 182                                                          P_("Draw Value"),
 183                                                          P_("Whether the current value is displayed as a string next to the slider"),
 184                                                          FALSE,
 185                                                          G_PARAM_READWRITE));
 186
 187   g_object_class_install_property (gobject_class,
 188                                    PROP_VALUE_POS,
 189                                    g_param_spec_enum ("value-pos",
 190                                                       P_("Value Position"),
 191                                                       P_("The position in which the current value is displayed"),
 192                                                       GTK_TYPE_POSITION_TYPE,
 193                                                       GTK_POS_LEFT,
 194                                                       G_PARAM_READWRITE));
 195
 196   gtk_widget_class_install_style_property (widget_class,
 197                                            g_param_spec_int ("slider-length",
 198                                                              P_("Slider Length"),
 199                                                              P_("Length of scale's slider"),
 200                                                              0,
 201                                                              G_MAXINT,
 202                                                              31,
 203                                                              G_PARAM_READABLE));
 204
 205   gtk_widget_class_install_style_property (widget_class,
 206                                            g_param_spec_int ("value-spacing",
 207                                                              P_("Value spacing"),
 208                                                              P_("Space between value text and the slider/trough area"),
 209                                                              0,
 210                                                              G_MAXINT,
 211                                                              2,
 212                                                              G_PARAM_READABLE));
 213
 214   /* All bindings (even arrow keys) are on both h/v scale, because
 215    * blind users etc. don't care about scale orientation.
 216    */
 217
 218   binding_set = gtk_binding_set_by_class (class);
 219
 220   add_slider_binding (binding_set, GDK_Left, 0,
 221                       GTK_SCROLL_STEP_LEFT);
 222
 223   add_slider_binding (binding_set, GDK_Left, GDK_CONTROL_MASK,
 224                       GTK_SCROLL_PAGE_LEFT);
 225
 226   add_slider_binding (binding_set, GDK_KP_Left, 0,
 227                       GTK_SCROLL_STEP_LEFT);
 228
 229   add_slider_binding (binding_set, GDK_KP_Left, GDK_CONTROL_MASK,
 230                       GTK_SCROLL_PAGE_LEFT);
 231
 232   add_slider_binding (binding_set, GDK_Right, 0,
 233                       GTK_SCROLL_STEP_RIGHT);
 234
 235   add_slider_binding (binding_set, GDK_Right, GDK_CONTROL_MASK,
 236                       GTK_SCROLL_PAGE_RIGHT);
 237
 238   add_slider_binding (binding_set, GDK_KP_Right, 0,
 239                       GTK_SCROLL_STEP_RIGHT);
 240
 241   add_slider_binding (binding_set, GDK_KP_Right, GDK_CONTROL_MASK,
 242                       GTK_SCROLL_PAGE_RIGHT);
 243
 244   add_slider_binding (binding_set, GDK_Up, 0,
 245                       GTK_SCROLL_STEP_UP);
 246
 247   add_slider_binding (binding_set, GDK_Up, GDK_CONTROL_MASK,
 248                       GTK_SCROLL_PAGE_UP);
 249
 250   add_slider_binding (binding_set, GDK_KP_Up, 0,
 251                       GTK_SCROLL_STEP_UP);
 252
 253   add_slider_binding (binding_set, GDK_KP_Up, GDK_CONTROL_MASK,
 254                       GTK_SCROLL_PAGE_UP);
 255
 256   add_slider_binding (binding_set, GDK_Down, 0,
 257                       GTK_SCROLL_STEP_DOWN);
 258
 259   add_slider_binding (binding_set, GDK_Down, GDK_CONTROL_MASK,
 260                       GTK_SCROLL_PAGE_DOWN);
 261
 262   add_slider_binding (binding_set, GDK_KP_Down, 0,
 263                       GTK_SCROLL_STEP_DOWN);
 264
 265   add_slider_binding (binding_set, GDK_KP_Down, GDK_CONTROL_MASK,
 266                       GTK_SCROLL_PAGE_DOWN);
 267
 268   add_slider_binding (binding_set, GDK_Page_Up, 0,
 269                       GTK_SCROLL_PAGE_LEFT);
 270
 271   add_slider_binding (binding_set, GDK_KP_Page_Up, 0,
 272                       GTK_SCROLL_PAGE_LEFT);
 273
 274   add_slider_binding (binding_set, GDK_Page_Up, 0,
 275                       GTK_SCROLL_PAGE_UP);
 276
 277   add_slider_binding (binding_set, GDK_KP_Page_Up, 0,
 278                       GTK_SCROLL_PAGE_UP);
 279
 280   add_slider_binding (binding_set, GDK_Page_Down, 0,
 281                       GTK_SCROLL_PAGE_RIGHT);
 282
 283   add_slider_binding (binding_set, GDK_KP_Page_Down, 0,
 284                       GTK_SCROLL_PAGE_RIGHT);
 285
 286   add_slider_binding (binding_set, GDK_Page_Down, 0,
 287                       GTK_SCROLL_PAGE_DOWN);
 288
 289   add_slider_binding (binding_set, GDK_KP_Page_Down, 0,
 290                       GTK_SCROLL_PAGE_DOWN);
 291
 292   /* Logical bindings (vs. visual bindings above) */
 293
 294   add_slider_binding (binding_set, GDK_plus, 0,
 295                       GTK_SCROLL_STEP_FORWARD);
 296
 297   add_slider_binding (binding_set, GDK_minus, 0,
 298                       GTK_SCROLL_STEP_BACKWARD);
 299
 300   add_slider_binding (binding_set, GDK_plus, GDK_CONTROL_MASK,
 301                       GTK_SCROLL_PAGE_FORWARD);
 302
 303   add_slider_binding (binding_set, GDK_minus, GDK_CONTROL_MASK,
 304                       GTK_SCROLL_PAGE_BACKWARD);
 305
 306
 307   add_slider_binding (binding_set, GDK_KP_Add, 0,
 308                       GTK_SCROLL_STEP_FORWARD);
 309
 310   add_slider_binding (binding_set, GDK_KP_Subtract, 0,
 311                       GTK_SCROLL_STEP_BACKWARD);
 312
 313   add_slider_binding (binding_set, GDK_KP_Add, GDK_CONTROL_MASK,
 314                       GTK_SCROLL_PAGE_FORWARD);
 315
 316   add_slider_binding (binding_set, GDK_KP_Subtract, GDK_CONTROL_MASK,
 317                       GTK_SCROLL_PAGE_BACKWARD);
 318
 319
 320   add_slider_binding (binding_set, GDK_Home, 0,
 321                       GTK_SCROLL_START);
 322
 323   add_slider_binding (binding_set, GDK_KP_Home, 0,
 324                       GTK_SCROLL_START);
 325
 326   add_slider_binding (binding_set, GDK_End, 0,
 327                       GTK_SCROLL_END);
 328
 329   add_slider_binding (binding_set, GDK_KP_End, 0,
 330                       GTK_SCROLL_END);
 331
 332   g_type_class_add_private (gobject_class, sizeof (GtkScalePrivate));
 333 }
 334
 335 static void
 336 gtk_scale_set_property (GObject      *object,
 337                         guint         prop_id,
 338                         const GValue *value,
 339                         GParamSpec   *pspec)
 340 {
 341   GtkScale *scale;
 342
 343   scale = GTK_SCALE (object);
 344
 345   switch (prop_id)
 346     {
 347     case PROP_DIGITS:
 348       gtk_scale_set_digits (scale, g_value_get_int (value));
 349       break;
 350     case PROP_DRAW_VALUE:
 351       gtk_scale_set_draw_value (scale, g_value_get_boolean (value));
 352       break;
 353     case PROP_VALUE_POS:
 354       gtk_scale_set_value_pos (scale, g_value_get_enum (value));
 355       break;
 356     default:
 357       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 358       break;
 359     }
 360 }
 361
 362 static void
 363 gtk_scale_get_property (GObject      *object,
 364                         guint         prop_id,
 365                         GValue       *value,
 366                         GParamSpec   *pspec)
 367 {
 368   GtkScale *scale;
 369
 370   scale = GTK_SCALE (object);
 371
 372   switch (prop_id)
 373     {
 374     case PROP_DIGITS:
 375       g_value_set_int (value, scale->digits);
 376       break;
 377     case PROP_DRAW_VALUE:
 378       g_value_set_boolean (value, scale->draw_value);
 379       break;
 380     case PROP_VALUE_POS:
 381       g_value_set_enum (value, scale->value_pos);
 382       break;
 383     default:
 384       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 385       break;
 386     }
 387 }
 388
 389 static void
 390 gtk_scale_init (GtkScale *scale)
 391 {
 392   GtkRange *range;
 393
 394   range = GTK_RANGE (scale);
 395
 396   GTK_WIDGET_SET_FLAGS (scale, GTK_CAN_FOCUS);
 397
 398   range->slider_size_fixed = TRUE;
 399   range->has_stepper_a = FALSE;
 400   range->has_stepper_b = FALSE;
 401   range->has_stepper_c = FALSE;
 402   range->has_stepper_d = FALSE;
 403
 404   scale->draw_value = TRUE;
 405   scale->value_pos = GTK_POS_TOP;
 406   scale->digits = 1;
 407   range->round_digits = scale->digits;
 408 }
 409
 410 void
 411 gtk_scale_set_digits (GtkScale *scale,
 412                       gint      digits)
 413 {
 414   GtkRange *range;
 415
 416   g_return_if_fail (GTK_IS_SCALE (scale));
 417
 418   range = GTK_RANGE (scale);
 419
 420   digits = CLAMP (digits, -1, MAX_DIGITS);
 421
 422   if (scale->digits != digits)
 423     {
 424       scale->digits = digits;
 425       if (scale->draw_value)
 426         range->round_digits = digits;
 427
 428       _gtk_scale_clear_layout (scale);
 429       gtk_widget_queue_resize (GTK_WIDGET (scale));
 430
 431       g_object_notify (G_OBJECT (scale), "digits");
 432     }
 433 }
 434
 435 gint
 436 gtk_scale_get_digits (GtkScale *scale)
 437 {
 438   g_return_val_if_fail (GTK_IS_SCALE (scale), -1);
 439
 440   return scale->digits;
 441 }
 442
 443 void
 444 gtk_scale_set_draw_value (GtkScale *scale,
 445                           gboolean  draw_value)
 446 {
 447   g_return_if_fail (GTK_IS_SCALE (scale));
 448
 449   draw_value = draw_value != FALSE;
 450
 451   if (scale->draw_value != draw_value)
 452     {
 453       scale->draw_value = draw_value;
 454       if (draw_value)
 455         GTK_RANGE (scale)->round_digits = scale->digits;
 456       else
 457         GTK_RANGE (scale)->round_digits = -1;
 458
 459       _gtk_scale_clear_layout (scale);
 460
 461       gtk_widget_queue_resize (GTK_WIDGET (scale));
 462
 463       g_object_notify (G_OBJECT (scale), "draw_value");
 464     }
 465 }
 466
 467 gboolean
 468 gtk_scale_get_draw_value (GtkScale *scale)
 469 {
 470   g_return_val_if_fail (GTK_IS_SCALE (scale), FALSE);
 471
 472   return scale->draw_value;
 473 }
 474
 475 void
 476 gtk_scale_set_value_pos (GtkScale        *scale,
 477                          GtkPositionType  pos)
 478 {
 479   g_return_if_fail (GTK_IS_SCALE (scale));
 480
 481   if (scale->value_pos != pos)
 482     {
 483       scale->value_pos = pos;
 484
 485       _gtk_scale_clear_layout (scale);
 486       if (GTK_WIDGET_VISIBLE (scale) && GTK_WIDGET_MAPPED (scale))
 487         gtk_widget_queue_resize (GTK_WIDGET (scale));
 488
 489       g_object_notify (G_OBJECT (scale), "value_pos");
 490     }
 491 }
 492
 493 GtkPositionType
 494 gtk_scale_get_value_pos (GtkScale *scale)
 495 {
 496   g_return_val_if_fail (GTK_IS_SCALE (scale), 0);
 497
 498   return scale->value_pos;
 499 }
 500
 501 static void
 502 gtk_scale_get_range_border (GtkRange  *range,
 503                             GtkBorder *border)
 504 {
 505   GtkWidget *widget;
 506   GtkScale *scale;
 507   gint w, h;
 508
 509   widget = GTK_WIDGET (range);
 510   scale = GTK_SCALE (range);
 511
 512   _gtk_scale_get_value_size (scale, &w, &h);
 513
 514   border->left = 0;
 515   border->right = 0;
 516   border->top = 0;
 517   border->bottom = 0;
 518
 519   if (scale->draw_value)
 520     {
 521       gint value_spacing;
 522       gtk_widget_style_get (widget, "value_spacing", &value_spacing, NULL);
 523
 524       switch (scale->value_pos)
 525         {
 526         case GTK_POS_LEFT:
 527           border->left += w + value_spacing;
 528           break;
 529         case GTK_POS_RIGHT:
 530           border->right += w + value_spacing;
 531           break;
 532         case GTK_POS_TOP:
 533           border->top += h + value_spacing;
 534           break;
 535         case GTK_POS_BOTTOM:
 536           border->bottom += h + value_spacing;
 537           break;
 538         }
 539     }
 540 }
 541
 542 /* FIXME this could actually be static at the moment. */
 543 void
 544 _gtk_scale_get_value_size (GtkScale *scale,
 545                            gint     *width,
 546                            gint     *height)
 547 {
 548   GtkRange *range;
 549
 550   g_return_if_fail (GTK_IS_SCALE (scale));
 551
 552   if (scale->draw_value)
 553     {
 554       PangoLayout *layout;
 555       PangoRectangle logical_rect;
 556       gchar *txt;
 557
 558       range = GTK_RANGE (scale);
 559
 560       layout = gtk_widget_create_pango_layout (GTK_WIDGET (scale), NULL);
 561
 562       txt = _gtk_scale_format_value (scale, range->adjustment->lower);
 563       pango_layout_set_text (layout, txt, -1);
 564       g_free (txt);
 565
 566       pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
 567
 568       if (width)
 569         *width = logical_rect.width;
 570       if (height)
 571         *height = logical_rect.height;
 572
 573       txt = _gtk_scale_format_value (scale, range->adjustment->upper);
 574       pango_layout_set_text (layout, txt, -1);
 575       g_free (txt);
 576
 577       pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
 578
 579       if (width)
 580         *width = MAX (*width, logical_rect.width);
 581       if (height)
 582         *height = MAX (*height, logical_rect.height);
 583
 584       g_object_unref (layout);
 585     }
 586   else
 587     {
 588       if (width)
 589         *width = 0;
 590       if (height)
 591         *height = 0;
 592     }
 593
 594 }
 595
 596 static void
 597 gtk_scale_style_set (GtkWidget *widget,
 598                      GtkStyle  *previous)
 599 {
 600   gint slider_length;
 601   GtkRange *range;
 602
 603   range = GTK_RANGE (widget);
 604
 605   gtk_widget_style_get (widget,
 606                         "slider_length", &slider_length,
 607                         NULL);
 608
 609   range->min_slider_size = slider_length;
 610
 611   _gtk_scale_clear_layout (GTK_SCALE (widget));
 612
 613   (* GTK_WIDGET_CLASS (parent_class)->style_set) (widget, previous);
 614 }
 615
 616 static void
 617 gtk_scale_screen_changed (GtkWidget *widget,
 618                           GdkScreen *old_screen)
 619 {
 620   _gtk_scale_clear_layout (GTK_SCALE (widget));
 621 }
 622
 623 /**
 624  * _gtk_scale_format_value:
 625  * @scale: a #GtkScale
 626  * @value: adjustment value
 627  *
 628  * Emits "format_value" signal to format the value, if no user
 629  * signal handlers, falls back to a default format.
 630  *
 631  * Return value: formatted value
 632  **/
 633 gchar*
 634 _gtk_scale_format_value (GtkScale *scale,
 635                          gdouble   value)
 636 {
 637   gchar *fmt = NULL;
 638
 639   g_signal_emit (scale,
 640                  signals[FORMAT_VALUE],
 641                  0,
 642                  value,
 643                  &fmt);
 644
 645   if (fmt)
 646     return fmt;
 647   else
 648     return g_strdup_printf ("%0.*f", scale->digits,
 649                             value);
 650 }
 651
 652 static void
 653 gtk_scale_finalize (GObject *object)
 654 {
 655   GtkScale *scale;
 656
 657   g_return_if_fail (GTK_IS_SCALE (object));
 658
 659   scale = GTK_SCALE (object);
 660
 661   _gtk_scale_clear_layout (scale);
 662
 663   G_OBJECT_CLASS (parent_class)->finalize (object);
 664 }
 665
 666 /**
 667  * gtk_scale_get_layout:
 668  * @scale: A #GtkScale
 669  *
 670  * Gets the #PangoLayout used to display the scale. The returned object
 671  * is owned by the scale so does not need to be freed by the caller.
 672  *
 673  * Return value: the #PangoLayout for this scale, or %NULL if the draw_value property
 674  *    is %FALSE.
 675  *
 676  * Since: 2.4
 677  **/
 678 PangoLayout *
 679 gtk_scale_get_layout (GtkScale *scale)
 680 {
 681   GtkScalePrivate *priv = GTK_SCALE_GET_PRIVATE (scale);
 682   gchar *txt;
 683
 684   g_return_val_if_fail (GTK_IS_SCALE (scale), NULL);
 685
 686   if (!priv->layout)
 687     {
 688       if (scale->draw_value)
 689         priv->layout = gtk_widget_create_pango_layout (GTK_WIDGET (scale), NULL);
 690     }
 691
 692   if (scale->draw_value)
 693     {
 694       txt = _gtk_scale_format_value (scale,
 695                                      GTK_RANGE (scale)->adjustment->value);
 696       pango_layout_set_text (priv->layout, txt, -1);
 697       g_free (txt);
 698     }
 699
 700   return priv->layout;
 701 }
 702
 703 /**
 704  * gtk_scale_get_layout_offsets:
 705  * @scale: a #GtkScale
 706  * @x: location to store X offset of layout, or %NULL
 707  * @y: location to store Y offset of layout, or %NULL
 708  *
 709  * Obtains the coordinates where the scale will draw the #PangoLayout
 710  * representing the text in the scale. Remember
 711  * when using the #PangoLayout function you need to convert to
 712  * and from pixels using PANGO_PIXELS() or #PANGO_SCALE.
 713  *
 714  * If the draw_value property is %FALSE, the return values are
 715  * undefined.
 716  *
 717  * Since: 2.4
 718  **/
 719 void
 720 gtk_scale_get_layout_offsets (GtkScale *scale,
 721                               gint     *x,
 722                               gint     *y)
 723 {
 724   gint local_x, local_y;
 725
 726   g_return_if_fail (GTK_IS_SCALE (scale));
 727
 728   if (GTK_SCALE_GET_CLASS (scale)->get_layout_offsets)
 729     (GTK_SCALE_GET_CLASS (scale)->get_layout_offsets) (scale, &local_x, &local_y);
 730
 731   if (x)
 732     *x = local_x;
 733
 734   if (y)
 735     *y = local_y;
 736 }
 737
 738 void _gtk_scale_clear_layout (GtkScale *scale)
 739 {
 740   GtkScalePrivate *priv = GTK_SCALE_GET_PRIVATE (scale);
 741
 742   g_return_if_fail (GTK_IS_SCALE (scale));
 743
 744   if (priv->layout)
 745     {
 746       g_object_unref (priv->layout);
 747       priv->layout = NULL;
 748     }
 749 }
 750