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