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