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->draw_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_digits = 1;
 386   scale->draw_value = TRUE;
 387   scale->value_pos = GTK_POS_TOP;
 388 }
 389
 390 void
 391 gtk_scale_set_digits (GtkScale *scale,
 392                       gint      digits)
 393 {
 394   GtkRange *range;
 395
 396   g_return_if_fail (GTK_IS_SCALE (scale));
 397
 398   range = GTK_RANGE (scale);
 399
 400   digits = CLAMP (digits, -1, MAX_DIGITS);
 401
 402   if (scale->draw_digits != digits)
 403     {
 404       scale->draw_digits = digits;
 405
 406       gtk_widget_queue_resize (GTK_WIDGET (scale));
 407
 408       g_object_notify (G_OBJECT (scale), "digits");
 409     }
 410 }
 411
 412 gint
 413 gtk_scale_get_digits (GtkScale *scale)
 414 {
 415   g_return_val_if_fail (GTK_IS_SCALE (scale), -1);
 416
 417   return scale->draw_digits;
 418 }
 419
 420 void
 421 gtk_scale_set_draw_value (GtkScale *scale,
 422                           gboolean  draw_value)
 423 {
 424   g_return_if_fail (GTK_IS_SCALE (scale));
 425
 426   draw_value = draw_value != FALSE;
 427
 428   if (scale->draw_value != draw_value)
 429     {
 430       scale->draw_value = draw_value;
 431
 432       gtk_widget_queue_resize (GTK_WIDGET (scale));
 433
 434       g_object_notify (G_OBJECT (scale), "draw_value");
 435     }
 436 }
 437
 438 gboolean
 439 gtk_scale_get_draw_value (GtkScale *scale)
 440 {
 441   g_return_val_if_fail (GTK_IS_SCALE (scale), FALSE);
 442
 443   return scale->draw_value;
 444 }
 445
 446 void
 447 gtk_scale_set_value_pos (GtkScale        *scale,
 448                          GtkPositionType  pos)
 449 {
 450   g_return_if_fail (GTK_IS_SCALE (scale));
 451
 452   if (scale->value_pos != pos)
 453     {
 454       scale->value_pos = pos;
 455
 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 (G_OBJECT (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_WIDGET_CLASS (parent_class)->style_set) (widget, previous);
 582 }
 583
 584
 585 /**
 586  * _gtk_scale_format_value:
 587  * @scale: a #GtkScale
 588  * @value: adjustment value
 589  *
 590  * Emits "format_value" signal to format the value, if no user
 591  * signal handlers, falls back to a default format.
 592  *
 593  * Return value: formatted value
 594  **/
 595 gchar*
 596 _gtk_scale_format_value (GtkScale *scale,
 597                          gdouble   value)
 598 {
 599   gchar *fmt = NULL;
 600
 601   g_signal_emit (G_OBJECT (scale),
 602                  signals[FORMAT_VALUE],
 603                  0,
 604                  value,
 605                  &fmt);
 606
 607   if (fmt)
 608     return fmt;
 609   else
 610     return g_strdup_printf ("%0.*f", scale->draw_digits,
 611                             value);
 612 }