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         _scrub_mode = !_scrub_mode;
 321         return (_scrub_mode ? on : off);
 322 }
 323
 324 Mackie::LedState
 325 MackieControlProtocol::scrub_release (Mackie::Button &)
 326 {
 327         return (_scrub_mode ? on : off);
 328 }
 329
 330 LedState
 331 MackieControlProtocol::undo_press (Button&)
 332 {
 333         if (_modifier_state & MODIFIER_SHIFT) {
 334                 Redo(); /* EMIT SIGNAL */
 335         } else {
 336                 Undo(); /* EMIT SIGNAL */
 337         }
 338         return off;
 339 }
 340
 341 LedState
 342 MackieControlProtocol::undo_release (Button&)
 343 {
 344         return off;
 345 }
 346
 347 LedState
 348 MackieControlProtocol::redo_press (Button&)
 349 {
 350         Redo(); /* EMIT SIGNAL */
 351         return off;
 352 }
 353
 354 LedState
 355 MackieControlProtocol::redo_release (Button&)
 356 {
 357         return off;
 358 }
 359
 360 LedState
 361 MackieControlProtocol::drop_press (Button &)
 362 {
 363         session->remove_last_capture();
 364         return on;
 365 }
 366
 367 LedState
 368 MackieControlProtocol::drop_release (Button &)
 369 {
 370         return off;
 371 }
 372
 373 LedState
 374 MackieControlProtocol::save_press (Button &)
 375 {
 376         session->save_state ("");
 377         return on;
 378 }
 379
 380 LedState
 381 MackieControlProtocol::save_release (Button &)
 382 {
 383         return off;
 384 }
 385
 386 LedState
 387 MackieControlProtocol::timecode_beats_press (Button &)
 388 {
 389         switch (_timecode_type) {
 390         case ARDOUR::AnyTime::BBT:
 391                 _timecode_type = ARDOUR::AnyTime::Timecode;
 392                 break;
 393         case ARDOUR::AnyTime::Timecode:
 394                 _timecode_type = ARDOUR::AnyTime::BBT;
 395                 break;
 396         default:
 397                 return off;
 398         }
 399
 400         update_timecode_beats_led();
 401
 402         return on;
 403 }
 404
 405 LedState
 406 MackieControlProtocol::timecode_beats_release (Button &)
 407 {
 408         return off;
 409 }
 410
 411 /////////////////////////////////////
 412 // Functions
 413 /////////////////////////////////////
 414 LedState
 415 MackieControlProtocol::marker_press (Button &)
 416 {
 417         string markername;
 418
 419         session->locations()->next_available_name (markername,"mcu");
 420         add_marker (markername);
 421
 422         return on;
 423 }
 424
 425 LedState
 426 MackieControlProtocol::marker_release (Button &)
 427 {
 428         return off;
 429 }
 430
 431 /////////////////////////////////////
 432 // Transport Buttons
 433 /////////////////////////////////////
 434
 435 LedState
 436 MackieControlProtocol::frm_left_press (Button &)
 437 {
 438         // can use first_mark_before/after as well
 439         unsigned long elapsed = _frm_left_last.restart();
 440
 441         Location * loc = session->locations()->first_location_before (
 442                 session->transport_frame()
 443         );
 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         }
 458
 459         return on;
 460 }
 461
 462 LedState
 463 MackieControlProtocol::frm_left_release (Button &)
 464 {
 465         return off;
 466 }
 467
 468 LedState
 469 MackieControlProtocol::frm_right_press (Button &)
 470 {
 471         // can use first_mark_before/after as well
 472         Location * loc = session->locations()->first_location_after (session->transport_frame());
 473
 474         if (loc != 0) {
 475                 session->request_locate (loc->start(), session->transport_rolling());
 476         }
 477
 478         return on;
 479 }
 480
 481 LedState
 482 MackieControlProtocol::frm_right_release (Button &)
 483 {
 484         return off;
 485 }
 486
 487 LedState
 488 MackieControlProtocol::stop_press (Button &)
 489 {
 490         transport_stop ();
 491         return on;
 492 }
 493
 494 LedState
 495 MackieControlProtocol::stop_release (Button &)
 496 {
 497         return session->transport_stopped();
 498 }
 499
 500 LedState
 501 MackieControlProtocol::play_press (Button &)
 502 {
 503         /* if we're already rolling at normal speed, and we're pressed
 504            again, jump back to where we started last time
 505         */
 506
 507         transport_play (session->transport_rolling() == 1.0);
 508         return none;
 509 }
 510
 511 LedState
 512 MackieControlProtocol::play_release (Button &)
 513 {
 514         return none;
 515 }
 516
 517 LedState
 518 MackieControlProtocol::record_press (Button &)
 519 {
 520         rec_enable_toggle ();
 521         return none;
 522 }
 523
 524 LedState
 525 MackieControlProtocol::record_release (Button &)
 526 {
 527         return none;
 528 }
 529
 530 LedState
 531 MackieControlProtocol::rewind_press (Button &)
 532 {
 533         rewind ();
 534         return none;
 535 }
 536
 537 LedState
 538 MackieControlProtocol::rewind_release (Button &)
 539 {
 540         return none;
 541 }
 542
 543 LedState
 544 MackieControlProtocol::ffwd_press (Button &)
 545 {
 546         ffwd ();
 547         return none;
 548 }
 549
 550 LedState
 551 MackieControlProtocol::ffwd_release (Button &)
 552 {
 553         return none;
 554 }
 555
 556 LedState
 557 MackieControlProtocol::loop_press (Button &)
 558 {
 559         if (_modifier_state & MODIFIER_CONTROL) {
 560                 set_view_mode (Loop);
 561                 return on;
 562         } else {
 563                 session->request_play_loop (!session->get_play_loop());
 564                 return none;
 565         }
 566 }
 567
 568 LedState
 569 MackieControlProtocol::loop_release (Button &)
 570 {
 571         return none;
 572 }
 573
 574 LedState
 575 MackieControlProtocol::punch_in_press (Button &)
 576 {
 577         bool const state = !session->config.get_punch_in();
 578         session->config.set_punch_in (state);
 579         return state;
 580 }
 581
 582 LedState
 583 MackieControlProtocol::punch_in_release (Button &)
 584 {
 585         return session->config.get_punch_in();
 586 }
 587
 588 LedState
 589 MackieControlProtocol::punch_out_press (Button &)
 590 {
 591         bool const state = !session->config.get_punch_out();
 592         session->config.set_punch_out (state);
 593         return state;
 594 }
 595
 596 LedState
 597 MackieControlProtocol::punch_out_release (Button &)
 598 {
 599         return session->config.get_punch_out();
 600 }
 601
 602 LedState
 603 MackieControlProtocol::home_press (Button &)
 604 {
 605         session->goto_start();
 606         return on;
 607 }
 608
 609 LedState
 610 MackieControlProtocol::home_release (Button &)
 611 {
 612         return off;
 613 }
 614
 615 LedState
 616 MackieControlProtocol::end_press (Button &)
 617 {
 618         session->goto_end();
 619         return on;
 620 }
 621
 622 LedState
 623 MackieControlProtocol::end_release (Button &)
 624 {
 625         return off;
 626 }
 627
 628 LedState
 629 MackieControlProtocol::clicking_press (Button &)
 630 {
 631         bool state = !Config->get_clicking();
 632         Config->set_clicking (state);
 633         return state;
 634 }
 635
 636 LedState
 637 MackieControlProtocol::clicking_release (Button &)
 638 {
 639         return Config->get_clicking();
 640 }
 641
 642 LedState MackieControlProtocol::global_solo_press (Button &)
 643 {
 644         bool state = !session->soloing();
 645         session->set_solo (session->get_routes(), state);
 646         return state;
 647 }
 648
 649 LedState MackieControlProtocol::global_solo_release (Button &)
 650 {
 651         return session->soloing();
 652 }
 653
 654 LedState
 655 MackieControlProtocol::enter_press (Button &)
 656 {
 657         Enter(); /* EMIT SIGNAL */
 658         return off;
 659 }
 660
 661 LedState
 662 MackieControlProtocol::enter_release (Button &)
 663 {
 664         return off;
 665 }
 666 LedState
 667 MackieControlProtocol::F1_press (Button &)
 668 {
 669         f_press (0);
 670         return off;
 671 }
 672 LedState
 673 MackieControlProtocol::F1_release (Button &)
 674 {
 675         return off;
 676 }
 677 LedState
 678 MackieControlProtocol::F2_press (Button &)
 679 {
 680         f_press (1);
 681         return off;
 682 }
 683 LedState
 684 MackieControlProtocol::F2_release (Button &)
 685 {
 686         return off;
 687 }
 688 LedState
 689 MackieControlProtocol::F3_press (Button &)
 690 {
 691         f_press (2);
 692         return off;
 693 }
 694 LedState
 695 MackieControlProtocol::F3_release (Button &)
 696 {
 697         return off;
 698 }
 699 LedState
 700 MackieControlProtocol::F4_press (Button &)
 701 {
 702         f_press (3);
 703         return off;
 704 }
 705 LedState
 706 MackieControlProtocol::F4_release (Button &)
 707 {
 708         return off;
 709 }
 710 LedState
 711 MackieControlProtocol::F5_press (Button &)
 712 {
 713         f_press (4);
 714         return off;
 715 }
 716 LedState
 717 MackieControlProtocol::F5_release (Button &)
 718 {
 719         return off;
 720 }
 721 LedState
 722 MackieControlProtocol::F6_press (Button &)
 723 {
 724         f_press (5);
 725         return off;
 726 }
 727 LedState
 728 MackieControlProtocol::F6_release (Button &)
 729 {
 730         return off;
 731 }
 732 LedState
 733 MackieControlProtocol::F7_press (Button &)
 734 {
 735         f_press (6);
 736         return off;
 737 }
 738 LedState
 739 MackieControlProtocol::F7_release (Button &)
 740 {
 741         return off;
 742 }
 743 LedState
 744 MackieControlProtocol::F8_press (Button &)
 745 {
 746         CloseDialog (); /* EMIT SIGNAL */
 747         return off;
 748 }
 749 LedState
 750 MackieControlProtocol::F8_release (Button &)
 751 {
 752         return off;
 753 }
 754
 755 /* UNIMPLEMENTED */
 756
 757 LedState
 758 MackieControlProtocol::io_press (Button &)
 759 {
 760         return off;
 761 }
 762 LedState
 763 MackieControlProtocol::io_release (Button &)
 764 {
 765         return off;
 766 }
 767 LedState
 768 MackieControlProtocol::sends_press (Button &)
 769 {
 770         set_view_mode (Sends);
 771         return on;
 772 }
 773 LedState
 774 MackieControlProtocol::sends_release (Button &)
 775 {
 776         return none;
 777 }
 778 LedState
 779 MackieControlProtocol::pan_press (Button &)
 780 {
 781         return off;
 782 }
 783 LedState
 784 MackieControlProtocol::pan_release (Button &)
 785 {
 786         return off;
 787 }
 788 LedState
 789 MackieControlProtocol::plugin_press (Button &)
 790 {
 791         return off;
 792 }
 793 LedState
 794 MackieControlProtocol::plugin_release (Button &)
 795 {
 796         return off;
 797 }
 798 LedState
 799 MackieControlProtocol::eq_press (Button &)
 800 {
 801         set_view_mode (EQ);
 802         return on;
 803 }
 804 LedState
 805 MackieControlProtocol::eq_release (Button &)
 806 {
 807         return none;
 808 }
 809 LedState
 810 MackieControlProtocol::dyn_press (Button &)
 811 {
 812         set_view_mode (Dynamics);
 813         return on;
 814 }
 815 LedState
 816 MackieControlProtocol::dyn_release (Button &)
 817 {
 818         return none;
 819 }
 820 LedState
 821 MackieControlProtocol::flip_press (Button &)
 822 {
 823         set_flip_mode (!_flip_mode);
 824         return (_flip_mode ? on : off);
 825 }
 826 LedState
 827 MackieControlProtocol::flip_release (Button &)
 828 {
 829         return none;
 830 }
 831 LedState
 832 MackieControlProtocol::edit_press (Button &)
 833 {
 834         return off;
 835 }
 836 LedState
 837 MackieControlProtocol::edit_release (Button &)
 838 {
 839         return off;
 840 }
 841 LedState
 842 MackieControlProtocol::name_value_press (Button &)
 843 {
 844         return off;
 845 }
 846 LedState
 847 MackieControlProtocol::name_value_release (Button &)
 848 {
 849         return off;
 850 }
 851 LedState
 852 MackieControlProtocol::F9_press (Button &)
 853 {
 854         return off;
 855 }
 856 LedState
 857 MackieControlProtocol::F9_release (Button &)
 858 {
 859         return off;
 860 }
 861 LedState
 862 MackieControlProtocol::F10_press (Button &)
 863 {
 864         return off;
 865 }
 866 LedState
 867 MackieControlProtocol::F10_release (Button &)
 868 {
 869         return off;
 870 }
 871 LedState
 872 MackieControlProtocol::F11_press (Button &)
 873 {
 874         return off;
 875 }
 876 LedState
 877 MackieControlProtocol::F11_release (Button &)
 878 {
 879         return off;
 880 }
 881 LedState
 882 MackieControlProtocol::F12_press (Button &)
 883 {
 884         return off;
 885 }
 886 LedState
 887 MackieControlProtocol::F12_release (Button &)
 888 {
 889         return off;
 890 }
 891 LedState
 892 MackieControlProtocol::F13_press (Button &)
 893 {
 894         return off;
 895 }
 896 LedState
 897 MackieControlProtocol::F13_release (Button &)
 898 {
 899         return off;
 900 }
 901 LedState
 902 MackieControlProtocol::F14_press (Button &)
 903 {
 904         return off;
 905 }
 906 LedState
 907 MackieControlProtocol::F14_release (Button &)
 908 {
 909         return off;
 910 }
 911 LedState
 912 MackieControlProtocol::F15_press (Button &)
 913 {
 914         return off;
 915 }
 916 LedState
 917 MackieControlProtocol::F15_release (Button &)
 918 {
 919         return off;
 920 }
 921 LedState
 922 MackieControlProtocol::F16_press (Button &)
 923 {
 924         return off;
 925 }
 926 LedState
 927 MackieControlProtocol::F16_release (Button &)
 928 {
 929         return off;
 930 }
 931 LedState
 932 MackieControlProtocol::on_press (Button &)
 933 {
 934         return off;
 935 }
 936 LedState
 937 MackieControlProtocol::on_release (Button &)
 938 {
 939         return off;
 940 }
 941 LedState
 942 MackieControlProtocol::rec_ready_press (Button &)
 943 {
 944         return off;
 945 }
 946 LedState
 947 MackieControlProtocol::rec_ready_release (Button &)
 948 {
 949         return off;
 950 }
 951 LedState
 952 MackieControlProtocol::touch_press (Button &)
 953 {
 954         return off;
 955 }
 956 LedState
 957 MackieControlProtocol::touch_release (Button &)
 958 {
 959         return off;
 960 }
 961 LedState
 962 MackieControlProtocol::cancel_press (Button &)
 963 {
 964         return off;
 965 }
 966 LedState
 967 MackieControlProtocol::cancel_release (Button &)
 968 {
 969         return off;
 970 }
 971 LedState
 972 MackieControlProtocol::mixer_press (Button &)
 973 {
 974         return off;
 975 }
 976 LedState
 977 MackieControlProtocol::mixer_release (Button &)
 978 {
 979         return off;
 980 }
 981 LedState
 982 MackieControlProtocol::user_a_press (Button &)
 983 {
 984         transport_play (session->transport_speed() == 1.0);
 985         return off;
 986 }
 987 LedState
 988 MackieControlProtocol::user_a_release (Button &)
 989 {
 990         return off;
 991 }
 992 LedState
 993 MackieControlProtocol::user_b_press (Button &)
 994 {
 995         transport_stop();
 996         return off;
 997 }
 998 LedState
 999 MackieControlProtocol::user_b_release (Button &)
1000 {
1001         return off;
1002 }
1003
1004 Mackie::LedState
1005 MackieControlProtocol::snapshot_press (Mackie::Button&)
1006 {
1007         return none;
1008 }
1009 Mackie::LedState
1010 MackieControlProtocol::snapshot_release (Mackie::Button&)
1011 {
1012         return none;
1013 }
1014 Mackie::LedState
1015 MackieControlProtocol::read_press (Mackie::Button&)
1016 {
1017         return none;
1018 }
1019 Mackie::LedState
1020 MackieControlProtocol::read_release (Mackie::Button&)
1021 {
1022         return none;
1023 }
1024 Mackie::LedState
1025 MackieControlProtocol::write_press (Mackie::Button&)
1026 {
1027         return none;
1028 }
1029 Mackie::LedState
1030 MackieControlProtocol::write_release (Mackie::Button&)
1031 {
1032         return none;
1033 }
1034 Mackie::LedState
1035 MackieControlProtocol::fdrgroup_press (Mackie::Button&)
1036 {
1037         return none;
1038 }
1039 Mackie::LedState
1040 MackieControlProtocol::fdrgroup_release (Mackie::Button&)
1041 {
1042         return none;
1043 }
1044 Mackie::LedState
1045 MackieControlProtocol::clearsolo_press (Mackie::Button&)
1046 {
1047         return none;
1048 }
1049 Mackie::LedState
1050 MackieControlProtocol::clearsolo_release (Mackie::Button&)
1051 {
1052         return none;
1053 }
1054 Mackie::LedState
1055 MackieControlProtocol::track_press (Mackie::Button&)
1056 {
1057         return none;
1058 }
1059 Mackie::LedState
1060 MackieControlProtocol::track_release (Mackie::Button&)
1061 {
1062         return none;
1063 }
1064 Mackie::LedState
1065 MackieControlProtocol::send_press (Mackie::Button&)
1066 {
1067         return none;
1068 }
1069 Mackie::LedState
1070 MackieControlProtocol::send_release (Mackie::Button&)
1071 {
1072         return none;
1073 }
1074 Mackie::LedState
1075 MackieControlProtocol::miditracks_press (Mackie::Button&)
1076 {
1077         return none;
1078 }
1079 Mackie::LedState
1080 MackieControlProtocol::miditracks_release (Mackie::Button&)
1081 {
1082         return none;
1083 }
1084 Mackie::LedState
1085 MackieControlProtocol::inputs_press (Mackie::Button&)
1086 {
1087         return none;
1088 }
1089 Mackie::LedState
1090 MackieControlProtocol::inputs_release (Mackie::Button&)
1091 {
1092         return none;
1093 }
1094 Mackie::LedState
1095 MackieControlProtocol::audiotracks_press (Mackie::Button&)
1096 {
1097         return none;
1098 }
1099 Mackie::LedState
1100 MackieControlProtocol::audiotracks_release (Mackie::Button&)
1101 {
1102         return none;
1103 }
1104 Mackie::LedState
1105 MackieControlProtocol::audioinstruments_press (Mackie::Button&)
1106 {
1107         return none;
1108 }
1109 Mackie::LedState
1110 MackieControlProtocol::audioinstruments_release (Mackie::Button&)
1111 {
1112         return none;
1113 }
1114 Mackie::LedState
1115 MackieControlProtocol::aux_press (Mackie::Button&)
1116 {
1117         return none;
1118 }
1119 Mackie::LedState
1120 MackieControlProtocol::aux_release (Mackie::Button&)
1121 {
1122         return none;
1123 }
1124 Mackie::LedState
1125 MackieControlProtocol::busses_press (Mackie::Button&)
1126 {
1127         return none;
1128 }
1129 Mackie::LedState
1130 MackieControlProtocol::busses_release (Mackie::Button&)
1131 {
1132         return none;
1133 }
1134 Mackie::LedState
1135 MackieControlProtocol::outputs_press (Mackie::Button&)
1136 {
1137         return none;
1138 }
1139 Mackie::LedState
1140 MackieControlProtocol::outputs_release (Mackie::Button&)
1141 {
1142         return none;
1143 }
1144 Mackie::LedState
1145 MackieControlProtocol::user_press (Mackie::Button&)
1146 {
1147         return none;
1148 }
1149 Mackie::LedState
1150 MackieControlProtocol::user_release (Mackie::Button&)
1151 {
1152         return none;
1153 }
1154 Mackie::LedState
1155 MackieControlProtocol::trim_press (Mackie::Button&)
1156 {
1157         return none;
1158 }
1159 Mackie::LedState
1160 MackieControlProtocol::trim_release (Mackie::Button&)
1161 {
1162         return none;
1163 }
1164 Mackie::LedState
1165 MackieControlProtocol::latch_press (Mackie::Button&)
1166 {
1167         return none;
1168 }
1169 Mackie::LedState
1170 MackieControlProtocol::latch_release (Mackie::Button&)
1171 {
1172         return none;
1173 }
1174 Mackie::LedState
1175 MackieControlProtocol::grp_press (Mackie::Button&)
1176 {
1177         return none;
1178 }
1179 Mackie::LedState
1180 MackieControlProtocol::grp_release (Mackie::Button&)
1181 {
1182         return none;
1183 }
1184 Mackie::LedState
1185 MackieControlProtocol::nudge_press (Mackie::Button&)
1186 {
1187         return none;
1188 }
1189 Mackie::LedState
1190 MackieControlProtocol::nudge_release (Mackie::Button&)
1191 {
1192         return none;
1193 }
1194 Mackie::LedState
1195 MackieControlProtocol::replace_press (Mackie::Button&)
1196 {
1197         return none;
1198 }
1199 Mackie::LedState
1200 MackieControlProtocol::replace_release (Mackie::Button&)
1201 {
1202         return none;
1203 }
1204 Mackie::LedState
1205 MackieControlProtocol::click_press (Mackie::Button&)
1206 {
1207         return none;
1208 }
1209 Mackie::LedState
1210 MackieControlProtocol::click_release (Mackie::Button&)
1211 {
1212         return none;
1213 }
1214 Mackie::LedState
1215 MackieControlProtocol::view_press (Mackie::Button&)
1216 {
1217         return none;
1218 }
1219 Mackie::LedState
1220 MackieControlProtocol::view_release (Mackie::Button&)
1221 {
1222         return none;
1223 }