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