gtk2_ardour/gtk-custom-ruler.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 Library 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  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library 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-1999.  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 /* modified by andreas meyer <hexx3000@gmx.de> */
  28
  29 #include <stdio.h>
  30 #include "gtk-custom-ruler.h"
  31
  32 enum
  33 {
  34         ARG_0,
  35         ARG_LOWER,
  36         ARG_UPPER,
  37         ARG_POSITION,
  38         ARG_MAX_SIZE,
  39         ARG_SHOW_POSITION
  40 };
  41
  42 static void gtk_custom_ruler_class_init (GtkCustomRulerClass * klass);
  43 static void gtk_custom_ruler_init (GtkCustomRuler * ruler);
  44 static void gtk_custom_ruler_realize (GtkWidget * widget);
  45 static void gtk_custom_ruler_unrealize (GtkWidget * widget);
  46 static void gtk_custom_ruler_size_allocate (GtkWidget * widget, GtkAllocation * allocation);
  47 static gint gtk_custom_ruler_expose (GtkWidget * widget, GdkEventExpose * event);
  48 static void gtk_custom_ruler_make_pixmap (GtkCustomRuler * ruler);
  49 static void gtk_custom_ruler_set_arg (GtkObject * object, GtkArg * arg, guint arg_id);
  50 static void gtk_custom_ruler_get_arg (GtkObject * object, GtkArg * arg, guint arg_id);
  51
  52 static gint
  53 default_metric_get_marks (GtkCustomRulerMark **marks, gulong lower, gulong upper, gint maxchars)
  54 {
  55         return 0;
  56 }
  57
  58 static const GtkCustomMetric default_metric = {
  59         1.0,
  60         default_metric_get_marks
  61 };
  62
  63 static GtkWidgetClass *parent_class;
  64
  65 GtkType gtk_custom_ruler_get_type (void)
  66 {
  67         static GtkType ruler_type = 0;
  68
  69         if (!ruler_type) {
  70                 static const GtkTypeInfo ruler_info = {
  71                         "GtkCustomRuler",
  72                         sizeof (GtkCustomRuler),
  73                         sizeof (GtkCustomRulerClass),
  74                         (GtkClassInitFunc) gtk_custom_ruler_class_init,
  75                         (GtkObjectInitFunc) gtk_custom_ruler_init,
  76                         /* reserved_1 */ NULL,
  77                         /* reserved_2 */ NULL,
  78                         (GtkClassInitFunc) NULL,
  79                 };
  80                 ruler_type = gtk_type_unique (GTK_TYPE_WIDGET, &ruler_info);
  81         }
  82         return ruler_type;
  83 }
  84
  85 static void
  86 gtk_custom_ruler_class_init (GtkCustomRulerClass * class)
  87 {
  88         GtkObjectClass *object_class;
  89         GtkWidgetClass *widget_class;
  90
  91         object_class = (GtkObjectClass *) class;
  92         widget_class = (GtkWidgetClass *) class;
  93
  94         parent_class = gtk_type_class (GTK_TYPE_WIDGET);
  95
  96         object_class->set_arg = gtk_custom_ruler_set_arg;
  97         object_class->get_arg = gtk_custom_ruler_get_arg;
  98
  99         widget_class->realize = gtk_custom_ruler_realize;
 100         widget_class->unrealize = gtk_custom_ruler_unrealize;
 101         widget_class->size_allocate = gtk_custom_ruler_size_allocate;
 102         widget_class->expose_event = gtk_custom_ruler_expose;
 103
 104         class->draw_ticks = NULL;
 105         class->draw_pos = NULL;
 106
 107         gtk_object_add_arg_type ("GtkCustomRuler::lower", GTK_TYPE_ULONG, GTK_ARG_READWRITE, ARG_LOWER);
 108         gtk_object_add_arg_type ("GtkCustomRuler::upper", GTK_TYPE_ULONG, GTK_ARG_READWRITE, ARG_UPPER);
 109         gtk_object_add_arg_type ("GtkCustomRuler::position", GTK_TYPE_ULONG, GTK_ARG_READWRITE, ARG_POSITION);
 110         gtk_object_add_arg_type ("GtkCustomRuler::max_size", GTK_TYPE_ULONG, GTK_ARG_READWRITE, ARG_MAX_SIZE);
 111         gtk_object_add_arg_type ("GtkCustomRuler::show_position", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_SHOW_POSITION);
 112 }
 113
 114 static void
 115 gtk_custom_ruler_init (GtkCustomRuler * ruler)
 116 {
 117         ruler->backing_store = NULL;
 118         ruler->non_gr_exp_gc = NULL;
 119         ruler->xsrc = 0;
 120         ruler->ysrc = 0;
 121         ruler->slider_size = 0;
 122         ruler->lower = 0;
 123         ruler->upper = 0;
 124         ruler->position = 0;
 125         ruler->max_size = 0;
 126         ruler->show_position = FALSE;
 127
 128         gtk_custom_ruler_set_metric (ruler, NULL);
 129 }
 130
 131 static void
 132 gtk_custom_ruler_set_arg (GtkObject * object, GtkArg * arg, guint arg_id)
 133 {
 134         GtkCustomRuler *ruler = GTK_CUSTOM_RULER (object);
 135
 136         switch (arg_id) {
 137         case ARG_LOWER:
 138                 gtk_custom_ruler_set_range (ruler, GTK_VALUE_ULONG (*arg), ruler->upper, ruler->position, ruler->max_size);
 139                 break;
 140         case ARG_UPPER:
 141                 gtk_custom_ruler_set_range (ruler, ruler->lower, GTK_VALUE_ULONG (*arg), ruler->position, ruler->max_size);
 142                 break;
 143         case ARG_POSITION:
 144                 gtk_custom_ruler_set_range (ruler, ruler->lower, ruler->upper, GTK_VALUE_ULONG (*arg), ruler->max_size);
 145                 break;
 146         case ARG_MAX_SIZE:
 147                 gtk_custom_ruler_set_range (ruler, ruler->lower, ruler->upper, ruler->position, GTK_VALUE_ULONG (*arg));
 148                 break;
 149         case ARG_SHOW_POSITION:
 150                 // gtk_customer_ruler_set_show_position (ruler, GTK_VALUE_BOOL (*arg));
 151                 break;
 152         }
 153 }
 154
 155 static void
 156 gtk_custom_ruler_get_arg (GtkObject * object, GtkArg * arg, guint arg_id)
 157 {
 158         GtkCustomRuler *ruler = GTK_CUSTOM_RULER (object);
 159
 160         switch (arg_id) {
 161         case ARG_LOWER:
 162                 GTK_VALUE_ULONG (*arg) = ruler->lower;
 163                 break;
 164         case ARG_UPPER:
 165                 GTK_VALUE_ULONG (*arg) = ruler->upper;
 166                 break;
 167         case ARG_POSITION:
 168                 GTK_VALUE_ULONG (*arg) = ruler->position;
 169                 break;
 170         case ARG_MAX_SIZE:
 171                 GTK_VALUE_ULONG (*arg) = ruler->max_size;
 172                 break;
 173         case ARG_SHOW_POSITION:
 174                 GTK_VALUE_BOOL (*arg) = ruler->show_position;
 175                 break;
 176         default:
 177                 arg->type = GTK_TYPE_INVALID;
 178                 break;
 179         }
 180 }
 181
 182 void
 183 gtk_custom_ruler_set_metric (GtkCustomRuler * ruler, GtkCustomMetric * metric)
 184 {
 185         g_return_if_fail (ruler != NULL);
 186         g_return_if_fail (GTK_IS_CUSTOM_RULER (ruler));
 187
 188         if (metric == NULL)
 189                 ruler->metric = (GtkCustomMetric *) & default_metric;
 190         else
 191                 ruler->metric = metric;
 192
 193         if (GTK_WIDGET_DRAWABLE (ruler))
 194                 gtk_widget_queue_draw (GTK_WIDGET (ruler));
 195 }
 196
 197 void
 198 gtk_custom_ruler_set_range (GtkCustomRuler * ruler, gulong lower, gulong upper, gulong position, gulong max_size)
 199 {
 200         g_return_if_fail (ruler != NULL);
 201         g_return_if_fail (GTK_IS_CUSTOM_RULER (ruler));
 202
 203         ruler->lower = lower;
 204         ruler->upper = upper;
 205         ruler->position = position;
 206         ruler->max_size = max_size;
 207
 208         if (GTK_WIDGET_DRAWABLE (ruler))
 209                 gtk_widget_queue_draw (GTK_WIDGET (ruler));
 210 }
 211
 212 void
 213 gtk_custom_ruler_draw_ticks (GtkCustomRuler * ruler)
 214 {
 215     GtkCustomRulerClass *klass;
 216         g_return_if_fail (ruler != NULL);
 217         g_return_if_fail (GTK_IS_CUSTOM_RULER (ruler));
 218
 219         klass = GTK_CUSTOM_RULER_CLASS (GTK_OBJECT (ruler));
 220         if (klass->draw_ticks)
 221                 klass->draw_ticks (ruler);
 222 }
 223
 224 void
 225 gtk_custom_ruler_draw_pos (GtkCustomRuler * ruler)
 226 {
 227     GtkCustomRulerClass *klass;
 228     g_return_if_fail (ruler != NULL);
 229     g_return_if_fail (GTK_IS_CUSTOM_RULER (ruler));
 230
 231     klass = GTK_CUSTOM_RULER_CLASS (GTK_OBJECT (ruler));
 232     if (klass->draw_pos && ruler->show_position)
 233             klass->draw_pos (ruler);
 234 }
 235
 236 static void
 237 gtk_custom_ruler_realize (GtkWidget * widget)
 238 {
 239         GtkCustomRuler *ruler;
 240         GdkWindowAttr attributes;
 241         gint attributes_mask;
 242
 243         g_return_if_fail (widget != NULL);
 244         g_return_if_fail (GTK_IS_CUSTOM_RULER (widget));
 245
 246         ruler = GTK_CUSTOM_RULER (widget);
 247         GTK_WIDGET_SET_FLAGS (ruler, GTK_REALIZED);
 248
 249         attributes.window_type = GDK_WINDOW_CHILD;
 250         attributes.x = widget->allocation.x;
 251         attributes.y = widget->allocation.y;
 252         attributes.width = widget->allocation.width;
 253         attributes.height = widget->allocation.height;
 254         attributes.wclass = GDK_INPUT_OUTPUT;
 255         attributes.visual = gtk_widget_get_visual (widget);
 256         attributes.colormap = gtk_widget_get_colormap (widget);
 257         attributes.event_mask = gtk_widget_get_events (widget);
 258         attributes.event_mask |= (GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
 259
 260         attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 261
 262         widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
 263         gdk_window_set_user_data (widget->window, ruler);
 264
 265         widget->style = gtk_style_attach (widget->style, widget->window);
 266         gtk_style_set_background (widget->style, widget->window, GTK_STATE_ACTIVE);
 267
 268         gtk_custom_ruler_make_pixmap (ruler);
 269 }
 270
 271 static void
 272 gtk_custom_ruler_unrealize (GtkWidget * widget)
 273 {
 274         GtkCustomRuler *ruler;
 275
 276         g_return_if_fail (widget != NULL);
 277         g_return_if_fail (GTK_IS_CUSTOM_RULER (widget));
 278
 279         ruler = GTK_CUSTOM_RULER (widget);
 280
 281         if (ruler->backing_store)
 282                 gdk_pixmap_unref (ruler->backing_store);
 283         if (ruler->non_gr_exp_gc)
 284                 gdk_gc_destroy (ruler->non_gr_exp_gc);
 285
 286         ruler->backing_store = NULL;
 287         ruler->non_gr_exp_gc = NULL;
 288
 289         if (GTK_WIDGET_CLASS (parent_class)->unrealize)
 290                 (*GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
 291 }
 292
 293 static void
 294 gtk_custom_ruler_size_allocate (GtkWidget * widget, GtkAllocation * allocation)
 295 {
 296         GtkCustomRuler *ruler;
 297
 298         g_return_if_fail (widget != NULL);
 299         g_return_if_fail (GTK_IS_CUSTOM_RULER (widget));
 300
 301         ruler = GTK_CUSTOM_RULER (widget);
 302         widget->allocation = *allocation;
 303
 304         if (GTK_WIDGET_REALIZED (widget)) {
 305                 gdk_window_move_resize (widget->window, allocation->x, allocation->y, allocation->width, allocation->height);
 306
 307                 gtk_custom_ruler_make_pixmap (ruler);
 308         }
 309 }
 310
 311 static gint
 312 gtk_custom_ruler_expose (GtkWidget * widget, GdkEventExpose * event)
 313 {
 314         GtkCustomRuler *ruler;
 315
 316         g_return_val_if_fail (widget != NULL, FALSE);
 317         g_return_val_if_fail (GTK_IS_CUSTOM_RULER (widget), FALSE);
 318         g_return_val_if_fail (event != NULL, FALSE);
 319
 320         if (GTK_WIDGET_DRAWABLE (widget)) {
 321                 ruler = GTK_CUSTOM_RULER (widget);
 322
 323                 gtk_custom_ruler_draw_ticks (ruler);
 324
 325                 gdk_draw_pixmap (widget->window,
 326                                  ruler->non_gr_exp_gc,
 327                                  ruler->backing_store, 0, 0, 0, 0, widget->allocation.width, widget->allocation.height);
 328
 329                 gtk_custom_ruler_draw_pos (ruler);
 330         }
 331
 332         return FALSE;
 333 }
 334
 335 static void
 336 gtk_custom_ruler_make_pixmap (GtkCustomRuler * ruler)
 337 {
 338         GtkWidget *widget;
 339         gint width;
 340         gint height;
 341
 342         widget = GTK_WIDGET (ruler);
 343
 344         if (ruler->backing_store) {
 345                 gdk_window_get_size (ruler->backing_store, &width, &height);
 346                 if ((width == widget->allocation.width) && (height == widget->allocation.height))
 347                         return;
 348
 349                 gdk_pixmap_unref (ruler->backing_store);
 350         }
 351
 352         ruler->backing_store = gdk_pixmap_new (widget->window, widget->allocation.width, widget->allocation.height, -1);
 353
 354         ruler->xsrc = 0;
 355         ruler->ysrc = 0;
 356
 357         if (!ruler->non_gr_exp_gc) {
 358                 ruler->non_gr_exp_gc = gdk_gc_new (widget->window);
 359                 gdk_gc_set_exposures (ruler->non_gr_exp_gc, FALSE);
 360         }
 361 }
 362
 363 void
 364 gtk_custom_ruler_set_show_position (GtkCustomRuler * ruler, gboolean yn)
 365 {
 366         ruler->show_position = yn;
 367 }