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