src/ctl_knob.cpp

   1 /* Calf DSP Library
   2  * Knob control.
   3  * Copyright (C) 2007-2010 Krzysztof Foltman, Torben Hohn, Markus Schmidt
   4  * and others
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General
  17  * Public License along with this program; if not, write to the
  18  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  * Boston, MA  02110-1301  USA
  20  */
  21 #include "config.h"
  22 #include <calf/ctl_knob.h>
  23 #include <gdk/gdkkeysyms.h>
  24 #include <cairo/cairo.h>
  25 #include <malloc.h>
  26 #include <math.h>
  27 #include <stdint.h>
  28 #include <stdlib.h>
  29 #include <gdk/gdk.h>
  30
  31 ///////////////////////////////////////// knob ///////////////////////////////////////////////
  32
  33 static gboolean
  34 calf_knob_expose (GtkWidget *widget, GdkEventExpose *event)
  35 {
  36     g_assert(CALF_IS_KNOB(widget));
  37
  38     float widths[6]  = {0, 2, 4, 4.5, 4.5, 5.5};
  39     float margins[6] = {0, 2, 3, 5.5, 5, 7.5};
  40     float pins_m[6]  = {0, 4, 8, 12, 11, 21};
  41     float pins_s[6]  = {0, 3, 4, 4, 4, 5};
  42
  43     CalfKnob *self = CALF_KNOB(widget);
  44     GtkAdjustment *adj = gtk_range_get_adjustment(GTK_RANGE(widget));
  45     cairo_t *ctx = gdk_cairo_create(GDK_DRAWABLE(widget->window));
  46
  47     int ox = widget->allocation.x, oy = widget->allocation.y;
  48     ox += (widget->allocation.width - self->knob_size * 20) / 2;
  49     oy += (widget->allocation.height - self->knob_size * 20) / 2;
  50     int size  = self->knob_size * 20;
  51     int rad   = size / 2;
  52     int from  = self->knob_type == 3 ? 270 : 135;
  53     int to    = self->knob_type == 3 ? -90 : 45;
  54     int phase = (adj->value - adj->lower) * 270 / (adj->upper - adj->lower) + 135;
  55     int start;
  56     int neg_b = 0;
  57     int neg_l = 0;
  58
  59     cairo_rectangle(ctx, ox, oy, size + size / 2, size + size / 2);
  60     cairo_clip(ctx);
  61
  62     switch (self->knob_type) {
  63         case 0:
  64         default:
  65             // normal knob
  66             start = 135;
  67             break;
  68         case 1:
  69             // centered @ 270°
  70             if (adj->value < 0.5) {
  71                 neg_l = 1;
  72             } else {
  73                 phase = (adj->value - adj->lower) * 270 / (adj->upper - adj->lower) -225;
  74             }
  75             start = -90;
  76             break;
  77         case 2:
  78             // reversed
  79             neg_l = 1;
  80             start = 45;
  81             break;
  82         case 3:
  83             // 360°
  84             neg_l = 1;
  85             neg_b = 1;
  86             phase = (adj->value - adj->lower) * 360 / (adj->upper - adj->lower) + -90;
  87             start = phase;
  88             break;
  89     }
  90
  91     if (self->knob_type == 1 && phase == 270) {
  92         double pt = (adj->value - adj->lower) * 2.0 / (adj->upper - adj->lower) - 1.0;
  93         if (pt < 0)
  94             phase = 269;
  95         if (pt > 0)
  96             phase = 273;
  97     }
  98
  99     static const double dash[] = {2, 1};
 100     cairo_set_dash(ctx, dash, 2, 0);
 101     cairo_set_line_width(ctx, widths[self->knob_size]);
 102
 103     // draw background
 104     gdk_draw_pixbuf(GDK_DRAWABLE(widget->window),
 105                     widget->style->fg_gc[0],
 106                     CALF_KNOB_CLASS(GTK_OBJECT_GET_CLASS(widget))->knob_image[self->knob_size - 1],
 107                     0, 0, ox, oy,
 108                     gdk_pixbuf_get_width(CALF_KNOB_CLASS(GTK_OBJECT_GET_CLASS(widget))->knob_image[self->knob_size - 1]),
 109                     gdk_pixbuf_get_height(CALF_KNOB_CLASS(GTK_OBJECT_GET_CLASS(widget))->knob_image[self->knob_size - 1]),
 110                     GDK_RGB_DITHER_NORMAL, 0, 0);
 111
 112     // draw unlit
 113     if (neg_b)
 114         cairo_arc_negative (ctx, ox + rad, oy + rad, rad - margins[self->knob_size], from * (M_PI / 180.), to * (M_PI / 180.));
 115     else
 116         cairo_arc (ctx, ox + rad, oy + rad, rad - margins[self->knob_size], from * (M_PI / 180.), to * (M_PI / 180.));
 117     cairo_set_source_rgb(ctx, 0, 0.1, 0.1);
 118     cairo_stroke(ctx);
 119
 120     // draw lit
 121     float pos1 = (rad - margins[self->knob_size] + widths[self->knob_size] / 2.) / rad;
 122     float pos2 = (rad - margins[self->knob_size]) / rad;
 123     float pos3 = (rad - margins[self->knob_size] - widths[self->knob_size] / 2.) / rad;
 124     cairo_pattern_t *pat = cairo_pattern_create_radial(ox + rad, oy + rad, 0, ox + rad, oy + rad, rad);
 125     cairo_pattern_add_color_stop_rgba(pat, pos1, 0, 0.9, 1, 0.75);
 126     cairo_pattern_add_color_stop_rgba(pat, pos2, 0,   1, 1, 1.);
 127     cairo_pattern_add_color_stop_rgba(pat, pos3, 0, 0.9, 1, 0.75);
 128     cairo_set_source(ctx, pat);
 129     if (neg_l)
 130         cairo_arc_negative (ctx, ox + rad, oy + rad, rad - margins[self->knob_size], start * (M_PI / 180.), phase * (M_PI / 180.));
 131     else
 132         cairo_arc (ctx, ox + rad, oy + rad, rad - margins[self->knob_size], start * (M_PI / 180.), phase * (M_PI / 180.));
 133     cairo_stroke(ctx);
 134
 135     // draw light
 136     float x = ox + rad + (rad - margins[self->knob_size]) * cos(phase * (M_PI / 180.));
 137     float y = oy + rad + (rad - margins[self->knob_size]) * sin(phase * (M_PI / 180.));
 138     if (neg_b)
 139         cairo_arc_negative (ctx, ox + rad, oy + rad, rad - margins[self->knob_size], from * (M_PI / 180.), to * (M_PI / 180.));
 140     else
 141         cairo_arc (ctx, ox + rad, oy + rad, rad - margins[self->knob_size], from * (M_PI / 180.), to * (M_PI / 180.));
 142     pat = cairo_pattern_create_radial(x, y, widths[self->knob_size] / 2, x, y, widths[self->knob_size]);
 143     cairo_pattern_add_color_stop_rgba(pat, 0, 1, 1, 1, 1);
 144     cairo_pattern_add_color_stop_rgba(pat, 1, 0, 0.5, 0.8, 0.);
 145     cairo_set_source(ctx, pat);
 146     cairo_stroke(ctx);
 147
 148     // draw shine
 149     cairo_rectangle(ctx, ox, oy, size, size);
 150     pat = cairo_pattern_create_radial(x, y, 0, x, y, widths[self->knob_size] * 1.5);
 151     cairo_pattern_add_color_stop_rgba(pat, 0, 0.8, 1, 1, 0.7);
 152     cairo_pattern_add_color_stop_rgba(pat, 1, 0, 0.75, 1, 0.);
 153     cairo_set_source(ctx, pat);
 154     cairo_fill(ctx);
 155
 156     // draw other shine
 157     if (neg_l)
 158         cairo_arc_negative (ctx, ox + rad, oy + rad, rad - margins[self->knob_size] + widths[self->knob_size], start * (M_PI / 180.), phase * (M_PI / 180.));
 159     else
 160         cairo_arc (ctx, ox + rad, oy + rad, rad - margins[self->knob_size], start * (M_PI / 180.), phase * (M_PI / 180.));
 161     pos1 = (rad - margins[self->knob_size] + widths[self->knob_size]) / rad;
 162     pos2 = (rad - margins[self->knob_size]) / rad;
 163     pos3 = (rad - margins[self->knob_size] - widths[self->knob_size]) / rad;
 164     pat = cairo_pattern_create_radial(ox + rad, oy + rad, 0, ox + rad, oy + rad, rad);
 165     cairo_pattern_add_color_stop_rgba(pat, pos1,   0, 1, 1, 0.);
 166     cairo_pattern_add_color_stop_rgba(pat, pos2, 0.8, 1, 1, 0.6);
 167     cairo_pattern_add_color_stop_rgba(pat, pos3,   0, 1, 1, 0.);
 168     cairo_set_source(ctx, pat);
 169     cairo_set_line_width(ctx, widths[self->knob_size] * 2.);
 170     cairo_stroke(ctx);
 171
 172
 173     cairo_pattern_destroy(pat);
 174
 175     // draw pin
 176     float x1 = ox + rad + (rad - pins_m[self->knob_size]) * cos(phase * (M_PI / 180.));
 177     float y1 = oy + rad + (rad - pins_m[self->knob_size]) * sin(phase * (M_PI / 180.));
 178     float x2 = ox + rad + (rad - pins_s[self->knob_size] - pins_m[self->knob_size]) * cos(phase * (M_PI / 180.));
 179     float y2 = oy + rad + (rad - pins_s[self->knob_size] - pins_m[self->knob_size]) * sin(phase * (M_PI / 180.));
 180     cairo_move_to(ctx, x1, y1);
 181     cairo_line_to(ctx, x2, y2);
 182     cairo_set_dash(ctx, dash, 0, 0);
 183     float col = 0;
 184     cairo_set_source_rgba(ctx, col, col, col,0.5);
 185     cairo_set_line_width(ctx, widths[self->knob_size] / 2.);
 186     cairo_stroke(ctx);
 187     cairo_destroy(ctx);
 188
 189     return TRUE;
 190 }
 191
 192 static void
 193 calf_knob_size_request (GtkWidget *widget,
 194                            GtkRequisition *requisition)
 195 {
 196     g_assert(CALF_IS_KNOB(widget));
 197
 198     CalfKnob *self = CALF_KNOB(widget);
 199
 200     // width/height is hardwired at 40px now
 201     // is now chooseable by "size" value in XML (1-4)
 202     requisition->width  = 20 * self->knob_size;
 203     requisition->height = 20 * self->knob_size;
 204 }
 205
 206 static void
 207 calf_knob_incr (GtkWidget *widget, int dir_down)
 208 {
 209     g_assert(CALF_IS_KNOB(widget));
 210     CalfKnob *self = CALF_KNOB(widget);
 211     GtkAdjustment *adj = gtk_range_get_adjustment(GTK_RANGE(widget));
 212
 213     int oldstep = (int)(0.5f + (adj->value - adj->lower) / adj->step_increment);
 214     int step;
 215     int nsteps = (int)(0.5f + (adj->upper - adj->lower) / adj->step_increment); // less 1 actually
 216     if (dir_down)
 217         step = oldstep - 1;
 218     else
 219         step = oldstep + 1;
 220     if (self->knob_type == 3 && step >= nsteps)
 221         step %= nsteps;
 222     if (self->knob_type == 3 && step < 0)
 223         step = nsteps - (nsteps - step) % nsteps;
 224
 225     // trying to reduce error cumulation here, by counting from lowest or from highest
 226     float value = adj->lower + step * double(adj->upper - adj->lower) / nsteps;
 227     gtk_range_set_value(GTK_RANGE(widget), value);
 228     // printf("step %d:%d nsteps %d value %f:%f\n", oldstep, step, nsteps, oldvalue, value);
 229 }
 230
 231 static gboolean
 232 calf_knob_key_press (GtkWidget *widget, GdkEventKey *event)
 233 {
 234     g_assert(CALF_IS_KNOB(widget));
 235     CalfKnob *self = CALF_KNOB(widget);
 236     GtkAdjustment *adj = gtk_range_get_adjustment(GTK_RANGE(widget));
 237
 238     switch(event->keyval)
 239     {
 240         case GDK_Home:
 241             gtk_range_set_value(GTK_RANGE(widget), adj->lower);
 242             return TRUE;
 243
 244         case GDK_End:
 245             gtk_range_set_value(GTK_RANGE(widget), adj->upper);
 246             return TRUE;
 247
 248         case GDK_Up:
 249             calf_knob_incr(widget, 0);
 250             return TRUE;
 251
 252         case GDK_Down:
 253             calf_knob_incr(widget, 1);
 254             return TRUE;
 255
 256         case GDK_Shift_L:
 257         case GDK_Shift_R:
 258             self->start_value = gtk_range_get_value(GTK_RANGE(widget));
 259             self->start_y = self->last_y;
 260             return TRUE;
 261     }
 262
 263     return FALSE;
 264 }
 265
 266 static gboolean
 267 calf_knob_key_release (GtkWidget *widget, GdkEventKey *event)
 268 {
 269     g_assert(CALF_IS_KNOB(widget));
 270     CalfKnob *self = CALF_KNOB(widget);
 271
 272     if(event->keyval == GDK_Shift_L || event->keyval == GDK_Shift_R)
 273     {
 274         self->start_value = gtk_range_get_value(GTK_RANGE(widget));
 275         self->start_y = self->last_y;
 276         return TRUE;
 277     }
 278
 279     return FALSE;
 280 }
 281
 282 static gboolean
 283 calf_knob_button_press (GtkWidget *widget, GdkEventButton *event)
 284 {
 285     g_assert(CALF_IS_KNOB(widget));
 286     CalfKnob *self = CALF_KNOB(widget);
 287
 288     if (event->type == GDK_2BUTTON_PRESS) {
 289         gtk_range_set_value(GTK_RANGE(widget), self->default_value);
 290     }
 291
 292     // CalfKnob *lg = CALF_KNOB(widget);
 293     gtk_widget_grab_focus(widget);
 294     gtk_grab_add(widget);
 295     self->start_x = event->x;
 296     self->last_y = self->start_y = event->y;
 297     self->start_value = gtk_range_get_value(GTK_RANGE(widget));
 298
 299     return TRUE;
 300 }
 301
 302 static gboolean
 303 calf_knob_button_release (GtkWidget *widget, GdkEventButton *event)
 304 {
 305     g_assert(CALF_IS_KNOB(widget));
 306
 307     if (GTK_WIDGET_HAS_GRAB(widget))
 308         gtk_grab_remove(widget);
 309     return FALSE;
 310 }
 311
 312 static inline float endless(float value)
 313 {
 314     if (value >= 0)
 315         return fmod(value, 1.f);
 316     else
 317         return fmod(1.f - fmod(1.f - value, 1.f), 1.f);
 318 }
 319
 320 static inline float deadzone(GtkWidget *widget, float value, float incr)
 321 {
 322     // map to dead zone
 323     float ov = value;
 324     if (ov > 0.5)
 325         ov = 0.1 + ov;
 326     if (ov < 0.5)
 327         ov = ov - 0.1;
 328
 329     float nv = ov + incr;
 330
 331     if (nv > 0.6)
 332         return nv - 0.1;
 333     if (nv < 0.4)
 334         return nv + 0.1;
 335     return 0.5;
 336 }
 337
 338 static gboolean
 339 calf_knob_pointer_motion (GtkWidget *widget, GdkEventMotion *event)
 340 {
 341     g_assert(CALF_IS_KNOB(widget));
 342     CalfKnob *self = CALF_KNOB(widget);
 343
 344     float scale = (event->state & GDK_SHIFT_MASK) ? 2500 : 250;
 345     gboolean moved = FALSE;
 346
 347     if (GTK_WIDGET_HAS_GRAB(widget))
 348     {
 349         if (self->knob_type == 3)
 350         {
 351             gtk_range_set_value(GTK_RANGE(widget), endless(self->start_value - (event->y - self->start_y) / scale));
 352         }
 353         else
 354         if (self->knob_type == 1)
 355         {
 356             gtk_range_set_value(GTK_RANGE(widget), deadzone(GTK_WIDGET(widget), self->start_value, -(event->y - self->start_y) / scale));
 357         }
 358         else
 359         {
 360             gtk_range_set_value(GTK_RANGE(widget), self->start_value - (event->y - self->start_y) / scale);
 361         }
 362         moved = TRUE;
 363     }
 364     self->last_y = event->y;
 365     return moved;
 366 }
 367
 368 static gboolean
 369 calf_knob_scroll (GtkWidget *widget, GdkEventScroll *event)
 370 {
 371     calf_knob_incr(widget, event->direction);
 372     return TRUE;
 373 }
 374
 375 static void
 376 calf_knob_class_init (CalfKnobClass *klass)
 377 {
 378     // GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
 379     GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass);
 380     widget_class->expose_event = calf_knob_expose;
 381     widget_class->size_request = calf_knob_size_request;
 382     widget_class->button_press_event = calf_knob_button_press;
 383     widget_class->button_release_event = calf_knob_button_release;
 384     widget_class->motion_notify_event = calf_knob_pointer_motion;
 385     widget_class->key_press_event = calf_knob_key_press;
 386     widget_class->key_release_event = calf_knob_key_release;
 387     widget_class->scroll_event = calf_knob_scroll;
 388     GError *error = NULL;
 389     klass->knob_image[0] = gdk_pixbuf_new_from_file(PKGLIBDIR "/knob1.png", &error);
 390     klass->knob_image[1] = gdk_pixbuf_new_from_file(PKGLIBDIR "/knob2.png", &error);
 391     klass->knob_image[2] = gdk_pixbuf_new_from_file(PKGLIBDIR "/knob3.png", &error);
 392     klass->knob_image[3] = gdk_pixbuf_new_from_file(PKGLIBDIR "/knob4.png", &error);
 393     klass->knob_image[4] = gdk_pixbuf_new_from_file(PKGLIBDIR "/knob5.png", &error);
 394     g_assert(klass->knob_image != NULL);
 395 }
 396
 397 static void
 398 calf_knob_init (CalfKnob *self)
 399 {
 400     GtkWidget *widget = GTK_WIDGET(self);
 401     GTK_WIDGET_SET_FLAGS (GTK_WIDGET(self), GTK_CAN_FOCUS);
 402     widget->requisition.width = 40;
 403     widget->requisition.height = 40;
 404 }
 405
 406 GtkWidget *
 407 calf_knob_new()
 408 {
 409     GtkAdjustment *adj = (GtkAdjustment *)gtk_adjustment_new(0, 0, 1, 0.01, 0.5, 0);
 410     return calf_knob_new_with_adjustment(adj);
 411 }
 412
 413 static gboolean calf_knob_value_changed(gpointer obj)
 414 {
 415     GtkWidget *widget = (GtkWidget *)obj;
 416     gtk_widget_queue_draw(widget);
 417     return FALSE;
 418 }
 419
 420 GtkWidget *calf_knob_new_with_adjustment(GtkAdjustment *_adjustment)
 421 {
 422     GtkWidget *widget = GTK_WIDGET( g_object_new (CALF_TYPE_KNOB, NULL ));
 423     if (widget) {
 424         gtk_range_set_adjustment(GTK_RANGE(widget), _adjustment);
 425         g_signal_connect(GTK_OBJECT(widget), "value-changed", G_CALLBACK(calf_knob_value_changed), widget);
 426     }
 427     return widget;
 428 }
 429
 430 GType
 431 calf_knob_get_type (void)
 432 {
 433     static GType type = 0;
 434     if (!type) {
 435
 436         static const GTypeInfo type_info = {
 437             sizeof(CalfKnobClass),
 438             NULL, /* base_init */
 439             NULL, /* base_finalize */
 440             (GClassInitFunc)calf_knob_class_init,
 441             NULL, /* class_finalize */
 442             NULL, /* class_data */
 443             sizeof(CalfKnob),
 444             0,    /* n_preallocs */
 445             (GInstanceInitFunc)calf_knob_init
 446         };
 447
 448         for (int i = 0; ; i++) {
 449             char *name = g_strdup_printf("CalfKnob%u%d",
 450                 ((unsigned int)(intptr_t)calf_knob_class_init) >> 16, i);
 451             if (g_type_from_name(name)) {
 452                 free(name);
 453                 continue;
 454             }
 455             type = g_type_register_static(GTK_TYPE_RANGE,
 456                                           name,
 457                                           &type_info,
 458                                           (GTypeFlags)0);
 459             free(name);
 460             break;
 461         }
 462     }
 463     return type;
 464 }