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