libs/surfaces/mackie/mcp_buttons.cc

   1 /*
   2         Copyright (C) 2006,2007 John Anderson
   3         Copyright (C) 2012 Paul Davis
   4
   5         This program is free software; you can redistribute it and/or modify
   6         it under the terms of the GNU General Public License as published by
   7         the Free Software Foundation; either version 2 of the License, or
   8         (at your option) any later version.
   9
  10         This program is distributed in the hope that it will be useful,
  11         but WITHOUT ANY WARRANTY; without even the implied warranty of
  12         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13         GNU General Public License for more details.
  14
  15         You should have received a copy of the GNU General Public License
  16         along with this program; if not, write to the Free Software
  17         Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18 */
  19
  20 #include "pbd/memento_command.h"
  21
  22 #include "ardour/debug.h"
  23 #include "ardour/session.h"
  24 #include "ardour/route.h"
  25 #include "ardour/location.h"
  26 #include "ardour/rc_configuration.h"
  27
  28 #include "mackie_control_protocol.h"
  29 #include "surface.h"
  30
  31 #include "i18n.h"
  32
  33 /* handlers for all buttons, broken into a separate file to avoid clutter in
  34  * mackie_control_protocol.cc
  35  */
  36
  37 using namespace Mackie;
  38 using namespace ARDOUR;
  39 using namespace PBD;
  40 using std::string;
  41
  42 LedState
  43 MackieControlProtocol::shift_press (Button &)
  44 {
  45         _modifier_state |= MODIFIER_SHIFT;
  46         return on;
  47 }
  48 LedState
  49 MackieControlProtocol::shift_release (Button &)
  50 {
  51         _modifier_state &= ~MODIFIER_SHIFT;
  52         return on;
  53 }
  54 LedState
  55 MackieControlProtocol::option_press (Button &)
  56 {
  57         _modifier_state |= MODIFIER_OPTION;
  58         return on;
  59 }
  60 LedState
  61 MackieControlProtocol::option_release (Button &)
  62 {
  63         _modifier_state &= ~MODIFIER_OPTION;
  64         return on;
  65 }
  66 LedState
  67 MackieControlProtocol::control_press (Button &)
  68 {
  69         _modifier_state |= MODIFIER_CONTROL;
  70         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("CONTROL Press: modifier state now set to %1\n", _modifier_state));
  71         return on;
  72 }
  73 LedState
  74 MackieControlProtocol::control_release (Button &)
  75 {
  76         _modifier_state &= ~MODIFIER_CONTROL;
  77         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("CONTROL Release: modifier state now set to %1\n", _modifier_state));
  78         return on;
  79 }
  80 LedState
  81 MackieControlProtocol::cmd_alt_press (Button &)
  82 {
  83         _modifier_state |= MODIFIER_CMDALT;
  84         return on;
  85 }
  86 LedState
  87 MackieControlProtocol::cmd_alt_release (Button &)
  88 {
  89         _modifier_state &= ~MODIFIER_CMDALT;
  90         return on;
  91 }
  92
  93 LedState
  94 MackieControlProtocol::left_press (Button &)
  95 {
  96         Sorted sorted = get_sorted_routes();
  97         uint32_t strip_cnt = n_strips ();
  98
  99         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("bank left with current initial = %1 nstrips = %2 tracks/busses = %3\n",
 100                                                            _current_initial_bank, strip_cnt, sorted.size()));
 101
 102         if (sorted.size() > strip_cnt) {
 103                 int new_initial = _current_initial_bank - strip_cnt;
 104                 if (new_initial < 0) {
 105                         new_initial = 0;
 106                 }
 107
 108                 if (new_initial != int (_current_initial_bank)) {
 109                         switch_banks (new_initial);
 110                 }
 111
 112                 return on;
 113         } else {
 114                 return flashing;
 115         }
 116 }
 117
 118 LedState
 119 MackieControlProtocol::left_release (Button &)
 120 {
 121         return off;
 122 }
 123
 124 LedState
 125 MackieControlProtocol::right_press (Button &)
 126 {
 127         Sorted sorted = get_sorted_routes();
 128         uint32_t strip_cnt = n_strips();
 129
 130         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("bank right with current initial = %1 nstrips = %2 tracks/busses = %3\n",
 131                                                            _current_initial_bank, strip_cnt, sorted.size()));
 132
 133         if (sorted.size() > strip_cnt) {
 134                 uint32_t delta = sorted.size() - (strip_cnt + _current_initial_bank);
 135
 136                 if (delta > strip_cnt) {
 137                         delta = strip_cnt;
 138                 }
 139
 140                 if (delta > 0) {
 141                         switch_banks (_current_initial_bank + delta);
 142                 }
 143
 144                 return on;
 145         } else {
 146                 return flashing;
 147         }
 148         return off;
 149 }
 150
 151 LedState
 152 MackieControlProtocol::right_release (Button &)
 153 {
 154         if (_zoom_mode) {
 155
 156         }
 157
 158         return off;
 159 }
 160
 161 LedState
 162 MackieControlProtocol::cursor_left_press (Button& )
 163 {
 164         if (_zoom_mode) {
 165
 166                 if (_modifier_state & MODIFIER_OPTION) {
 167                         /* reset selected tracks to default vertical zoom */
 168                 } else {
 169                         ZoomOut (); /* EMIT SIGNAL */
 170                 }
 171         } else {
 172                 float page_fraction;
 173                 if (_modifier_state == MODIFIER_CONTROL) {
 174                         page_fraction = 1.0;
 175                 } else if (_modifier_state == MODIFIER_OPTION) {
 176                         page_fraction = 0.1;
 177                 } else if (_modifier_state == MODIFIER_SHIFT) {
 178                         page_fraction = 2.0;
 179                 } else {
 180                         page_fraction = 0.25;
 181                 }
 182
 183                 ScrollTimeline (-page_fraction);
 184         }
 185
 186         return off;
 187 }
 188
 189 LedState
 190 MackieControlProtocol::cursor_left_release (Button&)
 191 {
 192         return off;
 193 }
 194
 195 LedState
 196 MackieControlProtocol::cursor_right_press (Button& )
 197 {
 198         if (_zoom_mode) {
 199
 200                 if (_modifier_state & MODIFIER_OPTION) {
 201                         /* reset selected tracks to default vertical zoom */
 202                 } else {
 203                         ZoomIn (); /* EMIT SIGNAL */
 204                 }
 205         } else {
 206                 float page_fraction;
 207                 if (_modifier_state == MODIFIER_CONTROL) {
 208                         page_fraction = 1.0;
 209                 } else if (_modifier_state == MODIFIER_OPTION) {
 210                         page_fraction = 0.1;
 211                 } else if (_modifier_state == MODIFIER_SHIFT) {
 212                         page_fraction = 2.0;
 213                 } else {
 214                         page_fraction = 0.25;
 215                 }
 216
 217                 ScrollTimeline (page_fraction);
 218         }
 219
 220         return off;
 221 }
 222
 223 LedState
 224 MackieControlProtocol::cursor_right_release (Button&)
 225 {
 226         return off;
 227 }
 228
 229 LedState
 230 MackieControlProtocol::cursor_up_press (Button&)
 231 {
 232         if (_zoom_mode) {
 233
 234                 if (_modifier_state & MODIFIER_CONTROL) {
 235                         VerticalZoomInSelected (); /* EMIT SIGNAL */
 236                 } else {
 237                         VerticalZoomInAll (); /* EMIT SIGNAL */
 238                 }
 239         }
 240         return off;
 241 }
 242
 243 LedState
 244 MackieControlProtocol::cursor_up_release (Button&)
 245 {
 246         return off;
 247 }
 248
 249 LedState
 250 MackieControlProtocol::cursor_down_press (Button&)
 251 {
 252         if (_zoom_mode) {
 253                 if (_modifier_state & MODIFIER_OPTION) {
 254                         VerticalZoomOutSelected (); /* EMIT SIGNAL */
 255                 } else {
 256                         VerticalZoomOutAll (); /* EMIT SIGNAL */
 257                 }
 258         }
 259         return off;
 260 }
 261
 262 LedState
 263 MackieControlProtocol::cursor_down_release (Button&)
 264 {
 265         return off;
 266 }
 267
 268 LedState
 269 MackieControlProtocol::channel_left_press (Button &)
 270 {
 271         Sorted sorted = get_sorted_routes();
 272         if (sorted.size() > n_strips()) {
 273                 prev_track();
 274                 return on;
 275         } else {
 276                 return flashing;
 277         }
 278 }
 279
 280 LedState
 281 MackieControlProtocol::channel_left_release (Button &)
 282 {
 283         return off;
 284 }
 285
 286 LedState
 287 MackieControlProtocol::channel_right_press (Button &)
 288 {
 289         Sorted sorted = get_sorted_routes();
 290         if (sorted.size() > n_strips()) {
 291                 next_track();
 292                 return on;
 293         } else {
 294                 return flashing;
 295         }
 296 }
 297
 298 LedState
 299 MackieControlProtocol::channel_right_release (Button &)
 300 {
 301         return off;
 302 }
 303
 304 Mackie::LedState
 305 MackieControlProtocol::zoom_press (Mackie::Button &)
 306 {
 307         _zoom_mode = !_zoom_mode;
 308         return (_zoom_mode ? on : off);
 309 }
 310
 311 Mackie::LedState
 312 MackieControlProtocol::zoom_release (Mackie::Button &)
 313 {
 314         return (_zoom_mode ? on : off);
 315 }
 316
 317 Mackie::LedState
 318 MackieControlProtocol::scrub_press (Mackie::Button &)
 319 {
 320         if (!surfaces.empty()) {
 321                 surfaces.front()->next_jog_mode ();
 322         }
 323         return none;
 324 }
 325
 326 Mackie::LedState
 327 MackieControlProtocol::scrub_release (Mackie::Button &)
 328 {
 329         return none;
 330 }
 331
 332 LedState
 333 MackieControlProtocol::undo_press (Button&)
 334 {
 335         if (_modifier_state & MODIFIER_SHIFT) {
 336                 Redo(); /* EMIT SIGNAL */
 337         } else {
 338                 Undo(); /* EMIT SIGNAL */
 339         }
 340         return off;
 341 }
 342
 343 LedState
 344 MackieControlProtocol::undo_release (Button&)
 345 {
 346         return off;
 347 }
 348
 349 LedState
 350 MackieControlProtocol::redo_press (Button&)
 351 {
 352         Redo(); /* EMIT SIGNAL */
 353         return off;
 354 }
 355
 356 LedState
 357 MackieControlProtocol::redo_release (Button&)
 358 {
 359         return off;
 360 }
 361
 362 LedState
 363 MackieControlProtocol::drop_press (Button &)
 364 {
 365         session->remove_last_capture();
 366         return on;
 367 }
 368
 369 LedState
 370 MackieControlProtocol::drop_release (Button &)
 371 {
 372         return off;
 373 }
 374
 375 LedState
 376 MackieControlProtocol::save_press (Button &)
 377 {
 378         session->save_state ("");
 379         return on;
 380 }
 381
 382 LedState
 383 MackieControlProtocol::save_release (Button &)
 384 {
 385         return off;
 386 }
 387
 388 LedState
 389 MackieControlProtocol::timecode_beats_press (Button &)
 390 {
 391         switch (_timecode_type) {
 392         case ARDOUR::AnyTime::BBT:
 393                 _timecode_type = ARDOUR::AnyTime::Timecode;
 394                 break;
 395         case ARDOUR::AnyTime::Timecode:
 396                 _timecode_type = ARDOUR::AnyTime::BBT;
 397                 break;
 398         default:
 399                 return off;
 400         }
 401
 402         update_timecode_beats_led();
 403
 404         return on;
 405 }
 406
 407 LedState
 408 MackieControlProtocol::timecode_beats_release (Button &)
 409 {
 410         return off;
 411 }
 412
 413 /////////////////////////////////////
 414 // Functions
 415 /////////////////////////////////////
 416 LedState
 417 MackieControlProtocol::marker_press (Button &)
 418 {
 419         string markername;
 420
 421         session->locations()->next_available_name (markername,"mcu");
 422         add_marker (markername);
 423
 424         return on;
 425 }
 426
 427 LedState
 428 MackieControlProtocol::marker_release (Button &)
 429 {
 430         return off;
 431 }
 432
 433 /////////////////////////////////////
 434 // Transport Buttons
 435 /////////////////////////////////////
 436
 437 LedState
 438 MackieControlProtocol::frm_left_press (Button &)
 439 {
 440         // can use first_mark_before/after as well
 441         unsigned long elapsed = _frm_left_last.restart();
 442
 443         Location * loc = session->locations()->first_location_before (session->transport_frame());
 444
 445         // allow a quick double to go past a previous mark
 446         if (session->transport_rolling() && elapsed < 500 && loc != 0) {
 447                 Location * loc_two_back = session->locations()->first_location_before (loc->start());
 448                 if (loc_two_back != 0)
 449                 {
 450                         loc = loc_two_back;
 451                 }
 452         }
 453
 454         // move to the location, if it's valid
 455         if (loc != 0) {
 456                 session->request_locate (loc->start(), session->transport_rolling());
 457         } else {
 458                 session->request_locate (session->locations()->session_range_location()->start(), session->transport_rolling());
 459         }
 460
 461         return on;
 462 }
 463
 464 LedState
 465 MackieControlProtocol::frm_left_release (Button &)
 466 {
 467         return off;
 468 }
 469
 470 LedState
 471 MackieControlProtocol::frm_right_press (Button &)
 472 {
 473         // can use first_mark_before/after as well
 474         Location * loc = session->locations()->first_location_after (session->transport_frame());
 475
 476         if (loc != 0) {
 477                 session->request_locate (loc->start(), session->transport_rolling());
 478         } else {
 479                 session->request_locate (session->locations()->session_range_location()->end(), session->transport_rolling());
 480         }
 481
 482         return on;
 483 }
 484
 485 LedState
 486 MackieControlProtocol::frm_right_release (Button &)
 487 {
 488         return off;
 489 }
 490
 491 LedState
 492 MackieControlProtocol::stop_press (Button &)
 493 {
 494         transport_stop ();
 495         return on;
 496 }
 497
 498 LedState
 499 MackieControlProtocol::stop_release (Button &)
 500 {
 501         return session->transport_stopped();
 502 }
 503
 504 LedState
 505 MackieControlProtocol::play_press (Button &)
 506 {
 507         /* if we're already rolling at normal speed, and we're pressed
 508            again, jump back to where we started last time
 509         */
 510
 511         transport_play (session->transport_rolling() == 1.0);
 512         return none;
 513 }
 514
 515 LedState
 516 MackieControlProtocol::play_release (Button &)
 517 {
 518         return none;
 519 }
 520
 521 LedState
 522 MackieControlProtocol::record_press (Button &)
 523 {
 524         rec_enable_toggle ();
 525         return none;
 526 }
 527
 528 LedState
 529 MackieControlProtocol::record_release (Button &)
 530 {
 531         return none;
 532 }
 533
 534 LedState
 535 MackieControlProtocol::rewind_press (Button &)
 536 {
 537         if (_modifier_state == MODIFIER_CONTROL) {
 538                 goto_start ();
 539         } else {
 540                 rewind ();
 541         }
 542         return none;
 543 }
 544
 545 LedState
 546 MackieControlProtocol::rewind_release (Button &)
 547 {
 548         return none;
 549 }
 550
 551 LedState
 552 MackieControlProtocol::ffwd_press (Button &)
 553 {
 554         if (_modifier_state == MODIFIER_CONTROL) {
 555                 goto_end();
 556         } else {
 557                 ffwd ();
 558         }
 559         return none;
 560 }
 561
 562 LedState
 563 MackieControlProtocol::ffwd_release (Button &)
 564 {
 565         return none;
 566 }
 567
 568 LedState
 569 MackieControlProtocol::loop_press (Button &)
 570 {
 571         if (_modifier_state & MODIFIER_CONTROL) {
 572                 set_view_mode (Loop);
 573                 return on;
 574         } else {
 575                 session->request_play_loop (!session->get_play_loop());
 576                 return none;
 577         }
 578 }
 579
 580 LedState
 581 MackieControlProtocol::loop_release (Button &)
 582 {
 583         return none;
 584 }
 585
 586 LedState
 587 MackieControlProtocol::punch_in_press (Button &)
 588 {
 589         bool const state = !session->config.get_punch_in();
 590         session->config.set_punch_in (state);
 591         return state;
 592 }
 593
 594 LedState
 595 MackieControlProtocol::punch_in_release (Button &)
 596 {
 597         return session->config.get_punch_in();
 598 }
 599
 600 LedState
 601 MackieControlProtocol::punch_out_press (Button &)
 602 {
 603         bool const state = !session->config.get_punch_out();
 604         session->config.set_punch_out (state);
 605         return state;
 606 }
 607
 608 LedState
 609 MackieControlProtocol::punch_out_release (Button &)
 610 {
 611         return session->config.get_punch_out();
 612 }
 613
 614 LedState
 615 MackieControlProtocol::home_press (Button &)
 616 {
 617         session->goto_start();
 618         return on;
 619 }
 620
 621 LedState
 622 MackieControlProtocol::home_release (Button &)
 623 {
 624         return off;
 625 }
 626
 627 LedState
 628 MackieControlProtocol::end_press (Button &)
 629 {
 630         session->goto_end();
 631         return on;
 632 }
 633
 634 LedState
 635 MackieControlProtocol::end_release (Button &)
 636 {
 637         return off;
 638 }
 639
 640 LedState
 641 MackieControlProtocol::clicking_press (Button &)
 642 {
 643         bool state = !Config->get_clicking();
 644         Config->set_clicking (state);
 645         return state;
 646 }
 647
 648 LedState
 649 MackieControlProtocol::clicking_release (Button &)
 650 {
 651         return Config->get_clicking();
 652 }
 653
 654 LedState MackieControlProtocol::global_solo_press (Button &)
 655 {
 656         bool state = !session->soloing();
 657         session->set_solo (session->get_routes(), state);
 658         return state;
 659 }
 660
 661 LedState MackieControlProtocol::global_solo_release (Button &)
 662 {
 663         return session->soloing();
 664 }
 665
 666 LedState
 667 MackieControlProtocol::enter_press (Button &)
 668 {
 669         Enter(); /* EMIT SIGNAL */
 670         return off;
 671 }
 672
 673 LedState
 674 MackieControlProtocol::enter_release (Button &)
 675 {
 676         return off;
 677 }
 678
 679 LedState
 680 MackieControlProtocol::F1_press (Button &)
 681 {
 682         return off;
 683 }
 684 LedState
 685 MackieControlProtocol::F1_release (Button &)
 686 {
 687         return off;
 688 }
 689 LedState
 690 MackieControlProtocol::F2_press (Button &)
 691 {
 692         return off;
 693 }
 694 LedState
 695 MackieControlProtocol::F2_release (Button &)
 696 {
 697         return off;
 698 }
 699 LedState
 700 MackieControlProtocol::F3_press (Button &)
 701 {
 702         return off;
 703 }
 704 LedState
 705 MackieControlProtocol::F3_release (Button &)
 706 {
 707         return off;
 708 }
 709 LedState
 710 MackieControlProtocol::F4_press (Button &)
 711 {
 712         return off;
 713 }
 714 LedState
 715 MackieControlProtocol::F4_release (Button &)
 716 {
 717         return off;
 718 }
 719 LedState
 720 MackieControlProtocol::F5_press (Button &)
 721 {
 722         return off;
 723 }
 724 LedState
 725 MackieControlProtocol::F5_release (Button &)
 726 {
 727         return off;
 728 }
 729 LedState
 730 MackieControlProtocol::F6_press (Button &)
 731 {
 732         return off;
 733 }
 734 LedState
 735 MackieControlProtocol::F6_release (Button &)
 736 {
 737         return off;
 738 }
 739 LedState
 740 MackieControlProtocol::F7_press (Button &)
 741 {
 742         return off;
 743 }
 744 LedState
 745 MackieControlProtocol::F7_release (Button &)
 746 {
 747         return off;
 748 }
 749 LedState
 750 MackieControlProtocol::F8_press (Button &)
 751 {
 752         CloseDialog (); /* EMIT SIGNAL */
 753         return off;
 754 }
 755 LedState
 756 MackieControlProtocol::F8_release (Button &)
 757 {
 758         return off;
 759 }
 760
 761 /* UNIMPLEMENTED */
 762
 763 LedState
 764 MackieControlProtocol::io_press (Button &)
 765 {
 766         return off;
 767 }
 768 LedState
 769 MackieControlProtocol::io_release (Button &)
 770 {
 771         return off;
 772 }
 773 LedState
 774 MackieControlProtocol::sends_press (Button &)
 775 {
 776         set_view_mode (Sends);
 777         return on;
 778 }
 779 LedState
 780 MackieControlProtocol::sends_release (Button &)
 781 {
 782         return none;
 783 }
 784 LedState
 785 MackieControlProtocol::pan_press (Button &)
 786 {
 787         return off;
 788 }
 789 LedState
 790 MackieControlProtocol::pan_release (Button &)
 791 {
 792         return off;
 793 }
 794 LedState
 795 MackieControlProtocol::plugin_press (Button &)
 796 {
 797         return off;
 798 }
 799 LedState
 800 MackieControlProtocol::plugin_release (Button &)
 801 {
 802         return off;
 803 }
 804 LedState
 805 MackieControlProtocol::eq_press (Button &)
 806 {
 807         set_view_mode (EQ);
 808         return on;
 809 }
 810 LedState
 811 MackieControlProtocol::eq_release (Button &)
 812 {
 813         return none;
 814 }
 815 LedState
 816 MackieControlProtocol::dyn_press (Button &)
 817 {
 818         set_view_mode (Dynamics);
 819         return on;
 820 }
 821 LedState
 822 MackieControlProtocol::dyn_release (Button &)
 823 {
 824         return none;
 825 }
 826 LedState
 827 MackieControlProtocol::flip_press (Button &)
 828 {
 829         set_flip_mode (!_flip_mode);
 830         return (_flip_mode ? on : off);
 831 }
 832 LedState
 833 MackieControlProtocol::flip_release (Button &)
 834 {
 835         return none;
 836 }
 837 LedState
 838 MackieControlProtocol::edit_press (Button &)
 839 {
 840         return off;
 841 }
 842 LedState
 843 MackieControlProtocol::edit_release (Button &)
 844 {
 845         return off;
 846 }
 847 LedState
 848 MackieControlProtocol::name_value_press (Button &)
 849 {
 850         return off;
 851 }
 852 LedState
 853 MackieControlProtocol::name_value_release (Button &)
 854 {
 855         return off;
 856 }
 857 LedState
 858 MackieControlProtocol::F9_press (Button &)
 859 {
 860         return off;
 861 }
 862 LedState
 863 MackieControlProtocol::F9_release (Button &)
 864 {
 865         return off;
 866 }
 867 LedState
 868 MackieControlProtocol::F10_press (Button &)
 869 {
 870         return off;
 871 }
 872 LedState
 873 MackieControlProtocol::F10_release (Button &)
 874 {
 875         return off;
 876 }
 877 LedState
 878 MackieControlProtocol::F11_press (Button &)
 879 {
 880         return off;
 881 }
 882 LedState
 883 MackieControlProtocol::F11_release (Button &)
 884 {
 885         return off;
 886 }
 887 LedState
 888 MackieControlProtocol::F12_press (Button &)
 889 {
 890         return off;
 891 }
 892 LedState
 893 MackieControlProtocol::F12_release (Button &)
 894 {
 895         return off;
 896 }
 897 LedState
 898 MackieControlProtocol::F13_press (Button &)
 899 {
 900         return off;
 901 }
 902 LedState
 903 MackieControlProtocol::F13_release (Button &)
 904 {
 905         return off;
 906 }
 907 LedState
 908 MackieControlProtocol::F14_press (Button &)
 909 {
 910         return off;
 911 }
 912 LedState
 913 MackieControlProtocol::F14_release (Button &)
 914 {
 915         return off;
 916 }
 917 LedState
 918 MackieControlProtocol::F15_press (Button &)
 919 {
 920         return off;
 921 }
 922 LedState
 923 MackieControlProtocol::F15_release (Button &)
 924 {
 925         return off;
 926 }
 927 LedState
 928 MackieControlProtocol::F16_press (Button &)
 929 {
 930         return off;
 931 }
 932 LedState
 933 MackieControlProtocol::F16_release (Button &)
 934 {
 935         return off;
 936 }
 937 LedState
 938 MackieControlProtocol::on_press (Button &)
 939 {
 940         return off;
 941 }
 942 LedState
 943 MackieControlProtocol::on_release (Button &)
 944 {
 945         return off;
 946 }
 947 LedState
 948 MackieControlProtocol::rec_ready_press (Button &)
 949 {
 950         return off;
 951 }
 952 LedState
 953 MackieControlProtocol::rec_ready_release (Button &)
 954 {
 955         return off;
 956 }
 957 LedState
 958 MackieControlProtocol::touch_press (Button &)
 959 {
 960         return off;
 961 }
 962 LedState
 963 MackieControlProtocol::touch_release (Button &)
 964 {
 965         return off;
 966 }
 967 LedState
 968 MackieControlProtocol::cancel_press (Button &)
 969 {
 970         return off;
 971 }
 972 LedState
 973 MackieControlProtocol::cancel_release (Button &)
 974 {
 975         return off;
 976 }
 977 LedState
 978 MackieControlProtocol::mixer_press (Button &)
 979 {
 980         return off;
 981 }
 982 LedState
 983 MackieControlProtocol::mixer_release (Button &)
 984 {
 985         return off;
 986 }
 987 LedState
 988 MackieControlProtocol::user_a_press (Button &)
 989 {
 990         transport_play (session->transport_speed() == 1.0);
 991         return off;
 992 }
 993 LedState
 994 MackieControlProtocol::user_a_release (Button &)
 995 {
 996         return off;
 997 }
 998 LedState
 999 MackieControlProtocol::user_b_press (Button &)
1000 {
1001         transport_stop();
1002         return off;
1003 }
1004 LedState
1005 MackieControlProtocol::user_b_release (Button &)
1006 {
1007         return off;
1008 }
1009
1010 Mackie::LedState
1011 MackieControlProtocol::snapshot_press (Mackie::Button&)
1012 {
1013         return none;
1014 }
1015 Mackie::LedState
1016 MackieControlProtocol::snapshot_release (Mackie::Button&)
1017 {
1018         return none;
1019 }
1020 Mackie::LedState
1021 MackieControlProtocol::read_press (Mackie::Button&)
1022 {
1023         return none;
1024 }
1025 Mackie::LedState
1026 MackieControlProtocol::read_release (Mackie::Button&)
1027 {
1028         return none;
1029 }
1030 Mackie::LedState
1031 MackieControlProtocol::write_press (Mackie::Button&)
1032 {
1033         return none;
1034 }
1035 Mackie::LedState
1036 MackieControlProtocol::write_release (Mackie::Button&)
1037 {
1038         return none;
1039 }
1040 Mackie::LedState
1041 MackieControlProtocol::fdrgroup_press (Mackie::Button&)
1042 {
1043         return none;
1044 }
1045 Mackie::LedState
1046 MackieControlProtocol::fdrgroup_release (Mackie::Button&)
1047 {
1048         return none;
1049 }
1050 Mackie::LedState
1051 MackieControlProtocol::clearsolo_press (Mackie::Button&)
1052 {
1053         return none;
1054 }
1055 Mackie::LedState
1056 MackieControlProtocol::clearsolo_release (Mackie::Button&)
1057 {
1058         return none;
1059 }
1060 Mackie::LedState
1061 MackieControlProtocol::track_press (Mackie::Button&)
1062 {
1063         return none;
1064 }
1065 Mackie::LedState
1066 MackieControlProtocol::track_release (Mackie::Button&)
1067 {
1068         return none;
1069 }
1070 Mackie::LedState
1071 MackieControlProtocol::send_press (Mackie::Button&)
1072 {
1073         return none;
1074 }
1075 Mackie::LedState
1076 MackieControlProtocol::send_release (Mackie::Button&)
1077 {
1078         return none;
1079 }
1080 Mackie::LedState
1081 MackieControlProtocol::miditracks_press (Mackie::Button&)
1082 {
1083         return none;
1084 }
1085 Mackie::LedState
1086 MackieControlProtocol::miditracks_release (Mackie::Button&)
1087 {
1088         return none;
1089 }
1090 Mackie::LedState
1091 MackieControlProtocol::inputs_press (Mackie::Button&)
1092 {
1093         return none;
1094 }
1095 Mackie::LedState
1096 MackieControlProtocol::inputs_release (Mackie::Button&)
1097 {
1098         return none;
1099 }
1100 Mackie::LedState
1101 MackieControlProtocol::audiotracks_press (Mackie::Button&)
1102 {
1103         return none;
1104 }
1105 Mackie::LedState
1106 MackieControlProtocol::audiotracks_release (Mackie::Button&)
1107 {
1108         return none;
1109 }
1110 Mackie::LedState
1111 MackieControlProtocol::audioinstruments_press (Mackie::Button&)
1112 {
1113         return none;
1114 }
1115 Mackie::LedState
1116 MackieControlProtocol::audioinstruments_release (Mackie::Button&)
1117 {
1118         return none;
1119 }
1120 Mackie::LedState
1121 MackieControlProtocol::aux_press (Mackie::Button&)
1122 {
1123         return none;
1124 }
1125 Mackie::LedState
1126 MackieControlProtocol::aux_release (Mackie::Button&)
1127 {
1128         return none;
1129 }
1130 Mackie::LedState
1131 MackieControlProtocol::busses_press (Mackie::Button&)
1132 {
1133         return none;
1134 }
1135 Mackie::LedState
1136 MackieControlProtocol::busses_release (Mackie::Button&)
1137 {
1138         return none;
1139 }
1140 Mackie::LedState
1141 MackieControlProtocol::outputs_press (Mackie::Button&)
1142 {
1143         return none;
1144 }
1145 Mackie::LedState
1146 MackieControlProtocol::outputs_release (Mackie::Button&)
1147 {
1148         return none;
1149 }
1150 Mackie::LedState
1151 MackieControlProtocol::user_press (Mackie::Button&)
1152 {
1153         return none;
1154 }
1155 Mackie::LedState
1156 MackieControlProtocol::user_release (Mackie::Button&)
1157 {
1158         return none;
1159 }
1160 Mackie::LedState
1161 MackieControlProtocol::trim_press (Mackie::Button&)
1162 {
1163         return none;
1164 }
1165 Mackie::LedState
1166 MackieControlProtocol::trim_release (Mackie::Button&)
1167 {
1168         return none;
1169 }
1170 Mackie::LedState
1171 MackieControlProtocol::latch_press (Mackie::Button&)
1172 {
1173         return none;
1174 }
1175 Mackie::LedState
1176 MackieControlProtocol::latch_release (Mackie::Button&)
1177 {
1178         return none;
1179 }
1180 Mackie::LedState
1181 MackieControlProtocol::grp_press (Mackie::Button&)
1182 {
1183         return none;
1184 }
1185 Mackie::LedState
1186 MackieControlProtocol::grp_release (Mackie::Button&)
1187 {
1188         return none;
1189 }
1190 Mackie::LedState
1191 MackieControlProtocol::nudge_press (Mackie::Button&)
1192 {
1193         return none;
1194 }
1195 Mackie::LedState
1196 MackieControlProtocol::nudge_release (Mackie::Button&)
1197 {
1198         return none;
1199 }
1200 Mackie::LedState
1201 MackieControlProtocol::replace_press (Mackie::Button&)
1202 {
1203         return none;
1204 }
1205 Mackie::LedState
1206 MackieControlProtocol::replace_release (Mackie::Button&)
1207 {
1208         return none;
1209 }
1210 Mackie::LedState
1211 MackieControlProtocol::click_press (Mackie::Button&)
1212 {
1213         return none;
1214 }
1215 Mackie::LedState
1216 MackieControlProtocol::click_release (Mackie::Button&)
1217 {
1218         return none;
1219 }
1220 Mackie::LedState
1221 MackieControlProtocol::view_press (Mackie::Button&)
1222 {
1223         return none;
1224 }
1225 Mackie::LedState
1226 MackieControlProtocol::view_release (Mackie::Button&)
1227 {
1228         return none;
1229 }