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  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #include <math.h>
  28 #include "gtkintl.h"
  29 #include "gtkscale.h"
  30
  31 enum {
  32   ARG_0,
  33   ARG_DIGITS,
  34   ARG_DRAW_VALUE,
  35   ARG_VALUE_POS
  36 };
  37
  38
  39 static void gtk_scale_class_init      (GtkScaleClass *klass);
  40 static void gtk_scale_init            (GtkScale      *scale);
  41 static void gtk_scale_set_arg         (GtkObject     *object,
  42                                        GtkArg        *arg,
  43                                        guint          arg_id);
  44 static void gtk_scale_get_arg         (GtkObject     *object,
  45                                        GtkArg        *arg,
  46                                        guint          arg_id);
  47 static void gtk_scale_map             (GtkWidget     *widget);
  48 static void gtk_scale_unmap           (GtkWidget     *widget);
  49
  50 static void gtk_scale_draw_background (GtkRange      *range);
  51
  52
  53 static GtkRangeClass *parent_class = NULL;
  54
  55
  56 GtkType
  57 gtk_scale_get_type (void)
  58 {
  59   static GtkType scale_type = 0;
  60
  61   if (!scale_type)
  62     {
  63       static const GtkTypeInfo scale_info =
  64       {
  65         "GtkScale",
  66         sizeof (GtkScale),
  67         sizeof (GtkScaleClass),
  68         (GtkClassInitFunc) gtk_scale_class_init,
  69         (GtkObjectInitFunc) gtk_scale_init,
  70         /* reserved_1 */ NULL,
  71         /* reserved_2 */ NULL,
  72         (GtkClassInitFunc) NULL,
  73       };
  74
  75       scale_type = gtk_type_unique (GTK_TYPE_RANGE, &scale_info);
  76     }
  77
  78   return scale_type;
  79 }
  80
  81 static void
  82 gtk_scale_class_init (GtkScaleClass *class)
  83 {
  84   GtkObjectClass *object_class;
  85   GtkWidgetClass *widget_class;
  86   GtkRangeClass *range_class;
  87
  88   object_class = (GtkObjectClass*) class;
  89   range_class = (GtkRangeClass*) class;
  90   widget_class = (GtkWidgetClass*) class;
  91
  92   parent_class = gtk_type_class (GTK_TYPE_RANGE);
  93
  94   gtk_object_add_arg_type ("GtkScale::digits",
  95                            GTK_TYPE_INT,
  96                            GTK_ARG_READWRITE,
  97                            ARG_DIGITS);
  98   gtk_object_add_arg_type ("GtkScale::draw_value",
  99                            GTK_TYPE_BOOL,
 100                            GTK_ARG_READWRITE,
 101                            ARG_DRAW_VALUE);
 102   gtk_object_add_arg_type ("GtkScale::value_pos",
 103                            GTK_TYPE_POSITION_TYPE,
 104                            GTK_ARG_READWRITE,
 105                            ARG_VALUE_POS);
 106
 107   object_class->set_arg = gtk_scale_set_arg;
 108   object_class->get_arg = gtk_scale_get_arg;
 109
 110   widget_class->map = gtk_scale_map;
 111   widget_class->unmap = gtk_scale_unmap;
 112
 113   range_class->draw_background = gtk_scale_draw_background;
 114
 115   gtk_widget_class_install_style_property (widget_class,
 116                                            g_param_spec_int ("slider_length",
 117                                                              _("Slider Length"),
 118                                                              _("Length of scale's slider"),
 119                                                              0,
 120                                                              G_MAXINT,
 121                                                              31,
 122                                                              G_PARAM_READABLE));
 123   class->value_spacing = 2;
 124   class->draw_value = NULL;
 125 }
 126
 127 static void
 128 gtk_scale_set_arg (GtkObject      *object,
 129                    GtkArg         *arg,
 130                    guint           arg_id)
 131 {
 132   GtkScale *scale;
 133
 134   scale = GTK_SCALE (object);
 135
 136   switch (arg_id)
 137     {
 138     case ARG_DIGITS:
 139       gtk_scale_set_digits (scale, GTK_VALUE_INT (*arg));
 140       break;
 141     case ARG_DRAW_VALUE:
 142       gtk_scale_set_draw_value (scale, GTK_VALUE_BOOL (*arg));
 143       break;
 144     case ARG_VALUE_POS:
 145       gtk_scale_set_value_pos (scale, GTK_VALUE_ENUM (*arg));
 146       break;
 147     default:
 148       break;
 149     }
 150 }
 151
 152 static void
 153 gtk_scale_get_arg (GtkObject      *object,
 154                    GtkArg         *arg,
 155                    guint           arg_id)
 156 {
 157   GtkScale *scale;
 158
 159   scale = GTK_SCALE (object);
 160
 161   switch (arg_id)
 162     {
 163     case ARG_DIGITS:
 164       GTK_VALUE_INT (*arg) = GTK_RANGE (scale)->digits;
 165       break;
 166     case ARG_DRAW_VALUE:
 167       GTK_VALUE_BOOL (*arg) = scale->draw_value;
 168       break;
 169     case ARG_VALUE_POS:
 170       GTK_VALUE_ENUM (*arg) = scale->value_pos;
 171       break;
 172     default:
 173       arg->type = GTK_TYPE_INVALID;
 174       break;
 175     }
 176 }
 177
 178 static void
 179 gtk_scale_init (GtkScale *scale)
 180 {
 181   GTK_WIDGET_SET_FLAGS (scale, GTK_CAN_FOCUS);
 182   GTK_WIDGET_SET_FLAGS (scale, GTK_NO_WINDOW);
 183   GTK_RANGE (scale)->digits = 1;
 184   scale->draw_value = TRUE;
 185   scale->value_pos = GTK_POS_TOP;
 186 }
 187
 188 static void
 189 gtk_scale_map (GtkWidget *widget)
 190 {
 191   GtkRange *range;
 192
 193   g_return_if_fail (widget != NULL);
 194   g_return_if_fail (GTK_IS_SCALE (widget));
 195
 196   GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
 197   range = GTK_RANGE (widget);
 198
 199   gdk_window_show (range->trough);
 200 }
 201
 202 static void
 203 gtk_scale_unmap (GtkWidget *widget)
 204 {
 205   GtkRange *range;
 206
 207   g_return_if_fail (widget != NULL);
 208   g_return_if_fail (GTK_IS_SCALE (widget));
 209
 210   GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
 211   range = GTK_RANGE (widget);
 212
 213   if (GTK_WIDGET_NO_WINDOW (widget))
 214      gtk_widget_queue_clear (widget);
 215
 216   gdk_window_hide (range->trough);
 217 }
 218
 219 void
 220 gtk_scale_set_digits (GtkScale *scale,
 221                       gint      digits)
 222 {
 223   g_return_if_fail (scale != NULL);
 224   g_return_if_fail (GTK_IS_SCALE (scale));
 225
 226   digits = CLAMP (digits, -1, 16);
 227
 228   if (GTK_RANGE (scale)->digits != digits)
 229     {
 230       GTK_RANGE (scale)->digits = digits;
 231
 232       gtk_widget_queue_resize (GTK_WIDGET (scale));
 233     }
 234 }
 235
 236 void
 237 gtk_scale_set_draw_value (GtkScale *scale,
 238                           gboolean  draw_value)
 239 {
 240   g_return_if_fail (scale != NULL);
 241   g_return_if_fail (GTK_IS_SCALE (scale));
 242
 243   draw_value = draw_value != FALSE;
 244
 245   if (scale->draw_value != draw_value)
 246     {
 247       scale->draw_value = draw_value;
 248
 249       gtk_widget_queue_resize (GTK_WIDGET (scale));
 250     }
 251 }
 252
 253 void
 254 gtk_scale_set_value_pos (GtkScale        *scale,
 255                          GtkPositionType  pos)
 256 {
 257   g_return_if_fail (scale != NULL);
 258   g_return_if_fail (GTK_IS_SCALE (scale));
 259
 260   if (scale->value_pos != pos)
 261     {
 262       scale->value_pos = pos;
 263
 264       if (GTK_WIDGET_VISIBLE (scale) && GTK_WIDGET_MAPPED (scale))
 265         gtk_widget_queue_resize (GTK_WIDGET (scale));
 266     }
 267 }
 268
 269 void
 270 gtk_scale_get_value_size (GtkScale *scale,
 271                           gint     *width,
 272                           gint     *height)
 273 {
 274   GtkRange *range;
 275
 276   g_return_if_fail (scale != NULL);
 277   g_return_if_fail (GTK_IS_SCALE (scale));
 278
 279   if (scale->draw_value)
 280     {
 281       PangoLayout *layout;
 282       PangoRectangle logical_rect;
 283       gchar buffer[128];
 284       gdouble value;
 285       gint digits;
 286       gint i, j;
 287
 288       range = GTK_RANGE (scale);
 289
 290       layout = gtk_widget_create_pango_layout (GTK_WIDGET (scale), NULL);
 291
 292       value = ABS (range->adjustment->lower);
 293       if (value == 0) value = 1;
 294       digits = log10 (value) + 1;
 295       if (digits > 13)
 296         digits = 13;
 297
 298       i = 0;
 299       if (range->adjustment->lower < 0)
 300         buffer[i++] = '-';
 301       for (j = 0; j < digits; j++)
 302         buffer[i++] = '0';
 303       if (GTK_RANGE (scale)->digits)
 304         buffer[i++] = '.';
 305       for (j = 0; j < GTK_RANGE (scale)->digits; j++)
 306         buffer[i++] = '0';
 307       buffer[i] = '\0';
 308
 309       pango_layout_set_text (layout, buffer, i);
 310       pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
 311
 312       if (width)
 313         *width = logical_rect.width;
 314       if (height)
 315         *height = logical_rect.width;
 316
 317       value = ABS (range->adjustment->upper);
 318       if (value == 0) value = 1;
 319       digits = log10 (value) + 1;
 320       if (digits > 13)
 321         digits = 13;
 322
 323       i = 0;
 324       if (range->adjustment->upper < 0)
 325         buffer[i++] = '-';
 326       for (j = 0; j < digits; j++)
 327         buffer[i++] = '0';
 328       if (GTK_RANGE (scale)->digits)
 329         buffer[i++] = '.';
 330       for (j = 0; j < GTK_RANGE (scale)->digits; j++)
 331         buffer[i++] = '0';
 332       buffer[i] = '\0';
 333
 334       pango_layout_set_text (layout, buffer, i);
 335       pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
 336
 337       if (width)
 338         *width = MAX (*width, logical_rect.width);
 339       if (height)
 340         *height = MAX (*height, logical_rect.height);
 341
 342       g_object_unref (G_OBJECT (layout));
 343     }
 344   else
 345     {
 346       if (width)
 347         *width = 0;
 348       if (height)
 349         *height = 0;
 350     }
 351
 352 }
 353
 354 gint
 355 gtk_scale_get_value_width (GtkScale *scale)
 356 {
 357   gint width;
 358
 359   g_return_val_if_fail (scale != NULL, 0);
 360   g_return_val_if_fail (GTK_IS_SCALE (scale), 0);
 361
 362   gtk_scale_get_value_size (scale, &width, NULL);
 363
 364   return width;
 365 }
 366
 367 void
 368 gtk_scale_draw_value (GtkScale *scale)
 369 {
 370   g_return_if_fail (scale != NULL);
 371   g_return_if_fail (GTK_IS_SCALE (scale));
 372
 373   if (GTK_SCALE_GET_CLASS (scale)->draw_value)
 374     GTK_SCALE_GET_CLASS (scale)->draw_value (scale);
 375 }
 376
 377
 378 static void
 379 gtk_scale_draw_background (GtkRange *range)
 380 {
 381   g_return_if_fail (range != NULL);
 382   g_return_if_fail (GTK_IS_SCALE (range));
 383
 384   gtk_scale_draw_value (GTK_SCALE (range));
 385 }