Pileus Git - ~andy/gtk/blob - gtk/gtkvscale.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 2001 Red Hat, Inc.
   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 <stdio.h>
  28 #include "gtkvscale.h"
  29 #include "gtksignal.h"
  30 #include "gtkintl.h"
  31
  32 #define VALUE_SPACING 2
  33
  34 static gpointer parent_class;
  35
  36 static void     gtk_vscale_class_init       (GtkVScaleClass *klass);
  37 static void     gtk_vscale_init             (GtkVScale      *vscale);
  38 static gboolean gtk_vscale_expose           (GtkWidget      *widget,
  39                                              GdkEventExpose *event);
  40
  41 GtkType
  42 gtk_vscale_get_type (void)
  43 {
  44   static GtkType vscale_type = 0;
  45
  46   if (!vscale_type)
  47     {
  48       static const GtkTypeInfo vscale_info =
  49       {
  50         "GtkVScale",
  51         sizeof (GtkVScale),
  52         sizeof (GtkVScaleClass),
  53         (GtkClassInitFunc) gtk_vscale_class_init,
  54         (GtkObjectInitFunc) gtk_vscale_init,
  55         /* reserved_1 */ NULL,
  56         /* reserved_2 */ NULL,
  57         (GtkClassInitFunc) NULL,
  58       };
  59
  60       vscale_type = gtk_type_unique (GTK_TYPE_SCALE, &vscale_info);
  61     }
  62
  63   return vscale_type;
  64 }
  65
  66 static void
  67 gtk_vscale_class_init (GtkVScaleClass *class)
  68 {
  69   GObjectClass   *gobject_class;
  70   GtkWidgetClass *widget_class;
  71   GtkRangeClass *range_class;
  72
  73   gobject_class = G_OBJECT_CLASS (class);
  74   widget_class = GTK_WIDGET_CLASS (class);
  75   range_class = GTK_RANGE_CLASS (class);
  76
  77   parent_class = g_type_class_peek_parent (class);
  78
  79   range_class->slider_detail = "vscale";
  80
  81   widget_class->expose_event = gtk_vscale_expose;
  82 }
  83
  84 static void
  85 gtk_vscale_init (GtkVScale *vscale)
  86 {
  87   GtkRange *range;
  88
  89   range = GTK_RANGE (vscale);
  90
  91   range->orientation = GTK_ORIENTATION_VERTICAL;
  92 }
  93
  94 GtkWidget*
  95 gtk_vscale_new (GtkAdjustment *adjustment)
  96 {
  97   GtkWidget *vscale;
  98
  99   vscale = gtk_widget_new (GTK_TYPE_VSCALE,
 100                            "adjustment", adjustment,
 101                            NULL);
 102
 103   return vscale;
 104 }
 105
 106
 107 /**
 108  * gtk_vscale_new_with_range:
 109  * @min: minimum value
 110  * @max: maximum value
 111  * @step: step increment (tick size) used with keyboard shortcuts
 112  *
 113  * Creates a new vertical scale widget that lets the user
 114  * input a number between @min and @max with the increment @step.
 115  * @step must be nonzero; it's the distance the slider moves when
 116  * using the arrow keys to adjust the scale value.
 117  *
 118  * Return value: a new #GtkVScale
 119  **/
 120 GtkWidget*
 121 gtk_vscale_new_with_range (gdouble min,
 122                            gdouble max,
 123                            gdouble step)
 124 {
 125   GtkObject *adj;
 126   GtkScale *scale;
 127   gint digits;
 128
 129   g_return_val_if_fail (min < max, NULL);
 130   g_return_val_if_fail (step != 0.0, NULL);
 131
 132   adj = gtk_adjustment_new (min, min, max, step, 10 * step, step);
 133
 134   scale = g_object_new (GTK_TYPE_VSCALE,
 135                         "adjustment", adj,
 136                         NULL);
 137
 138   if (fabs (step) >= 1.0 || step == 0.0)
 139     digits = 0;
 140   else {
 141     digits = abs ((gint) floor (log10 (fabs (step))));
 142     if (digits > 5)
 143       digits = 5;
 144   }
 145
 146   gtk_scale_set_digits (scale, digits);
 147
 148   return GTK_WIDGET (scale);
 149 }
 150
 151 static gboolean
 152 gtk_vscale_expose (GtkWidget      *widget,
 153                    GdkEventExpose *event)
 154 {
 155   GtkRange *range;
 156   GtkVScale *vscale;
 157   GtkScale *scale;
 158
 159   range = GTK_RANGE (widget);
 160   scale = GTK_SCALE (widget);
 161   vscale = GTK_VSCALE (widget);
 162
 163   if (scale->draw_value)
 164     {
 165       PangoLayout *layout;
 166       PangoRectangle logical_rect;
 167       gchar *txt;
 168       gint x, y;
 169       GtkStateType state_type;
 170       gint value_spacing;
 171
 172       gtk_widget_style_get (widget, "value_spacing", &value_spacing, NULL);
 173
 174       txt = _gtk_scale_format_value (scale,
 175                                      GTK_RANGE (scale)->adjustment->value);
 176
 177       layout = gtk_widget_create_pango_layout (widget, txt);
 178       g_free (txt);
 179
 180       pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
 181
 182       switch (scale->value_pos)
 183         {
 184         case GTK_POS_LEFT:
 185           x = range->range_rect.x - logical_rect.width - value_spacing;
 186           y = range->slider_start + (range->slider_end - range->slider_start - logical_rect.height) / 2;
 187           y = CLAMP (y, 0, widget->allocation.height - logical_rect.height);
 188           break;
 189
 190         case GTK_POS_RIGHT:
 191           x = range->range_rect.x + range->range_rect.width + value_spacing;
 192           y = range->slider_start + (range->slider_end - range->slider_start - logical_rect.height) / 2;
 193           y = CLAMP (y, 0, widget->allocation.height - logical_rect.height);
 194           break;
 195
 196         case GTK_POS_TOP:
 197           x = range->range_rect.x + (range->range_rect.width - logical_rect.width) / 2;
 198           y = range->range_rect.y - logical_rect.height - value_spacing;
 199           break;
 200
 201         case GTK_POS_BOTTOM:
 202           x = range->range_rect.x + (range->range_rect.width - logical_rect.width) / 2;
 203           y = range->range_rect.y + range->range_rect.height + value_spacing;
 204           break;
 205
 206         default:
 207           g_return_val_if_reached (FALSE);
 208           x = 0;
 209           y = 0;
 210           break;
 211         }
 212
 213       state_type = GTK_STATE_NORMAL;
 214       if (!GTK_WIDGET_IS_SENSITIVE (scale))
 215         state_type = GTK_STATE_INSENSITIVE;
 216
 217       gtk_paint_layout (widget->style,
 218                         widget->window,
 219                         state_type,
 220                         FALSE,
 221                         NULL,
 222                         widget,
 223                         "vscale",
 224                         x, y,
 225                         layout);
 226
 227       g_object_unref (G_OBJECT (layout));
 228     }
 229
 230   return (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
 231 }