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