libs/surfaces/faderport8/actions.cc

   1 /* Faderport 8 Control Surface
   2  * This is the button "Controller" of the MVC surface inteface,
   3  * see callbacks.cc for the "View".
   4  *
   5  * Copyright (C) 2017 Robin Gareus <robin@gareus.org>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20  */
  21
  22 #include "ardour/dB.h"
  23 #include "ardour/plugin_insert.h"
  24 #include "ardour/session.h"
  25 #include "ardour/session_configuration.h"
  26 #include "ardour/types.h"
  27
  28 #include "gtkmm2ext/actions.h"
  29
  30 #include "faderport8.h"
  31
  32 #include "pbd/i18n.h"
  33
  34 using namespace ARDOUR;
  35 using namespace ArdourSurface;
  36 using namespace std;
  37 using namespace ArdourSurface::FP8Types;
  38
  39 #define BindMethod(ID, CB) \
  40         _ctrls.button (FP8Controls::ID).released.connect_same_thread (button_connections, boost::bind (&FaderPort8:: CB, this));
  41
  42 #define BindFunction(ID, ACT, CB, ...) \
  43         _ctrls.button (FP8Controls::ID). ACT .connect_same_thread (button_connections, boost::bind (&FaderPort8:: CB, this, __VA_ARGS__));
  44
  45 #define BindAction(ID, GRP, ITEM) \
  46         _ctrls.button (FP8Controls::ID).released.connect_same_thread (button_connections, boost::bind (&FaderPort8::button_action, this, GRP, ITEM));
  47
  48 #define BindUserAction(ID) \
  49         _ctrls.button (ID).pressed.connect_same_thread (button_connections, boost::bind (&FaderPort8::button_user, this, true, ID)); \
  50 _ctrls.button (ID).released.connect_same_thread (button_connections, boost::bind (&FaderPort8::button_user, this, false, ID));
  51
  52
  53 /* Bind button signals (press, release) to callback methods
  54  * (called once after constructing buttons).
  55  * Bound actions are handled the the ctrl-surface thread.
  56  */
  57 void
  58 FaderPort8::setup_actions ()
  59 {
  60         BindMethod (BtnPlay, button_play);
  61         BindMethod (BtnStop, button_stop);
  62         BindMethod (BtnLoop, button_loop);
  63         BindMethod (BtnRecord, button_record);
  64         BindMethod (BtnClick, button_metronom);
  65         BindAction (BtnRedo, "Editor", "redo");
  66
  67         BindAction (BtnSave, "Common", "Save");
  68         BindAction (BtnUndo, "Editor", "undo");
  69         BindAction (BtnRedo, "Editor", "redo");
  70
  71 #ifdef FP8_MUTESOLO_UNDO
  72         BindMethod (BtnSoloClear, button_solo_clear);
  73 #else
  74         BindAction (BtnSoloClear, "Main", "cancel-solo");
  75 #endif
  76         BindMethod (BtnMuteClear, button_mute_clear);
  77
  78         BindMethod (FP8Controls::BtnArmAll, button_arm_all);
  79
  80         BindFunction (BtnRewind, pressed, button_varispeed, false);
  81         BindFunction (BtnFastForward, pressed, button_varispeed, true);
  82
  83         BindFunction (BtnPrev, released, button_prev_next, false);
  84         BindFunction (BtnNext, released, button_prev_next, true);
  85
  86         BindFunction (BtnArm, pressed, button_arm, true);
  87         BindFunction (BtnArm, released, button_arm, false);
  88
  89         BindFunction (BtnAOff, released, button_automation, ARDOUR::Off);
  90         BindFunction (BtnATouch, released, button_automation, ARDOUR::Touch);
  91         BindFunction (BtnARead, released, button_automation, ARDOUR::Play);
  92         BindFunction (BtnAWrite, released, button_automation, ARDOUR::Write);
  93
  94         _ctrls.button (FP8Controls::BtnEncoder).pressed.connect_same_thread (button_connections, boost::bind (&FaderPort8::button_encoder, this));
  95         _ctrls.button (FP8Controls::BtnParam).pressed.connect_same_thread (button_connections, boost::bind (&FaderPort8::button_parameter, this));
  96
  97
  98         BindMethod (BtnBypass, button_bypass);
  99         BindAction (BtnBypassAll, "Mixer", "ab-plugins");
 100
 101         BindAction (BtnMacro, "Common", "toggle-editor-and-mixer");
 102         BindMethod (BtnOpen, button_open);
 103
 104         BindMethod (BtnLink, button_link);
 105         BindMethod (BtnLock, button_lock);
 106
 107         // user-specific
 108         for (FP8Controls::UserButtonMap::const_iterator i = _ctrls.user_buttons ().begin ();
 109                         i != _ctrls.user_buttons ().end (); ++i) {
 110                 BindUserAction ((*i).first);
 111         }
 112 }
 113
 114 /* ****************************************************************************
 115  * Direct control callback Actions
 116  */
 117
 118 void
 119 FaderPort8::button_play ()
 120 {
 121         if (session->transport_rolling ()) {
 122                 if (session->transport_speed () != 1.0) {
 123                         session->request_transport_speed (1.0);
 124                 } else {
 125                         transport_stop ();
 126                 }
 127         } else {
 128                 transport_play ();
 129         }
 130 }
 131
 132 void
 133 FaderPort8::button_stop ()
 134 {
 135         if (session->transport_rolling ()) {
 136                 transport_stop ();
 137         } else {
 138                 AccessAction ("Transport", "GotoStart");
 139         }
 140 }
 141
 142 void
 143 FaderPort8::button_record ()
 144 {
 145         set_record_enable (!get_record_enabled ());
 146 }
 147
 148 void
 149 FaderPort8::button_loop ()
 150 {
 151         loop_toggle ();
 152 }
 153
 154 void
 155 FaderPort8::button_metronom ()
 156 {
 157         Config->set_clicking (!Config->get_clicking ());
 158 }
 159
 160 void
 161 FaderPort8::button_bypass ()
 162 {
 163         boost::shared_ptr<PluginInsert> pi = _plugin_insert.lock();
 164         if (pi) {
 165                 pi->enable (! pi->enabled ());
 166         } else {
 167                 AccessAction ("Mixer", "ab-plugins");
 168         }
 169 }
 170
 171 void
 172 FaderPort8::button_open ()
 173 {
 174         boost::shared_ptr<PluginInsert> pi = _plugin_insert.lock();
 175         if (pi) {
 176                 pi->ToggleUI (); /* EMIT SIGNAL */
 177         } else {
 178                 AccessAction ("Common", "addExistingAudioFiles");
 179         }
 180 }
 181 void
 182 FaderPort8::button_lock ()
 183 {
 184         if (!_link_enabled) {
 185                 AccessAction ("Editor", "lock");
 186                 return;
 187         }
 188         if (_link_locked) {
 189                 unlock_link ();
 190         } else if (!_link_control.expired ()) {
 191                 lock_link ();
 192         }
 193 }
 194
 195 void
 196 FaderPort8::button_link ()
 197 {
 198         switch (_ctrls.fader_mode()) {
 199                 case ModeTrack:
 200                 case ModePan:
 201                         if (_link_enabled) {
 202                                 stop_link ();
 203                         } else {
 204                                 start_link ();
 205                         }
 206                         break;
 207                 default:
 208                         //AccessAction ("Window", "show-mixer");
 209                         break;
 210         }
 211 }
 212
 213 void
 214 FaderPort8::button_automation (ARDOUR::AutoState as)
 215 {
 216         FaderMode fadermode = _ctrls.fader_mode ();
 217         switch (fadermode) {
 218                 case ModePlugins:
 219 #if 0 // Plugin Control Automation Mode
 220                         for ( std::list <ProcessorCtrl>::iterator i = _proc_params.begin(); i != _proc_params.end(); ++i) {
 221                                 ((*i).ac)->set_automation_state (as);
 222                         }
 223 #endif
 224                         return;
 225                 case ModeSend:
 226                         if (first_selected_stripable()) {
 227 #if 0 // Send Level Automation
 228                                 boost::shared_ptr<Stripable> s = first_selected_stripable();
 229                                 boost::shared_ptr<AutomationControl> send;
 230                                 uint32_t i = 0;
 231                                 while (0 != (send = s->send_level_controllable (i))) {
 232                                         send->set_automation_state (as);
 233                                         ++i;
 234                                 }
 235 #endif
 236                         }
 237                         return;
 238                 default:
 239                         break;
 240         }
 241
 242         // TODO link/lock control automation?
 243
 244         // apply to all selected tracks
 245         StripableList all;
 246         session->get_stripables (all);
 247         for (StripableList::const_iterator i = all.begin(); i != all.end(); ++i) {
 248                 if ((*i)->is_master() || (*i)->is_monitor()) {
 249                         continue;
 250                 }
 251                 if (!(*i)->is_selected()) {
 252                         continue;
 253                 }
 254                 boost::shared_ptr<AutomationControl> ac;
 255                 switch (fadermode) {
 256                         case ModeTrack:
 257                                 ac = (*i)->gain_control ();
 258                                 break;
 259                         case ModePan:
 260                                 ac = (*i)->pan_azimuth_control ();
 261                                 break;
 262                         default:
 263                                 break;
 264                 }
 265                 if (ac) {
 266                         ac->set_automation_state (as);
 267                 }
 268         }
 269 }
 270
 271 void
 272 FaderPort8::button_varispeed (bool ffw)
 273 {
 274         /* pressing both rew + ffwd -> return to zero */
 275         FP8ButtonInterface& b_rew = _ctrls.button (FP8Controls::BtnRewind);
 276         FP8ButtonInterface& b_ffw = _ctrls.button (FP8Controls::BtnFastForward);
 277         if (b_rew.is_pressed () && b_ffw.is_pressed ()){
 278                 // stop key-repeat
 279                 dynamic_cast<FP8RepeatButton*>(&b_ffw)->stop_repeat();
 280                 dynamic_cast<FP8RepeatButton*>(&b_rew)->stop_repeat();
 281                 session->request_locate (0, false);
 282                 return;
 283         }
 284
 285         // switch play direction, if needed
 286         if (ffw) {
 287                 if (session->transport_speed () <= 0) {
 288                         session->request_transport_speed (1.0);
 289                         return ;
 290                 }
 291         } else {
 292                 if (session->transport_speed () >= 0) {
 293                         session->request_transport_speed (-1.0);
 294                         return ;
 295                 }
 296         }
 297         // incremetally increase speed. double speed every 10 clicks
 298         // (keypress auto-repeat is 100ms)
 299         float maxspeed = Config->get_shuttle_max_speed();
 300         float speed = exp2f(0.1f) * session->transport_speed ();
 301         speed = std::max (-maxspeed, std::min (maxspeed, speed));
 302         session->request_transport_speed (speed, false);
 303 }
 304
 305 #ifdef FP8_MUTESOLO_UNDO
 306 void
 307 FaderPort8::button_solo_clear ()
 308 {
 309         bool soloing = session->soloing() || session->listening();
 310 #ifdef MIXBUS
 311         soloing |= session->mixbus_soloed();
 312 #endif
 313         if (soloing) {
 314                 StripableList all;
 315                 session->get_stripables (all);
 316                 for (StripableList::const_iterator i = all.begin(); i != all.end(); ++i) {
 317                         if ((*i)->is_master() || (*i)->is_auditioner() || (*i)->is_monitor()) {
 318                                 continue;
 319                         }
 320                         boost::shared_ptr<SoloControl> sc = (*i)->solo_control();
 321                         if (sc && sc->self_soloed ()) {
 322                                 _solo_state.push_back (boost::weak_ptr<AutomationControl>(sc));
 323                         }
 324                 }
 325                 cancel_all_solo (); // AccessAction ("Main", "cancel-solo");
 326         } else {
 327                 /* restore solo */
 328                 boost::shared_ptr<ControlList> cl (new ControlList);
 329                 for (std::vector <boost::weak_ptr<AutomationControl> >::const_iterator i = _solo_state.begin(); i != _solo_state.end(); ++i) {
 330                         boost::shared_ptr<AutomationControl> ac = (*i).lock();
 331                         if (!ac) {
 332                                 continue;
 333                         }
 334                         ac->start_touch (ac->session().transport_frame());
 335                         cl->push_back (ac);
 336                 }
 337                 if (!cl->empty()) {
 338                         session->set_controls (cl, 1.0, PBD::Controllable::NoGroup);
 339                 }
 340         }
 341 }
 342 #endif
 343
 344 void
 345 FaderPort8::button_mute_clear ()
 346 {
 347 #ifdef FP8_MUTESOLO_UNDO
 348         if (session->muted ()) {
 349                 _mute_state = session->cancel_all_mute ();
 350         } else {
 351                 /* restore mute */
 352                 boost::shared_ptr<ControlList> cl (new ControlList);
 353                 for (std::vector <boost::weak_ptr<AutomationControl> >::const_iterator i = _mute_state.begin(); i != _mute_state.end(); ++i) {
 354                         boost::shared_ptr<AutomationControl> ac = (*i).lock();
 355                         if (!ac) {
 356                                 continue;
 357                         }
 358                         cl->push_back (ac);
 359                         ac->start_touch (ac->session().transport_frame());
 360                 }
 361                 if (!cl->empty()) {
 362                         session->set_controls (cl, 1.0, PBD::Controllable::NoGroup);
 363                 }
 364         }
 365 #else
 366         session->cancel_all_mute ();
 367 #endif
 368 }
 369
 370 void
 371 FaderPort8::button_arm_all ()
 372 {
 373         BasicUI::all_tracks_rec_in ();
 374 }
 375
 376 /* access generic action */
 377 void
 378 FaderPort8::button_action (const std::string& group, const std::string& item)
 379 {
 380         AccessAction (group, item);
 381 }
 382
 383 /* ****************************************************************************
 384  * Control Interaction (encoder)
 385  */
 386
 387 void
 388 FaderPort8::handle_encoder_pan (int steps)
 389 {
 390         boost::shared_ptr<Stripable> s = first_selected_stripable();
 391         if (s) {
 392                 boost::shared_ptr<AutomationControl> ac;
 393                 if (shift_mod () || _ctrls.fader_mode() == ModePan) {
 394                         ac = s->pan_width_control ();
 395                 } else {
 396                         ac = s->pan_azimuth_control ();
 397                 }
 398                 if (ac) {
 399                         ac->start_touch (ac->session().transport_frame());
 400                         if (steps == 0) {
 401                                 ac->set_value (ac->normal(), PBD::Controllable::UseGroup);
 402                         } else {
 403                                 double v = ac->internal_to_interface (ac->get_value());
 404                                 v = std::max (0.0, std::min (1.0, v + steps * .01));
 405                                 ac->set_value (ac->interface_to_internal(v), PBD::Controllable::UseGroup);
 406                         }
 407                 }
 408         }
 409 }
 410
 411 void
 412 FaderPort8::handle_encoder_link (int steps)
 413 {
 414         if (_link_control.expired ()) {
 415                 return;
 416         }
 417         boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (_link_control.lock ());
 418         if (!ac) {
 419                 return;
 420         }
 421
 422         double v = ac->internal_to_interface (ac->get_value());
 423         ac->start_touch (ac->session().transport_frame());
 424
 425         if (steps == 0) {
 426                 ac->set_value (ac->normal(), PBD::Controllable::UseGroup);
 427                 return;
 428         }
 429
 430         if (ac->desc().toggled) {
 431                 v = v > 0 ? 0. : 1.;
 432         } else if (ac->desc().integer_step) {
 433                 v += steps / (1.f + ac->desc().upper - ac->desc().lower);
 434         } else if (ac->desc().enumeration) {
 435                 ac->set_value (ac->desc().step_enum (ac->get_value(), steps < 0), PBD::Controllable::UseGroup);
 436                 return;
 437         } else {
 438                 v = std::max (0.0, std::min (1.0, v + steps * .01));
 439         }
 440         ac->set_value (ac->interface_to_internal(v), PBD::Controllable::UseGroup);
 441 }
 442
 443
 444 /* ****************************************************************************
 445  * Mode specific and internal callbacks
 446  */
 447
 448 /* handle "ARM" press -- act like shift, change "Select" button mode */
 449 void
 450 FaderPort8::button_arm (bool press)
 451 {
 452         FaderMode fadermode = _ctrls.fader_mode ();
 453         if (fadermode == ModeTrack || fadermode == ModePan) {
 454                 _ctrls.button (FP8Controls::BtnArm).set_active (press);
 455                 ARMButtonChange (press); /* EMIT SIGNAL */
 456         }
 457 }
 458
 459 void
 460 FaderPort8::button_prev_next (bool next)
 461 {
 462         switch (_ctrls.nav_mode()) {
 463                 case NavChannel:
 464                         select_prev_next (next);
 465                         break;
 466                 case NavMaster:
 467                 case NavScroll:
 468                         bank (!next, false);
 469                         break;
 470                 case NavBank:
 471                         bank (!next, true);
 472                         break;
 473                 case NavZoom:
 474                         if (next) {
 475                                 VerticalZoomInSelected ();
 476                         } else {
 477                                 VerticalZoomOutSelected ();
 478                         }
 479                         break;
 480                 case NavSection:
 481                         if (next) {
 482                                 AccessAction ("Region", "nudge-forward");
 483                         } else {
 484                                 AccessAction ("Region", "nudge-backward");
 485                         }
 486                         break;
 487                 case NavMarker:
 488                         if (next) {
 489                                 next_marker ();
 490                         } else {
 491                                 prev_marker ();
 492                         }
 493                         break;
 494         }
 495 }
 496
 497 /* handle navigation encoder press */
 498 void
 499 FaderPort8::button_encoder ()
 500 {
 501         /* special-case metronome level */
 502         if (_ctrls.button (FP8Controls::BtnClick).is_pressed ()) {
 503                 Config->set_click_gain (1.0);
 504                 _ctrls.button (FP8Controls::BtnClick).ignore_release();
 505                 return;
 506         }
 507         switch (_ctrls.nav_mode()) {
 508                 case NavZoom:
 509                         ZoomToSession (); // XXX undo zoom
 510                         break;
 511                 case NavScroll:
 512                         ZoomToSession ();
 513                         break;
 514                 case NavChannel:
 515                         AccessAction ("Editor", "select-topmost");
 516                         break;
 517                 case NavBank:
 518                         move_selected_into_view ();
 519                         break;
 520                 case NavMaster:
 521                         {
 522                                 /* master || monitor level -- reset to 0dB */
 523                                 boost::shared_ptr<AutomationControl> ac;
 524                                 if (session->monitor_active() && !_ctrls.button (FP8Controls::BtnMaster).is_pressed ()) {
 525                                         ac = session->monitor_out()->gain_control ();
 526                                 } else if (session->master_out()) {
 527                                         ac = session->master_out()->gain_control ();
 528                                 }
 529                                 if (ac) {
 530                                         ac->start_touch (ac->session().transport_frame());
 531                                         ac->set_value (ac->normal(), PBD::Controllable::NoGroup);
 532                                 }
 533                         }
 534                         break;
 535                 case NavSection:
 536                         // TODO nudge
 537                         break;
 538                 case NavMarker:
 539                         {
 540                                 string markername;
 541                                 /* Don't add another mark if one exists within 1/100th of a second of
 542                                  * the current position and we're not rolling.
 543                                  */
 544                                 framepos_t where = session->audible_frame();
 545                                 if (session->transport_stopped() && session->locations()->mark_at (where, session->frame_rate() / 100.0)) {
 546                                         return;
 547                                 }
 548
 549                                 session->locations()->next_available_name (markername,"mark");
 550                                 add_marker (markername);
 551                         }
 552                         break;
 553         }
 554 }
 555
 556 /* handle navigation encoder turn */
 557 void
 558 FaderPort8::encoder_navigate (bool neg, int steps)
 559 {
 560         /* special-case metronome level */
 561         if (_ctrls.button (FP8Controls::BtnClick).is_pressed ()) {
 562                 // compare to ARDOUR_UI::click_button_scroll()
 563                 gain_t gain = Config->get_click_gain();
 564                 float gain_db = accurate_coefficient_to_dB (gain);
 565                 gain_db += (neg ? -1.f : 1.f) * steps;
 566                 gain_db = std::max (-60.f, gain_db);
 567                 gain = dB_to_coefficient (gain_db);
 568                 gain = std::min (gain, Config->get_max_gain());
 569                 Config->set_click_gain (gain);
 570                 _ctrls.button (FP8Controls::BtnClick).ignore_release();
 571                 return;
 572         }
 573
 574         switch (_ctrls.nav_mode()) {
 575                 case NavChannel:
 576                         if (neg) {
 577                                 AccessAction ("Mixer", "scroll-left");
 578                                 AccessAction ("Editor", "step-tracks-up");
 579                         } else {
 580                                 AccessAction ("Mixer", "scroll-right");
 581                                 AccessAction ("Editor", "step-tracks-down");
 582                         }
 583                         break;
 584                 case NavZoom:
 585                         if (neg) {
 586                                 ZoomOut ();
 587                         } else {
 588                                 ZoomIn ();
 589                         }
 590                         break;
 591                 case NavMarker:
 592                 case NavScroll:
 593                         ScrollTimeline ((neg ? -1.f : 1.f) * steps / (shift_mod() ? 1024.f : 256.f));
 594                         break;
 595                 case NavBank:
 596                         bank (neg, false);
 597                         break;
 598                 case NavMaster:
 599                         {
 600                                 /* master || monitor level */
 601                                 boost::shared_ptr<AutomationControl> ac;
 602                                 if (session->monitor_active() && !_ctrls.button (FP8Controls::BtnMaster).is_pressed ()) {
 603                                         ac = session->monitor_out()->gain_control ();
 604                                 } else if (session->master_out()) {
 605                                         ac = session->master_out()->gain_control ();
 606                                 }
 607                                 if (ac) {
 608                                         double v = ac->internal_to_interface (ac->get_value());
 609                                         v = std::max (0.0, std::min (1.0, v + steps * (neg ? -.01 : .01)));
 610                                         ac->start_touch (ac->session().transport_frame());
 611                                         ac->set_value (ac->interface_to_internal(v), PBD::Controllable::NoGroup);
 612                                 }
 613                         }
 614                         break;
 615                 case NavSection:
 616                         if (neg) {
 617                                 AccessAction ("Common", "nudge-playhead-backward");
 618                         } else {
 619                                 AccessAction ("Common", "nudge-playhead-forward");
 620                         }
 621                         break;
 622         }
 623 }
 624
 625 /* handle pan/param encoder press */
 626 void
 627 FaderPort8::button_parameter ()
 628 {
 629         switch (_ctrls.fader_mode()) {
 630                 case ModeTrack:
 631                 case ModePan:
 632                         if (_link_enabled || _link_locked) {
 633                                 handle_encoder_link (0);
 634                         } else {
 635                                 handle_encoder_pan (0);
 636                         }
 637                         break;
 638                 case ModePlugins:
 639                         toggle_preset_param_mode ();
 640                         break;
 641                 case ModeSend:
 642                         break;
 643         }
 644 }
 645
 646 /* handle pan/param encoder turn */
 647 void
 648 FaderPort8::encoder_parameter (bool neg, int steps)
 649 {
 650         switch (_ctrls.fader_mode()) {
 651                 case ModeTrack:
 652                 case ModePan:
 653                         if (steps != 0) {
 654                                 if (_link_enabled || _link_locked) {
 655                                         handle_encoder_link (neg ? -steps : steps);
 656                                 } else {
 657                                         handle_encoder_pan (neg ? -steps : steps);
 658                                 }
 659                         }
 660                         break;
 661                 case ModePlugins:
 662                 case ModeSend:
 663                         while (steps > 0) {
 664                                 bank_param (neg, shift_mod());
 665                                 --steps;
 666                         }
 667                         break;
 668         }
 669 }
 670
 671 /* handle user-specific actions */
 672 void
 673 FaderPort8::button_user (bool press, FP8Controls::ButtonId btn)
 674 {
 675         _user_action_map[btn].call (*this, press);
 676 }