src/gtkknob.c

   1 /* gAlan - Graphical Audio Language
   2  * Copyright (C) 1999 Tony Garnock-Jones
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program 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
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #include <math.h>
  20 #include <stdio.h>
  21 #include <gtk/gtkmain.h>
  22 #include <gtk/gtksignal.h>
  23
  24 #include <gdk-pixbuf/gdk-pixbuf.h>
  25
  26 #include "gtkknob.h"
  27
  28 #ifndef M_PI
  29 # define M_PI           3.14159265358979323846  /* pi */
  30 #endif
  31
  32 #define SCROLL_DELAY_LENGTH     300
  33 #define KNOB_SIZE               32
  34
  35 #define STATE_IDLE              0
  36 #define STATE_PRESSED           1
  37 #define STATE_DRAGGING          2
  38
  39
  40 /* Forward declarations */
  41
  42 static void gtk_knob_class_init(GtkKnobClass *klass);
  43 static void gtk_knob_init(GtkKnob *knob);
  44 static void gtk_knob_destroy(GtkObject *object);
  45 static void gtk_knob_realize(GtkWidget *widget);
  46 static void gtk_knob_size_request(GtkWidget *widget, GtkRequisition *requisition);
  47 static void gtk_knob_size_allocate(GtkWidget *widget, GtkAllocation *allocation);
  48 static gint gtk_knob_expose(GtkWidget *widget, GdkEventExpose *event);
  49 static gint gtk_knob_button_press(GtkWidget *widget, GdkEventButton *event);
  50 static gint gtk_knob_button_release(GtkWidget *widget, GdkEventButton *event);
  51 static gint gtk_knob_motion_notify(GtkWidget *widget, GdkEventMotion *event);
  52 static gint gtk_knob_timer(GtkKnob *knob);
  53
  54 static void gtk_knob_update_mouse_update(GtkKnob *knob);
  55 static void gtk_knob_update_mouse(GtkKnob *knob, gint x, gint y);
  56 static void gtk_knob_update_mouse_abs(GtkKnob *knob, gint x, gint y);
  57 static void gtk_knob_update(GtkKnob *knob);
  58 static void gtk_knob_adjustment_changed(GtkAdjustment *adjustment, gpointer data);
  59 static void gtk_knob_adjustment_value_changed(GtkAdjustment *adjustment, gpointer data);
  60
  61 /* Local data */
  62
  63 static GtkWidgetClass *parent_class = NULL;
  64 static GList *animation = NULL;
  65
  66
  67 // Old gif loading code... will be removed soon...
  68 #if 0
  69 static GList *get_anim_list( char *name ) {
  70
  71    GError *err = NULL;
  72    GTimeVal time;
  73    GdkPixbufAnimation *animation;
  74    GdkPixbufAnimationIter *iter;
  75    GList *retval = NULL;
  76
  77    animation = gdk_pixbuf_animation_new_from_file( name, &err );
  78    g_get_current_time( &time );
  79    iter = gdk_pixbuf_animation_get_iter( animation, &time );
  80
  81    while(1) {
  82        GdkPixbuf *pixbuf = gdk_pixbuf_animation_iter_get_pixbuf(iter);
  83        int delay = gdk_pixbuf_animation_iter_get_delay_time( iter );
  84
  85        retval = g_list_append( retval, gdk_pixbuf_copy( pixbuf ) );
  86
  87        if( gdk_pixbuf_animation_iter_on_currently_loading_frame( iter ) )
  88            return retval;
  89
  90        if( delay == -1 )
  91            break;
  92        if( g_list_length( retval ) > 300 )
  93            break;
  94
  95        g_time_val_add( &time, delay*1000 );
  96        gdk_pixbuf_animation_iter_advance( iter, &time );
  97    }
  98    return retval;
  99 }
 100 #endif
 101
 102 static GList *get_anim_list( char *name ) {
 103
 104    GError *err = NULL;
 105    GdkPixbuf *animation;
 106    GList *retval = NULL;
 107    int x, w;
 108
 109    animation = gdk_pixbuf_new_from_file( name, &err );
 110    if( animation ) {
 111        w = gdk_pixbuf_get_width( animation );
 112
 113        for(x=0; x<w; x+=KNOB_SIZE ) {
 114            GdkPixbuf *pixbuf = gdk_pixbuf_new_subpixbuf( animation, x, 0, KNOB_SIZE, KNOB_SIZE );
 115            retval = g_list_append( retval, pixbuf );
 116        }
 117        return retval;
 118    } else {
 119        // Create empty GdkPixBuf...
 120        return NULL;
 121    }
 122 }
 123
 124 void free_anim_list( GList *anim_list )
 125 {
 126     // g_list_foreach( anim_list, gdk_pixbuf_unref );
 127 }
 128
 129
 130 guint gtk_knob_get_type(void) {
 131   static guint knob_type = 0;
 132
 133   if (!knob_type) {
 134     GtkTypeInfo knob_info = {
 135       "GtkKnob",
 136       sizeof (GtkKnob),
 137       sizeof (GtkKnobClass),
 138       (GtkClassInitFunc) gtk_knob_class_init,
 139       (GtkObjectInitFunc) gtk_knob_init,
 140       NULL,
 141       NULL,
 142     };
 143
 144     knob_type = gtk_type_unique(gtk_widget_get_type(), &knob_info);
 145   }
 146
 147   return knob_type;
 148 }
 149
 150 static void gtk_knob_class_init (GtkKnobClass *class) {
 151   GtkObjectClass *object_class;
 152   GtkWidgetClass *widget_class;
 153
 154   //animation = get_anim_list( PIXMAPDIRIFY("knob.gif") );
 155   animation = get_anim_list( PIXMAPDIRIFY("new-knob02.png") );
 156   object_class = (GtkObjectClass*) class;
 157   widget_class = (GtkWidgetClass*) class;
 158
 159   parent_class = gtk_type_class(gtk_widget_get_type());
 160
 161   object_class->destroy = gtk_knob_destroy;
 162
 163   widget_class->realize = gtk_knob_realize;
 164   widget_class->expose_event = gtk_knob_expose;
 165   widget_class->size_request = gtk_knob_size_request;
 166   widget_class->size_allocate = gtk_knob_size_allocate;
 167   widget_class->button_press_event = gtk_knob_button_press;
 168   widget_class->button_release_event = gtk_knob_button_release;
 169   widget_class->motion_notify_event = gtk_knob_motion_notify;
 170 }
 171
 172 static void gtk_knob_init (GtkKnob *knob) {
 173   knob->policy = GTK_UPDATE_CONTINUOUS;
 174   knob->state = STATE_IDLE;
 175   knob->saved_x = knob->saved_y = 0;
 176   knob->timer = 0;
 177   knob->pixbuf = NULL;
 178   knob->anim_list = animation;
 179   knob->old_value = 0.0;
 180   knob->old_lower = 0.0;
 181   knob->old_upper = 0.0;
 182   knob->adjustment = NULL;
 183 }
 184
 185
 186
 187
 188
 189 GtkWidget *gtk_knob_new(GtkAdjustment *adjustment) {
 190   GtkKnob *knob;
 191
 192   knob = gtk_type_new(gtk_knob_get_type());
 193
 194   if (!adjustment)
 195     adjustment = (GtkAdjustment*) gtk_adjustment_new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
 196
 197   gtk_knob_set_adjustment(knob, adjustment);
 198
 199   return GTK_WIDGET(knob);
 200 }
 201
 202 static void gtk_knob_destroy(GtkObject *object) {
 203   GtkKnob *knob;
 204
 205   g_return_if_fail(object != NULL);
 206   g_return_if_fail(GTK_IS_KNOB(object));
 207
 208   knob = GTK_KNOB(object);
 209
 210   if (knob->adjustment) {
 211     gtk_object_unref(GTK_OBJECT(knob->adjustment));
 212     knob->adjustment = NULL;
 213   }
 214
 215   if (knob->pixbuf) {
 216     gdk_pixbuf_unref(knob->pixbuf);
 217     knob->pixbuf = NULL;
 218   }
 219
 220   if (GTK_OBJECT_CLASS(parent_class)->destroy)
 221     (*GTK_OBJECT_CLASS(parent_class)->destroy)(object);
 222 }
 223
 224 GtkAdjustment* gtk_knob_get_adjustment(GtkKnob *knob) {
 225   g_return_val_if_fail(knob != NULL, NULL);
 226   g_return_val_if_fail(GTK_IS_KNOB(knob), NULL);
 227
 228   return knob->adjustment;
 229 }
 230
 231 void gtk_knob_set_update_policy(GtkKnob *knob, GtkUpdateType policy) {
 232   g_return_if_fail (knob != NULL);
 233   g_return_if_fail (GTK_IS_KNOB (knob));
 234
 235   knob->policy = policy;
 236 }
 237
 238 void gtk_knob_set_adjustment(GtkKnob *knob, GtkAdjustment *adjustment) {
 239   g_return_if_fail (knob != NULL);
 240   g_return_if_fail (GTK_IS_KNOB (knob));
 241
 242   if (knob->adjustment) {
 243     gtk_signal_disconnect_by_data(GTK_OBJECT(knob->adjustment), (gpointer)knob);
 244     gtk_object_unref(GTK_OBJECT(knob->adjustment));
 245   }
 246
 247   knob->adjustment = adjustment;
 248   gtk_object_ref(GTK_OBJECT(knob->adjustment));
 249   gtk_object_sink(GTK_OBJECT( knob->adjustment ) );
 250
 251   gtk_signal_connect(GTK_OBJECT(adjustment), "changed",
 252                      GTK_SIGNAL_FUNC(gtk_knob_adjustment_changed), (gpointer) knob);
 253   gtk_signal_connect(GTK_OBJECT(adjustment), "value_changed",
 254                      GTK_SIGNAL_FUNC(gtk_knob_adjustment_value_changed), (gpointer) knob);
 255
 256   knob->old_value = adjustment->value;
 257   knob->old_lower = adjustment->lower;
 258   knob->old_upper = adjustment->upper;
 259
 260   gtk_knob_update(knob);
 261 }
 262
 263 static void gtk_knob_realize(GtkWidget *widget) {
 264   GtkKnob *knob;
 265   GdkWindowAttr attributes;
 266   gint attributes_mask;
 267
 268   g_return_if_fail(widget != NULL);
 269   g_return_if_fail(GTK_IS_KNOB(widget));
 270
 271   GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);
 272   knob = GTK_KNOB(widget);
 273
 274   attributes.x = widget->allocation.x;
 275   attributes.y = widget->allocation.y;
 276   attributes.width = widget->allocation.width;
 277   attributes.height = widget->allocation.height;
 278   attributes.wclass = GDK_INPUT_OUTPUT;
 279   attributes.window_type = GDK_WINDOW_CHILD;
 280   attributes.event_mask =
 281     gtk_widget_get_events (widget) |
 282     GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK |
 283     GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK |
 284     GDK_POINTER_MOTION_HINT_MASK;
 285   attributes.visual = gtk_widget_get_visual(widget);
 286   attributes.colormap = gtk_widget_get_colormap(widget);
 287
 288   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 289   widget->window = gdk_window_new(widget->parent->window, &attributes, attributes_mask);
 290
 291   widget->style = gtk_style_attach(widget->parent->style, widget->window);
 292
 293   gdk_window_set_user_data(widget->window, widget);
 294
 295
 296   gtk_style_set_background(widget->style, widget->window, GTK_STATE_NORMAL);
 297 }
 298
 299 static void gtk_knob_size_request (GtkWidget *widget, GtkRequisition *requisition) {
 300   requisition->width = KNOB_SIZE;
 301   requisition->height = KNOB_SIZE;
 302 }
 303
 304 static void gtk_knob_size_allocate (GtkWidget *widget, GtkAllocation *allocation) {
 305   GtkKnob *knob;
 306
 307   g_return_if_fail(widget != NULL);
 308   g_return_if_fail(GTK_IS_KNOB(widget));
 309   g_return_if_fail(allocation != NULL);
 310
 311   widget->allocation = *allocation;
 312   knob = GTK_KNOB(widget);
 313
 314   if (GTK_WIDGET_REALIZED(widget)) {
 315     gdk_window_move_resize(widget->window,
 316                            allocation->x, allocation->y,
 317                            allocation->width, allocation->height);
 318   }
 319 }
 320
 321 static gint gtk_knob_expose(GtkWidget *widget, GdkEventExpose *event) {
 322   GtkKnob *knob;
 323   gfloat dx, dy;
 324   GList *framelist;
 325
 326   g_return_val_if_fail(widget != NULL, FALSE);
 327   g_return_val_if_fail(GTK_IS_KNOB(widget), FALSE);
 328   g_return_val_if_fail(event != NULL, FALSE);
 329
 330   if (event->count > 0)
 331     return FALSE;
 332
 333   knob = GTK_KNOB(widget);
 334
 335   gdk_window_clear_area(widget->window, 0, 0, widget->allocation.width, widget->allocation.height);
 336
 337   dx = knob->adjustment->value - knob->adjustment->lower;
 338   dy = knob->adjustment->upper - knob->adjustment->lower;
 339   framelist = knob->anim_list;
 340
 341   if (dy != 0) {
 342     GdkPixbuf *pixbuf;
 343
 344     dx = MIN(MAX(dx / dy, 0), 1);
 345     //dx = (1-dx) * (g_list_length( framelist )-0.5) * 0.75 + 0.125 * g_list_length( framelist );
 346     dx = (dx) * (g_list_length( framelist ) - 1 );
 347
 348     pixbuf = g_list_nth_data( framelist, (int) dx);
 349
 350     gdk_pixbuf_render_to_drawable_alpha( pixbuf, widget->window,
 351             0, 0, 0, 0, gdk_pixbuf_get_width( pixbuf ), gdk_pixbuf_get_height( pixbuf ), GDK_PIXBUF_ALPHA_FULL, 0, 0,0,0 );
 352   }
 353
 354
 355
 356
 357   return FALSE;
 358 }
 359
 360 static gint gtk_knob_button_press(GtkWidget *widget, GdkEventButton *event) {
 361   GtkKnob *knob;
 362
 363   g_return_val_if_fail(widget != NULL, FALSE);
 364   g_return_val_if_fail(GTK_IS_KNOB(widget), FALSE);
 365   g_return_val_if_fail(event != NULL, FALSE);
 366
 367   knob = GTK_KNOB(widget);
 368
 369   switch (knob->state) {
 370     case STATE_IDLE:
 371       switch (event->button) {
 372 #if 0
 373         case 3:
 374           gtk_knob_update_mouse_abs(knob, event->x, event->y);
 375           /* FALL THROUGH */
 376 #endif
 377
 378         case 1:
 379         case 3:
 380           gtk_grab_add(widget);
 381           knob->state = STATE_PRESSED;
 382           knob->saved_x = event->x;
 383           knob->saved_y = event->y;
 384           break;
 385
 386         default:
 387           break;
 388       }
 389       break;
 390
 391     default:
 392       break;
 393   }
 394
 395   return FALSE;
 396 }
 397
 398 static gint gtk_knob_button_release(GtkWidget *widget, GdkEventButton *event) {
 399   GtkKnob *knob;
 400
 401   g_return_val_if_fail(widget != NULL, FALSE);
 402   g_return_val_if_fail(GTK_IS_KNOB(widget), FALSE);
 403   g_return_val_if_fail(event != NULL, FALSE);
 404
 405   knob = GTK_KNOB(widget);
 406
 407   switch (knob->state) {
 408     case STATE_PRESSED:
 409       gtk_grab_remove(widget);
 410       knob->state = STATE_IDLE;
 411
 412       switch (event->button) {
 413         case 1:
 414           knob->adjustment->value -= knob->adjustment->page_increment;
 415           gtk_signal_emit_by_name(GTK_OBJECT(knob->adjustment), "value_changed");
 416           break;
 417
 418         case 3:
 419           knob->adjustment->value += knob->adjustment->page_increment;
 420           gtk_signal_emit_by_name(GTK_OBJECT(knob->adjustment), "value_changed");
 421           break;
 422
 423         default:
 424           break;
 425       }
 426       break;
 427
 428     case STATE_DRAGGING:
 429       gtk_grab_remove(widget);
 430       knob->state = STATE_IDLE;
 431
 432       if (knob->policy != GTK_UPDATE_CONTINUOUS && knob->old_value != knob->adjustment->value)
 433         gtk_signal_emit_by_name(GTK_OBJECT(knob->adjustment), "value_changed");
 434
 435       break;
 436
 437     default:
 438       break;
 439   }
 440
 441   return FALSE;
 442 }
 443
 444 static gint gtk_knob_motion_notify(GtkWidget *widget, GdkEventMotion *event) {
 445   GtkKnob *knob;
 446   GdkModifierType mods;
 447   gint x, y;
 448
 449   g_return_val_if_fail(widget != NULL, FALSE);
 450   g_return_val_if_fail(GTK_IS_KNOB(widget), FALSE);
 451   g_return_val_if_fail(event != NULL, FALSE);
 452
 453   knob = GTK_KNOB(widget);
 454
 455   x = event->x;
 456   y = event->y;
 457
 458   if (event->is_hint || (event->window != widget->window))
 459     gdk_window_get_pointer(widget->window, &x, &y, &mods);
 460
 461   switch (knob->state) {
 462     case STATE_PRESSED:
 463       knob->state = STATE_DRAGGING;
 464       /* fall through */
 465
 466     case STATE_DRAGGING:
 467       if (mods & GDK_BUTTON1_MASK) {
 468         gtk_knob_update_mouse(knob, x, y);
 469         return TRUE;
 470       } else if (mods & GDK_BUTTON3_MASK) {
 471         gtk_knob_update_mouse_abs(knob, x, y);
 472         return TRUE;
 473       }
 474       break;
 475
 476     default:
 477       break;
 478   }
 479
 480   return FALSE;
 481 }
 482
 483 static gint gtk_knob_timer(GtkKnob *knob) {
 484   g_return_val_if_fail(knob != NULL, FALSE);
 485   g_return_val_if_fail(GTK_IS_KNOB(knob), FALSE);
 486
 487   if (knob->policy == GTK_UPDATE_DELAYED)
 488     gtk_signal_emit_by_name(GTK_OBJECT(knob->adjustment), "value_changed");
 489
 490   return FALSE; /* don't keep running this timer */
 491 }
 492
 493 static void gtk_knob_update_mouse_update(GtkKnob *knob) {
 494   if (knob->policy == GTK_UPDATE_CONTINUOUS)
 495     gtk_signal_emit_by_name(GTK_OBJECT(knob->adjustment), "value_changed");
 496   else {
 497     gtk_widget_draw(GTK_WIDGET(knob), NULL);
 498
 499     if (knob->policy == GTK_UPDATE_DELAYED) {
 500       if (knob->timer)
 501         gtk_timeout_remove(knob->timer);
 502
 503       knob->timer = gtk_timeout_add (SCROLL_DELAY_LENGTH, (GtkFunction) gtk_knob_timer,
 504                                      (gpointer) knob);
 505     }
 506   }
 507 }
 508
 509 static void gtk_knob_update_mouse(GtkKnob *knob, gint x, gint y) {
 510   gfloat old_value;
 511   gfloat dv;
 512
 513   g_return_if_fail(knob != NULL);
 514   g_return_if_fail(GTK_IS_KNOB(knob));
 515
 516   old_value = knob->adjustment->value;
 517
 518   dv = (knob->saved_y - y) * knob->adjustment->step_increment;
 519   knob->saved_x = x;
 520   knob->saved_y = y;
 521
 522   knob->adjustment->value += dv;
 523
 524   if (knob->adjustment->value != old_value)
 525     gtk_knob_update_mouse_update(knob);
 526 }
 527
 528 static void gtk_knob_update_mouse_abs(GtkKnob *knob, gint x, gint y) {
 529   gfloat old_value;
 530   gdouble angle;
 531
 532   g_return_if_fail(knob != NULL);
 533   g_return_if_fail(GTK_IS_KNOB(knob));
 534
 535   old_value = knob->adjustment->value;
 536
 537   x -= KNOB_SIZE>>1;
 538   y -= KNOB_SIZE>>1;
 539   y = -y;       /* inverted cartesian graphics coordinate system */
 540
 541   angle = atan2(y, x) / M_PI;
 542   if (angle < -0.5)
 543     angle += 2;
 544
 545   angle = -(2.0/3.0) * (angle - 1.25);  /* map [1.25pi, -0.25pi] onto [0, 1] */
 546   angle *= knob->adjustment->upper - knob->adjustment->lower;
 547   angle += knob->adjustment->lower;
 548
 549   knob->adjustment->value = angle;
 550
 551   if (knob->adjustment->value != old_value)
 552     gtk_knob_update_mouse_update(knob);
 553 }
 554
 555 static void gtk_knob_update(GtkKnob *knob) {
 556   gfloat new_value;
 557
 558   g_return_if_fail(knob != NULL);
 559   g_return_if_fail(GTK_IS_KNOB (knob));
 560
 561   new_value = knob->adjustment->value;
 562
 563   if (new_value < knob->adjustment->lower)
 564     new_value = knob->adjustment->lower;
 565
 566   if (new_value > knob->adjustment->upper)
 567     new_value = knob->adjustment->upper;
 568
 569   if (new_value != knob->adjustment->value) {
 570     knob->adjustment->value = new_value;
 571     gtk_signal_emit_by_name(GTK_OBJECT(knob->adjustment), "value_changed");
 572   }
 573
 574   gtk_widget_draw(GTK_WIDGET(knob), NULL);
 575 }
 576
 577 static void gtk_knob_adjustment_changed(GtkAdjustment *adjustment, gpointer data) {
 578   GtkKnob *knob;
 579
 580   g_return_if_fail(adjustment != NULL);
 581   g_return_if_fail(data != NULL);
 582
 583   knob = GTK_KNOB(data);
 584
 585   if ((knob->old_value != adjustment->value) ||
 586       (knob->old_lower != adjustment->lower) ||
 587       (knob->old_upper != adjustment->upper)) {
 588     gtk_knob_update (knob);
 589
 590     knob->old_value = adjustment->value;
 591     knob->old_lower = adjustment->lower;
 592     knob->old_upper = adjustment->upper;
 593   }
 594 }
 595
 596 static void gtk_knob_adjustment_value_changed (GtkAdjustment *adjustment, gpointer data) {
 597   GtkKnob *knob;
 598
 599   g_return_if_fail(adjustment != NULL);
 600   g_return_if_fail(data != NULL);
 601
 602   knob = GTK_KNOB(data);
 603
 604   if (knob->old_value != adjustment->value) {
 605     gtk_knob_update (knob);
 606
 607     knob->old_value = adjustment->value;
 608   }
 609 }