gtk2_ardour/ardour_knob.cc

   1 /*
   2     Copyright (C) 2010 Paul Davis
   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., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include <iostream>
  21 #include <cmath>
  22 #include <algorithm>
  23
  24 #include <pangomm/layout.h>
  25
  26 #include "pbd/compose.h"
  27 #include "pbd/error.h"
  28 #include "pbd/stacktrace.h"
  29
  30 #include "gtkmm2ext/utils.h"
  31 #include "gtkmm2ext/rgb_macros.h"
  32 #include "gtkmm2ext/gui_thread.h"
  33 #include "gtkmm2ext/keyboard.h"
  34
  35 #include "ardour/rc_configuration.h" // for widget prelight preference
  36
  37 #include "ardour_knob.h"
  38 #include "ardour_ui.h"
  39 #include "global_signals.h"
  40
  41 #include "canvas/colors.h"
  42 #include "canvas/utils.h"
  43
  44 #include "i18n.h"
  45
  46 using namespace Gtkmm2ext;
  47 using namespace Gdk;
  48 using namespace Gtk;
  49 using namespace Glib;
  50 using namespace PBD;
  51 using std::max;
  52 using std::min;
  53 using namespace std;
  54
  55 ArdourKnob::Element ArdourKnob::default_elements = ArdourKnob::Element (ArdourKnob::Arc);
  56
  57 ArdourKnob::ArdourKnob (Element e, Flags flags)
  58         : _elements (e)
  59         , _hovering (false)
  60         , _grabbed_x (0)
  61         , _grabbed_y (0)
  62         , _val (0)
  63         , _normal (0)
  64         , _dead_zone_delta (0)
  65         , _flags (flags)
  66         , _tooltip (this)
  67 {
  68         ARDOUR_UI_UTILS::ColorsChanged.connect (sigc::mem_fun (*this, &ArdourKnob::color_handler));
  69 }
  70
  71 ArdourKnob::~ArdourKnob()
  72 {
  73 }
  74
  75 void
  76 ArdourKnob::render (cairo_t* cr, cairo_rectangle_t *)
  77 {
  78         cairo_pattern_t* shade_pattern;
  79
  80         float width = get_width();
  81         float height = get_height();
  82
  83         const float scale = min(width, height);
  84         const float pointer_thickness = 3.0 * (scale/80);  //(if the knob is 80 pixels wide, we want a 3-pix line on it)
  85
  86         const float start_angle = ((180 - 65) * G_PI) / 180;
  87         const float end_angle = ((360 + 65) * G_PI) / 180;
  88
  89         float zero = 0;
  90         if (_flags & ArcToZero) {
  91                 zero = _normal;
  92         }
  93
  94         const float value_angle = start_angle + (_val * (end_angle - start_angle));
  95         const float zero_angle = start_angle + (zero * (end_angle - start_angle));
  96
  97         float value_x = cos (value_angle);
  98         float value_y = sin (value_angle);
  99
 100         float xc =  0.5 + width/ 2.0;
 101         float yc = 0.5 + height/ 2.0;
 102
 103         cairo_translate (cr, xc, yc);  //after this, everything is based on the center of the knob
 104
 105         //get the knob color from the theme
 106         ArdourCanvas::Color knob_color = ARDOUR_UI::config()->color (string_compose ("%1", get_name()));
 107
 108         float center_radius = 0.48*scale;
 109         float border_width = 0.8;
 110
 111         bool arc = (_elements & Arc)==Arc;
 112         bool bevel = (_elements & Bevel)==Bevel;
 113         bool flat = _flat_buttons;
 114
 115         if ( arc ) {
 116                 center_radius = scale*0.33;
 117
 118                 float inner_progress_radius = scale*0.38;
 119                 float outer_progress_radius = scale*0.48;
 120                 float progress_width = (outer_progress_radius-inner_progress_radius);
 121                 float progress_radius = inner_progress_radius + progress_width/2.0;
 122
 123                 //dark arc background
 124                 cairo_set_source_rgb (cr, 0.3, 0.3, 0.3 );
 125                 cairo_set_line_width (cr, progress_width);
 126                 cairo_arc (cr, 0, 0, progress_radius, start_angle, end_angle);
 127                 cairo_stroke (cr);
 128
 129                 //look up the arc colors from the config
 130                 double red_start, green_start, blue_start, unused;
 131                 ArdourCanvas::Color arc_start_color = ARDOUR_UI::config()->color ( string_compose ("%1: arc start", get_name()));
 132                 ArdourCanvas::color_to_rgba( arc_start_color, red_start, green_start, blue_start, unused );
 133                 double red_end, green_end, blue_end;
 134                 ArdourCanvas::Color arc_end_color = ARDOUR_UI::config()->color ( string_compose ("%1: arc end", get_name()) );
 135                 ArdourCanvas::color_to_rgba( arc_end_color, red_end, green_end, blue_end, unused );
 136
 137                 //vary the arc color over the travel of the knob
 138                 float intensity = fabsf (_val - zero) / std::max(zero, (1.f - zero));
 139                 const float intensity_inv = 1.0 - intensity;
 140                 float r = intensity_inv * red_end   + intensity * red_start;
 141                 float g = intensity_inv * green_end + intensity * green_start;
 142                 float b = intensity_inv * blue_end  + intensity * blue_start;
 143
 144                 //draw the arc
 145                 cairo_set_source_rgb (cr, r,g,b);
 146                 cairo_set_line_width (cr, progress_width);
 147                 if (zero_angle > value_angle) {
 148                         cairo_arc (cr, 0, 0, progress_radius, value_angle, zero_angle);
 149                 } else {
 150                         cairo_arc (cr, 0, 0, progress_radius, zero_angle, value_angle);
 151                 }
 152                 cairo_stroke (cr);
 153
 154                 //shade the arc
 155                 if (!flat) {
 156                         shade_pattern = cairo_pattern_create_linear (0.0, -yc, 0.0,  yc);  //note we have to offset the pattern from our centerpoint
 157                         cairo_pattern_add_color_stop_rgba (shade_pattern, 0.0, 1,1,1, 0.15);
 158                         cairo_pattern_add_color_stop_rgba (shade_pattern, 0.5, 1,1,1, 0.0);
 159                         cairo_pattern_add_color_stop_rgba (shade_pattern, 1.0, 1,1,1, 0.0);
 160                         cairo_set_source (cr, shade_pattern);
 161                         cairo_arc (cr, 0, 0, outer_progress_radius-1, 0, 2.0*G_PI);
 162                         cairo_fill (cr);
 163                         cairo_pattern_destroy (shade_pattern);
 164                 }
 165
 166 #if 0 //black border
 167                 const float start_angle_x = cos (start_angle);
 168                 const float start_angle_y = sin (start_angle);
 169                 const float end_angle_x = cos (end_angle);
 170                 const float end_angle_y = sin (end_angle);
 171
 172                 cairo_set_source_rgb (cr, 0, 0, 0 );
 173                 cairo_set_line_width (cr, border_width);
 174                 cairo_move_to (cr, (outer_progress_radius * start_angle_x), (outer_progress_radius * start_angle_y));
 175                 cairo_line_to (cr, (inner_progress_radius * start_angle_x), (inner_progress_radius * start_angle_y));
 176                 cairo_stroke (cr);
 177                 cairo_move_to (cr, (outer_progress_radius * end_angle_x), (outer_progress_radius * end_angle_y));
 178                 cairo_line_to (cr, (inner_progress_radius * end_angle_x), (inner_progress_radius * end_angle_y));
 179                 cairo_stroke (cr);
 180                 cairo_arc (cr, 0, 0, outer_progress_radius, start_angle, end_angle);
 181                 cairo_stroke (cr);
 182 #endif
 183         }
 184
 185         if (!flat) {
 186                 //knob shadow
 187                 cairo_save(cr);
 188                 cairo_translate(cr, pointer_thickness+1, pointer_thickness+1 );
 189                 cairo_set_source_rgba (cr, 0, 0, 0, 0.1 );
 190                 cairo_arc (cr, 0, 0, center_radius-1, 0, 2.0*G_PI);
 191                 cairo_fill (cr);
 192                 cairo_restore(cr);
 193
 194                 //inner circle
 195                 ArdourCanvas::set_source_rgba(cr, knob_color);
 196                 cairo_arc (cr, 0, 0, center_radius, 0, 2.0*G_PI);
 197                 cairo_fill (cr);
 198
 199                 //gradient
 200                 if (bevel) {
 201                         //knob gradient
 202                         shade_pattern = cairo_pattern_create_linear (0.0, -yc, 0.0,  yc);  //note we have to offset the gradient from our centerpoint
 203                         cairo_pattern_add_color_stop_rgba (shade_pattern, 0.0, 1,1,1, 0.2);
 204                         cairo_pattern_add_color_stop_rgba (shade_pattern, 0.2, 1,1,1, 0.2);
 205                         cairo_pattern_add_color_stop_rgba (shade_pattern, 0.8, 0,0,0, 0.2);
 206                         cairo_pattern_add_color_stop_rgba (shade_pattern, 1.0, 0,0,0, 0.2);
 207                         cairo_set_source (cr, shade_pattern);
 208                         cairo_arc (cr, 0, 0, center_radius, 0, 2.0*G_PI);
 209                         cairo_fill (cr);
 210                         cairo_pattern_destroy (shade_pattern);
 211
 212                         //flat top over beveled edge
 213                         ArdourCanvas::set_source_rgb_a (cr, knob_color, 0.5 );
 214                         cairo_arc (cr, 0, 0, center_radius-pointer_thickness, 0, 2.0*G_PI);
 215                         cairo_fill (cr);
 216                 } else {
 217                         //radial gradient
 218                         shade_pattern = cairo_pattern_create_radial ( -center_radius, -center_radius, 1, -center_radius, -center_radius, center_radius*2.5  );  //note we have to offset the gradient from our centerpoint
 219                         cairo_pattern_add_color_stop_rgba (shade_pattern, 0.0, 1,1,1, 0.2);
 220                         cairo_pattern_add_color_stop_rgba (shade_pattern, 1.0, 0,0,0, 0.3);
 221                         cairo_set_source (cr, shade_pattern);
 222                         cairo_arc (cr, 0, 0, center_radius, 0, 2.0*G_PI);
 223                         cairo_fill (cr);
 224                         cairo_pattern_destroy (shade_pattern);
 225                 }
 226
 227         } else {
 228                 //inner circle
 229                 ArdourCanvas::set_source_rgba(cr, knob_color);
 230                 cairo_arc (cr, 0, 0, center_radius, 0, 2.0*G_PI);
 231                 cairo_fill (cr);
 232         }
 233
 234
 235         //black knob border
 236         cairo_set_line_width (cr, border_width);
 237         cairo_set_source_rgba (cr, 0,0,0, 1 );
 238         cairo_arc (cr, 0, 0, center_radius, 0, 2.0*G_PI);
 239         cairo_stroke (cr);
 240
 241         //line shadow
 242         if (!flat) {
 243                 cairo_save(cr);
 244                 cairo_translate(cr, 1, 1 );
 245                 cairo_set_source_rgba (cr, 0,0,0,0.3 );
 246                 cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
 247                 cairo_set_line_width (cr, pointer_thickness);
 248                 cairo_move_to (cr, (center_radius * value_x), (center_radius * value_y));
 249                 cairo_line_to (cr, ((center_radius*0.4) * value_x), ((center_radius*0.4) * value_y));
 250                 cairo_stroke (cr);
 251                 cairo_restore(cr);
 252         }
 253
 254         //line
 255         cairo_set_source_rgba (cr, 1,1,1, 1 );
 256         cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
 257         cairo_set_line_width (cr, pointer_thickness);
 258         cairo_move_to (cr, (center_radius * value_x), (center_radius * value_y));
 259         cairo_line_to (cr, ((center_radius*0.4) * value_x), ((center_radius*0.4) * value_y));
 260         cairo_stroke (cr);
 261
 262         //highlight if grabbed or if mouse is hovering over me
 263         if (_tooltip.dragging() || (_hovering && ARDOUR_UI::config()->get_widget_prelight() ) ) {
 264                 cairo_set_source_rgba (cr, 1,1,1, 0.12 );
 265                 cairo_arc (cr, 0, 0, center_radius, 0, 2.0*G_PI);
 266                 cairo_fill (cr);
 267         }
 268
 269         cairo_identity_matrix(cr);
 270 }
 271
 272 void
 273 ArdourKnob::on_size_request (Gtk::Requisition* req)
 274 {
 275         // see ardour-button VectorIcon size, use font scaling as default
 276         CairoWidget::on_size_request (req); // allow to override
 277
 278         // we're square
 279         if (req->width < req->height) {
 280                 req->width = req->height;
 281         }
 282         if (req->height < req->width) {
 283                 req->height = req->width;
 284         }
 285 }
 286
 287 bool
 288 ArdourKnob::on_scroll_event (GdkEventScroll* ev)
 289 {
 290         /* mouse wheel */
 291
 292         float scale = 0.05;  //by default, we step in 1/20ths of the knob travel
 293         if (ev->state & Keyboard::GainFineScaleModifier) {
 294                 if (ev->state & Keyboard::GainExtraFineScaleModifier) {
 295                         scale *= 0.01;
 296                 } else {
 297                         scale *= 0.10;
 298                 }
 299         }
 300
 301         boost::shared_ptr<PBD::Controllable> c = binding_proxy.get_controllable();
 302         if (c) {
 303                 float val = c->get_interface();
 304
 305                 if ( ev->direction == GDK_SCROLL_UP )
 306                         val += scale;
 307                 else
 308                         val -= scale;
 309
 310                 c->set_interface(val);
 311         }
 312
 313         return true;
 314 }
 315
 316 bool
 317 ArdourKnob::on_motion_notify_event (GdkEventMotion *ev)
 318 {
 319         if (!(ev->state & Gdk::BUTTON1_MASK)) {
 320                 return true;
 321         }
 322
 323         boost::shared_ptr<PBD::Controllable> c = binding_proxy.get_controllable();
 324         if (!c) {
 325                 return true;
 326         }
 327
 328
 329         //scale the adjustment based on keyboard modifiers & GUI size
 330         const float ui_scale = max (1.f, ARDOUR_UI::ui_scale);
 331         float scale = 0.0025 / ui_scale;
 332
 333         if (ev->state & Keyboard::GainFineScaleModifier) {
 334                 if (ev->state & Keyboard::GainExtraFineScaleModifier) {
 335                         scale *= 0.01;
 336                 } else {
 337                         scale *= 0.10;
 338                 }
 339         }
 340
 341         //calculate the travel of the mouse
 342         int delta = (_grabbed_y - ev->y) - (_grabbed_x - ev->x);
 343         if (delta == 0) {
 344                 return true;
 345         }
 346
 347         _grabbed_x = ev->x;
 348         _grabbed_y = ev->y;
 349         float val = c->get_interface();
 350
 351         if (_flags & Detent) {
 352                 const float px_deadzone = 42.f * ui_scale;
 353
 354                 if ((val - _normal) * (val - _normal + delta * scale) < 0) {
 355                         /* detent */
 356                         const int tozero = (_normal - val) * scale;
 357                         int remain = delta - tozero;
 358                         if (abs (remain) > px_deadzone) {
 359                                 /* slow down passing the default value */
 360                                 remain += (remain > 0) ? px_deadzone * -.5 : px_deadzone * .5;
 361                                 delta = tozero + remain;
 362                                 _dead_zone_delta = 0;
 363                         } else {
 364                                 c->set_interface(_normal);
 365                                 val = _normal;
 366                                 _dead_zone_delta = remain / px_deadzone;
 367                                 return true;
 368                         }
 369                 }
 370
 371                 if (fabsf (rintf((val - _normal) / scale) + _dead_zone_delta) < 1) {
 372                         c->set_interface(_normal);
 373                         _dead_zone_delta += delta / px_deadzone;
 374                         return true;
 375                 }
 376
 377                 _dead_zone_delta = 0;
 378         }
 379
 380         val += delta * scale;
 381         c->set_interface(val);
 382
 383         return true;
 384 }
 385
 386 bool
 387 ArdourKnob::on_button_press_event (GdkEventButton *ev)
 388 {
 389         _grabbed_x = ev->x;
 390         _grabbed_y = ev->y;
 391         _dead_zone_delta = 0;
 392
 393         if (ev->type != GDK_BUTTON_PRESS) {
 394                 if (_grabbed) {
 395                         remove_modal_grab();
 396                         gdk_pointer_ungrab (GDK_CURRENT_TIME);
 397                 }
 398                 return true;
 399         }
 400
 401         if (binding_proxy.button_press_handler (ev)) {
 402                 return true;
 403         }
 404
 405         if (ev->button != 1 && ev->button != 2) {
 406                 return false;
 407         }
 408
 409         set_active_state (Gtkmm2ext::ExplicitActive);
 410         _tooltip.start_drag();
 411         add_modal_grab();
 412         _grabbed = true;
 413         gdk_pointer_grab(ev->window,false,
 414                         GdkEventMask( Gdk::POINTER_MOTION_MASK | Gdk::BUTTON_PRESS_MASK |Gdk::BUTTON_RELEASE_MASK),
 415                         NULL,NULL,ev->time);
 416         return true;
 417 }
 418
 419 bool
 420 ArdourKnob::on_button_release_event (GdkEventButton *ev)
 421 {
 422         _tooltip.stop_drag();
 423         _grabbed = false;
 424         remove_modal_grab();
 425         gdk_pointer_ungrab (GDK_CURRENT_TIME);
 426
 427         if ( (_grabbed_y == ev->y && _grabbed_x == ev->x) && Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {  //no move, shift-click sets to default
 428                 boost::shared_ptr<PBD::Controllable> c = binding_proxy.get_controllable();
 429                 if (!c) return false;
 430                 c->set_value (c->normal());
 431                 return true;
 432         }
 433
 434         unset_active_state ();
 435
 436         return true;
 437 }
 438
 439 void
 440 ArdourKnob::color_handler ()
 441 {
 442         set_dirty ();
 443 }
 444
 445 void
 446 ArdourKnob::on_size_allocate (Allocation& alloc)
 447 {
 448         CairoWidget::on_size_allocate (alloc);
 449 }
 450
 451 void
 452 ArdourKnob::set_controllable (boost::shared_ptr<Controllable> c)
 453 {
 454     watch_connection.disconnect ();  //stop watching the old controllable
 455
 456         if (!c) return;
 457
 458         binding_proxy.set_controllable (c);
 459
 460         c->Changed.connect (watch_connection, invalidator(*this), boost::bind (&ArdourKnob::controllable_changed, this), gui_context());
 461
 462         _normal = c->internal_to_interface(c->normal());
 463
 464         controllable_changed();
 465 }
 466
 467 void
 468 ArdourKnob::controllable_changed ()
 469 {
 470         boost::shared_ptr<PBD::Controllable> c = binding_proxy.get_controllable();
 471
 472         _val = c->get_interface();  //% of knob travel
 473         _val = min( max(0.0f, _val), 1.0f);  //range check
 474
 475         if (!_tooltip_prefix.empty()) {
 476                 _tooltip.set_tip (_tooltip_prefix + c->get_user_string());
 477         }
 478         set_dirty();
 479 }
 480
 481 void
 482 ArdourKnob::on_style_changed (const RefPtr<Gtk::Style>&)
 483 {
 484         set_dirty ();
 485 }
 486
 487 void
 488 ArdourKnob::on_name_changed ()
 489 {
 490         set_dirty ();
 491 }
 492
 493
 494 void
 495 ArdourKnob::set_active_state (Gtkmm2ext::ActiveState s)
 496 {
 497         if (_active_state != s)
 498                 CairoWidget::set_active_state (s);
 499 }
 500
 501 void
 502 ArdourKnob::set_visual_state (Gtkmm2ext::VisualState s)
 503 {
 504         if (_visual_state != s)
 505                 CairoWidget::set_visual_state (s);
 506 }
 507
 508
 509 bool
 510 ArdourKnob::on_focus_in_event (GdkEventFocus* ev)
 511 {
 512         set_dirty ();
 513         return CairoWidget::on_focus_in_event (ev);
 514 }
 515
 516 bool
 517 ArdourKnob::on_focus_out_event (GdkEventFocus* ev)
 518 {
 519         set_dirty ();
 520         return CairoWidget::on_focus_out_event (ev);
 521 }
 522
 523 bool
 524 ArdourKnob::on_enter_notify_event (GdkEventCrossing* ev)
 525 {
 526         _hovering = true;
 527
 528         set_dirty ();
 529
 530         return CairoWidget::on_enter_notify_event (ev);
 531 }
 532
 533 bool
 534 ArdourKnob::on_leave_notify_event (GdkEventCrossing* ev)
 535 {
 536         _hovering = false;
 537
 538         set_dirty ();
 539
 540         return CairoWidget::on_leave_notify_event (ev);
 541 }
 542
 543 void
 544 ArdourKnob::set_elements (Element e)
 545 {
 546         _elements = e;
 547 }
 548
 549 void
 550 ArdourKnob::add_elements (Element e)
 551 {
 552         _elements = (ArdourKnob::Element) (_elements | e);
 553 }
 554
 555
 556 KnobPersistentTooltip::KnobPersistentTooltip (Gtk::Widget* w)
 557         : PersistentTooltip (w, 3)
 558         , _dragging (false)
 559 {
 560 }
 561
 562 void
 563 KnobPersistentTooltip::start_drag ()
 564 {
 565         _dragging = true;
 566 }
 567
 568 void
 569 KnobPersistentTooltip::stop_drag ()
 570 {
 571         _dragging = false;
 572 }
 573
 574 bool
 575 KnobPersistentTooltip::dragging () const
 576 {
 577         return _dragging;
 578 }