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/profile.h"
  26 #include "ardour/session.h"
  27 #include "ardour/route.h"
  28 #include "ardour/location.h"
  29 #include "ardour/rc_configuration.h"
  30
  31 #include "mackie_control_protocol.h"
  32 #include "surface.h"
  33 #include "fader.h"
  34
  35 #include "i18n.h"
  36
  37 /* handlers for all buttons, broken into a separate file to avoid clutter in
  38  * mackie_control_protocol.cc
  39  */
  40
  41 using std::string;
  42 using namespace ARDOUR;
  43 using namespace PBD;
  44 using namespace ArdourSurface;
  45 using namespace Mackie;
  46
  47 LedState
  48 MackieControlProtocol::shift_press (Button &)
  49 {
  50         _modifier_state |= MODIFIER_SHIFT;
  51         return on;
  52 }
  53 LedState
  54 MackieControlProtocol::shift_release (Button &)
  55 {
  56         _modifier_state &= ~MODIFIER_SHIFT;
  57         return off;
  58 }
  59 LedState
  60 MackieControlProtocol::option_press (Button &)
  61 {
  62         _modifier_state |= MODIFIER_OPTION;
  63         return on;
  64 }
  65 LedState
  66 MackieControlProtocol::option_release (Button &)
  67 {
  68         _modifier_state &= ~MODIFIER_OPTION;
  69         return off;
  70 }
  71 LedState
  72 MackieControlProtocol::control_press (Button &)
  73 {
  74         _modifier_state |= MODIFIER_CONTROL;
  75         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("CONTROL Press: modifier state now set to %1\n", _modifier_state));
  76         return on;
  77 }
  78 LedState
  79 MackieControlProtocol::control_release (Button &)
  80 {
  81         _modifier_state &= ~MODIFIER_CONTROL;
  82         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("CONTROL Release: modifier state now set to %1\n", _modifier_state));
  83         return off;
  84 }
  85 LedState
  86 MackieControlProtocol::cmd_alt_press (Button &)
  87 {
  88         _modifier_state |= MODIFIER_CMDALT;
  89         return on;
  90 }
  91 LedState
  92 MackieControlProtocol::cmd_alt_release (Button &)
  93 {
  94         _modifier_state &= ~MODIFIER_CMDALT;
  95         return off;
  96 }
  97
  98 LedState
  99 MackieControlProtocol::left_press (Button &)
 100 {
 101         Sorted sorted = get_sorted_routes();
 102         uint32_t strip_cnt = n_strips ();
 103
 104         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("bank left with current initial = %1 nstrips = %2 tracks/busses = %3\n",
 105                                                            _current_initial_bank, strip_cnt, sorted.size()));
 106         if (_current_initial_bank > 0) {
 107                 switch_banks ((_current_initial_bank - 1) / strip_cnt * strip_cnt);
 108         } else {
 109                 switch_banks (0);
 110         }
 111
 112
 113         return on;
 114 }
 115
 116 LedState
 117 MackieControlProtocol::left_release (Button &)
 118 {
 119         return off;
 120 }
 121
 122 LedState
 123 MackieControlProtocol::right_press (Button &)
 124 {
 125         Sorted sorted = get_sorted_routes();
 126         uint32_t strip_cnt = n_strips();
 127         uint32_t route_cnt = sorted.size();
 128         uint32_t max_bank = route_cnt / strip_cnt * strip_cnt;
 129
 130
 131         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("bank right with current initial = %1 nstrips = %2 tracks/busses = %3\n",
 132                                                            _current_initial_bank, strip_cnt, route_cnt));
 133
 134         if (_current_initial_bank < max_bank) {
 135                 uint32_t new_initial = (_current_initial_bank / strip_cnt * strip_cnt) + strip_cnt;
 136
 137                 switch_banks (new_initial);
 138         } else {
 139                 switch_banks (max_bank);
 140         }
 141
 142         return on;
 143 }
 144
 145 LedState
 146 MackieControlProtocol::right_release (Button &)
 147 {
 148         if (zoom_mode()) {
 149
 150         }
 151
 152         return off;
 153 }
 154
 155 LedState
 156 MackieControlProtocol::cursor_left_press (Button& )
 157 {
 158         if (zoom_mode()) {
 159
 160                 if (main_modifier_state() & MODIFIER_OPTION) {
 161                         /* reset selected tracks to default vertical zoom */
 162                 } else {
 163                         ZoomOut (); /* EMIT SIGNAL */
 164                 }
 165         } else {
 166                 float page_fraction;
 167                 if (main_modifier_state() == MODIFIER_CONTROL) {
 168                         page_fraction = 1.0;
 169                 } else if (main_modifier_state() == MODIFIER_OPTION) {
 170                         page_fraction = 0.1;
 171                 } else if (main_modifier_state() == MODIFIER_SHIFT) {
 172                         page_fraction = 2.0;
 173                 } else {
 174                         page_fraction = 0.25;
 175                 }
 176
 177                 ScrollTimeline (-page_fraction);
 178         }
 179
 180         return off;
 181 }
 182
 183 LedState
 184 MackieControlProtocol::cursor_left_release (Button&)
 185 {
 186         return off;
 187 }
 188
 189 LedState
 190 MackieControlProtocol::cursor_right_press (Button& )
 191 {
 192         if (zoom_mode()) {
 193
 194                 if (main_modifier_state() & MODIFIER_OPTION) {
 195                         /* reset selected tracks to default vertical zoom */
 196                 } else {
 197                         ZoomIn (); /* EMIT SIGNAL */
 198                 }
 199         } else {
 200                 float page_fraction;
 201                 if (main_modifier_state() == MODIFIER_CONTROL) {
 202                         page_fraction = 1.0;
 203                 } else if (main_modifier_state() == MODIFIER_OPTION) {
 204                         page_fraction = 0.1;
 205                 } else if (main_modifier_state() == MODIFIER_SHIFT) {
 206                         page_fraction = 2.0;
 207                 } else {
 208                         page_fraction = 0.25;
 209                 }
 210
 211                 ScrollTimeline (page_fraction);
 212         }
 213
 214         return off;
 215 }
 216
 217 LedState
 218 MackieControlProtocol::cursor_right_release (Button&)
 219 {
 220         return off;
 221 }
 222
 223 LedState
 224 MackieControlProtocol::cursor_up_press (Button&)
 225 {
 226         if (zoom_mode()) {
 227
 228                 if (main_modifier_state() & MODIFIER_CONTROL) {
 229                         VerticalZoomInSelected (); /* EMIT SIGNAL */
 230                 } else {
 231                         VerticalZoomInAll (); /* EMIT SIGNAL */
 232                 }
 233         } else {
 234                 StepTracksUp (); /* EMIT SIGNAL */
 235         }
 236         return off;
 237 }
 238
 239 LedState
 240 MackieControlProtocol::cursor_up_release (Button&)
 241 {
 242         return off;
 243 }
 244
 245 LedState
 246 MackieControlProtocol::cursor_down_press (Button&)
 247 {
 248         if (zoom_mode()) {
 249                 if (main_modifier_state() & MODIFIER_OPTION) {
 250                         VerticalZoomOutSelected (); /* EMIT SIGNAL */
 251                 } else {
 252                         VerticalZoomOutAll (); /* EMIT SIGNAL */
 253                 }
 254         } else {
 255                 StepTracksDown (); /* EMIT SIGNAL */
 256         }
 257         return off;
 258 }
 259
 260 LedState
 261 MackieControlProtocol::cursor_down_release (Button&)
 262 {
 263         return off;
 264 }
 265
 266 LedState
 267 MackieControlProtocol::channel_left_press (Button &)
 268 {
 269         Sorted sorted = get_sorted_routes();
 270         if (sorted.size() > n_strips()) {
 271                 prev_track();
 272                 return on;
 273         } else {
 274                 return flashing;
 275         }
 276 }
 277
 278 LedState
 279 MackieControlProtocol::channel_left_release (Button &)
 280 {
 281         return off;
 282 }
 283
 284 LedState
 285 MackieControlProtocol::channel_right_press (Button &)
 286 {
 287         Sorted sorted = get_sorted_routes();
 288         if (sorted.size() > n_strips()) {
 289                 next_track();
 290                 return on;
 291         } else {
 292                 return flashing;
 293         }
 294 }
 295
 296 LedState
 297 MackieControlProtocol::channel_right_release (Button &)
 298 {
 299         return off;
 300 }
 301
 302 Mackie::LedState
 303 MackieControlProtocol::zoom_press (Mackie::Button &)
 304 {
 305         return none;
 306 }
 307
 308 Mackie::LedState
 309 MackieControlProtocol::zoom_release (Mackie::Button &)
 310 {
 311         if (_modifier_state & MODIFIER_ZOOM) {
 312                 _modifier_state &= ~MODIFIER_ZOOM;
 313         } else {
 314                 _modifier_state |= MODIFIER_ZOOM;
 315         }
 316
 317         return (zoom_mode() ? on : off);
 318 }
 319
 320 Mackie::LedState
 321 MackieControlProtocol::scrub_press (Mackie::Button &)
 322 {
 323         if (!surfaces.empty()) {
 324                 // surfaces.front()->next_jog_mode ();
 325                 _master_surface->next_jog_mode ();
 326         }
 327         return none;
 328 }
 329
 330 Mackie::LedState
 331 MackieControlProtocol::scrub_release (Mackie::Button &)
 332 {
 333         return none;
 334 }
 335
 336 LedState
 337 MackieControlProtocol::undo_press (Button&)
 338 {
 339         if (main_modifier_state() & MODIFIER_SHIFT) {
 340                 Redo(); /* EMIT SIGNAL */
 341         } else {
 342                 Undo(); /* EMIT SIGNAL */
 343         }
 344         return off;
 345 }
 346
 347 LedState
 348 MackieControlProtocol::undo_release (Button&)
 349 {
 350         return off;
 351 }
 352
 353 LedState
 354 MackieControlProtocol::drop_press (Button &)
 355 {
 356         session->remove_last_capture();
 357         return on;
 358 }
 359
 360 LedState
 361 MackieControlProtocol::drop_release (Button &)
 362 {
 363         return off;
 364 }
 365
 366 LedState
 367 MackieControlProtocol::save_press (Button &)
 368 {
 369         session->save_state ("");
 370         return on;
 371 }
 372
 373 LedState
 374 MackieControlProtocol::save_release (Button &)
 375 {
 376         return off;
 377 }
 378
 379 LedState
 380 MackieControlProtocol::timecode_beats_press (Button &)
 381 {
 382         switch (_timecode_type) {
 383         case ARDOUR::AnyTime::BBT:
 384                 _timecode_type = ARDOUR::AnyTime::Timecode;
 385                 break;
 386         case ARDOUR::AnyTime::Timecode:
 387                 _timecode_type = ARDOUR::AnyTime::BBT;
 388                 break;
 389         default:
 390                 return off;
 391         }
 392
 393         update_timecode_beats_led();
 394
 395         return on;
 396 }
 397
 398 LedState
 399 MackieControlProtocol::timecode_beats_release (Button &)
 400 {
 401         return off;
 402 }
 403
 404 /////////////////////////////////////
 405 // Functions
 406 /////////////////////////////////////
 407 LedState
 408 MackieControlProtocol::marker_press (Button &)
 409 {
 410         string markername;
 411
 412         /* Don't add another mark if one exists within 1/100th of a second of
 413          * the current position and we're not rolling.
 414          */
 415
 416
 417         framepos_t where = session->audible_frame();
 418
 419         if (session->transport_stopped() && session->locations()->mark_at (where, session->frame_rate() / 100.0)) {
 420                 return off;
 421         }
 422
 423         session->locations()->next_available_name (markername,"marker");
 424         add_marker (markername);
 425
 426         return on;
 427 }
 428
 429 LedState
 430 MackieControlProtocol::marker_release (Button &)
 431 {
 432         return off;
 433 }
 434
 435 /////////////////////////////////////
 436 // Transport Buttons
 437 /////////////////////////////////////
 438
 439 LedState
 440 MackieControlProtocol::stop_press (Button &)
 441 {
 442         transport_stop ();
 443         return on;
 444 }
 445
 446 LedState
 447 MackieControlProtocol::stop_release (Button &)
 448 {
 449         return session->transport_stopped();
 450 }
 451
 452 LedState
 453 MackieControlProtocol::play_press (Button &)
 454 {
 455         /* if we're already rolling at normal speed, and we're pressed
 456            again, jump back to where we started last time
 457         */
 458
 459         transport_play (session->transport_speed() == 1.0);
 460         return none;
 461 }
 462
 463 LedState
 464 MackieControlProtocol::play_release (Button &)
 465 {
 466         return none;
 467 }
 468
 469 LedState
 470 MackieControlProtocol::record_press (Button &)
 471 {
 472         rec_enable_toggle ();
 473         return none;
 474 }
 475
 476 LedState
 477 MackieControlProtocol::record_release (Button &)
 478 {
 479         return none;
 480 }
 481
 482 LedState
 483 MackieControlProtocol::rewind_press (Button &)
 484 {
 485         if (main_modifier_state() == MODIFIER_CONTROL) {
 486                 goto_start ();
 487         } else {
 488                 rewind ();
 489         }
 490         return none;
 491 }
 492
 493 LedState
 494 MackieControlProtocol::rewind_release (Button &)
 495 {
 496         return none;
 497 }
 498
 499 LedState
 500 MackieControlProtocol::ffwd_press (Button &)
 501 {
 502         if (main_modifier_state() == MODIFIER_CONTROL) {
 503                 goto_end();
 504         } else {
 505                 ffwd ();
 506         }
 507         return none;
 508 }
 509
 510 LedState
 511 MackieControlProtocol::ffwd_release (Button &)
 512 {
 513         return none;
 514 }
 515
 516 LedState
 517 MackieControlProtocol::loop_press (Button &)
 518 {
 519         bool was_on = session->get_play_loop();
 520         session->request_play_loop (!was_on);
 521         return was_on ? off : on;
 522 }
 523
 524 LedState
 525 MackieControlProtocol::loop_release (Button &)
 526 {
 527         return none;
 528 }
 529
 530 LedState
 531 MackieControlProtocol::clicking_press (Button &)
 532 {
 533         bool state = !Config->get_clicking();
 534         Config->set_clicking (state);
 535         return state;
 536 }
 537
 538 LedState
 539 MackieControlProtocol::clicking_release (Button &)
 540 {
 541         return Config->get_clicking();
 542 }
 543
 544 LedState MackieControlProtocol::global_solo_press (Button &)
 545 {
 546         bool state = !session->soloing();
 547         session->set_solo (session->get_routes(), state);
 548         return state;
 549 }
 550
 551 LedState MackieControlProtocol::global_solo_release (Button &)
 552 {
 553         return session->soloing();
 554 }
 555
 556 LedState
 557 MackieControlProtocol::enter_press (Button &)
 558 {
 559         Enter(); /* EMIT SIGNAL */
 560         return off;
 561 }
 562
 563 LedState
 564 MackieControlProtocol::enter_release (Button &)
 565 {
 566         return off;
 567 }
 568
 569 LedState
 570 MackieControlProtocol::bank_release (Button& b, uint32_t basic_bank_num)
 571 {
 572         uint32_t bank_num = basic_bank_num;
 573
 574         if (b.long_press_count() > 0) {
 575                 bank_num = 8 + basic_bank_num;
 576         }
 577
 578         switch_banks (n_strips() * bank_num);
 579
 580         return on;
 581 }
 582
 583 LedState
 584 MackieControlProtocol::F1_press (Button &b)
 585 {
 586         return off;
 587 }
 588 LedState
 589 MackieControlProtocol::F1_release (Button &b)
 590 {
 591         return bank_release (b, 0);
 592 }
 593 LedState
 594 MackieControlProtocol::F2_press (Button &)
 595 {
 596         return off;
 597 }
 598 LedState
 599 MackieControlProtocol::F2_release (Button &b)
 600 {
 601         return bank_release (b, 1);
 602 }
 603 LedState
 604 MackieControlProtocol::F3_press (Button &)
 605 {
 606         return off;
 607 }
 608 LedState
 609 MackieControlProtocol::F3_release (Button &b)
 610 {
 611         return bank_release (b, 2);
 612 }
 613 LedState
 614 MackieControlProtocol::F4_press (Button &)
 615 {
 616         return off;
 617 }
 618 LedState
 619 MackieControlProtocol::F4_release (Button &b)
 620 {
 621         return bank_release (b, 3);
 622 }
 623 LedState
 624 MackieControlProtocol::F5_press (Button &)
 625 {
 626         return off;
 627 }
 628 LedState
 629 MackieControlProtocol::F5_release (Button &)
 630 {
 631         return off;
 632 }
 633 LedState
 634 MackieControlProtocol::F6_press (Button &)
 635 {
 636         return off;
 637 }
 638 LedState
 639 MackieControlProtocol::F6_release (Button &)
 640 {
 641         return off;
 642 }
 643 LedState
 644 MackieControlProtocol::F7_press (Button &)
 645 {
 646         return off;
 647 }
 648 LedState
 649 MackieControlProtocol::F7_release (Button &)
 650 {
 651         return off;
 652 }
 653 LedState
 654 MackieControlProtocol::F8_press (Button &)
 655 {
 656         CloseDialog (); /* EMIT SIGNAL */
 657         return off;
 658 }
 659 LedState
 660 MackieControlProtocol::F8_release (Button &)
 661 {
 662         return off;
 663 }
 664
 665 /* UNIMPLEMENTED */
 666
 667 LedState
 668 MackieControlProtocol::pan_press (Button &)
 669 {
 670         set_pot_mode (Pan);
 671         return none;
 672 }
 673 LedState
 674 MackieControlProtocol::pan_release (Button &)
 675 {
 676         return none;
 677 }
 678 LedState
 679 MackieControlProtocol::plugin_press (Button &)
 680 {
 681         return off;
 682 }
 683 LedState
 684 MackieControlProtocol::plugin_release (Button &)
 685 {
 686         set_view_mode (Plugins);
 687         return none; /* LED state set by set_view_mode */
 688 }
 689 LedState
 690 MackieControlProtocol::eq_press (Button &)
 691 {
 692         if (Profile->get_mixbus()) {
 693                 if (_last_selected_routes.size() == 1) {
 694                         set_subview_mode (EQ);
 695                         return on;
 696                 }
 697         }
 698         return none;
 699
 700 }
 701 LedState
 702 MackieControlProtocol::eq_release (Button &)
 703 {
 704         return none;
 705 }
 706 LedState
 707 MackieControlProtocol::dyn_press (Button &)
 708 {
 709         if (Profile->get_mixbus()) {
 710                 set_subview_mode (Dynamics);
 711                 return on;
 712         }
 713         return none;
 714 }
 715 LedState
 716 MackieControlProtocol::dyn_release (Button &)
 717 {
 718         return none;
 719 }
 720 LedState
 721 MackieControlProtocol::flip_press (Button &)
 722 {
 723         if (_flip_mode != Normal) {
 724                 set_flip_mode (Normal);
 725         } else {
 726                 set_flip_mode (Mirror);
 727         }
 728         return ((_flip_mode != Normal) ? on : off);
 729 }
 730 LedState
 731 MackieControlProtocol::flip_release (Button &)
 732 {
 733         return none;
 734 }
 735 LedState
 736 MackieControlProtocol::name_value_press (Button &)
 737 {
 738         return off;
 739 }
 740 LedState
 741 MackieControlProtocol::name_value_release (Button &)
 742 {
 743         return off;
 744 }
 745 LedState
 746 MackieControlProtocol::touch_press (Button &)
 747 {
 748         return off;
 749 }
 750 LedState
 751 MackieControlProtocol::touch_release (Button &)
 752 {
 753         return off;
 754 }
 755 LedState
 756 MackieControlProtocol::cancel_press (Button &)
 757 {
 758         return off;
 759 }
 760 LedState
 761 MackieControlProtocol::cancel_release (Button &)
 762 {
 763         return off;
 764 }
 765 LedState
 766 MackieControlProtocol::user_a_press (Button &)
 767 {
 768         transport_play (session->transport_speed() == 1.0);
 769         return off;
 770 }
 771 LedState
 772 MackieControlProtocol::user_a_release (Button &)
 773 {
 774         return off;
 775 }
 776 LedState
 777 MackieControlProtocol::user_b_press (Button &)
 778 {
 779         transport_stop();
 780         return off;
 781 }
 782 LedState
 783 MackieControlProtocol::user_b_release (Button &)
 784 {
 785         return off;
 786 }
 787
 788 LedState
 789 MackieControlProtocol::master_fader_touch_press (Mackie::Button &)
 790 {
 791         DEBUG_TRACE (DEBUG::MackieControl, "MackieControlProtocol::master_fader_touch_press\n");
 792
 793         Fader* master_fader = _master_surface->master_fader();
 794
 795         boost::shared_ptr<AutomationControl> ac = master_fader->control ();
 796
 797         master_fader->set_in_use (true);
 798         master_fader->start_touch (transport_frame());
 799
 800         return none;
 801 }
 802 LedState
 803 MackieControlProtocol::master_fader_touch_release (Mackie::Button &)
 804 {
 805         DEBUG_TRACE (DEBUG::MackieControl, "MackieControlProtocol::master_fader_touch_release\n");
 806
 807         Fader* master_fader = _master_surface->master_fader();
 808
 809         master_fader->set_in_use (false);
 810         master_fader->stop_touch (transport_frame(), true);
 811
 812         return none;
 813 }
 814
 815 Mackie::LedState
 816 MackieControlProtocol::read_press (Mackie::Button&)
 817 {
 818         _metering_active = !_metering_active;
 819         notify_metering_state_changed ();
 820         return _metering_active;
 821 }
 822 Mackie::LedState
 823 MackieControlProtocol::read_release (Mackie::Button&)
 824 {
 825         return _metering_active;
 826 }
 827 Mackie::LedState
 828 MackieControlProtocol::write_press (Mackie::Button&)
 829 {
 830         return none;
 831 }
 832 Mackie::LedState
 833 MackieControlProtocol::write_release (Mackie::Button&)
 834 {
 835         return none;
 836 }
 837 Mackie::LedState
 838 MackieControlProtocol::clearsolo_press (Mackie::Button&)
 839 {
 840         return none;
 841 }
 842 Mackie::LedState
 843 MackieControlProtocol::clearsolo_release (Mackie::Button&)
 844 {
 845         return none;
 846 }
 847 Mackie::LedState
 848 MackieControlProtocol::track_press (Mackie::Button&)
 849 {
 850         set_pot_mode (Trim);
 851         return none;
 852 }
 853 Mackie::LedState
 854 MackieControlProtocol::track_release (Mackie::Button&)
 855 {
 856         return none;
 857 }
 858 Mackie::LedState
 859 MackieControlProtocol::send_press (Mackie::Button&)
 860 {
 861         set_pot_mode (Send);
 862         return none;
 863 }
 864 Mackie::LedState
 865 MackieControlProtocol::send_release (Mackie::Button&)
 866 {
 867         return none;
 868 }
 869 Mackie::LedState
 870 MackieControlProtocol::miditracks_press (Mackie::Button&)
 871 {
 872         return none;
 873 }
 874 Mackie::LedState
 875 MackieControlProtocol::miditracks_release (Mackie::Button&)
 876 {
 877         set_view_mode (MidiTracks);
 878         return none;
 879 }
 880 Mackie::LedState
 881 MackieControlProtocol::inputs_press (Mackie::Button&)
 882 {
 883         return none;
 884 }
 885 Mackie::LedState
 886 MackieControlProtocol::inputs_release (Mackie::Button&)
 887 {
 888         return none;
 889 }
 890 Mackie::LedState
 891 MackieControlProtocol::audiotracks_press (Mackie::Button&)
 892 {
 893         return none;
 894 }
 895 Mackie::LedState
 896 MackieControlProtocol::audiotracks_release (Mackie::Button&)
 897 {
 898         set_view_mode (AudioTracks);
 899         return none;
 900 }
 901 Mackie::LedState
 902 MackieControlProtocol::audioinstruments_press (Mackie::Button&)
 903 {
 904         return none;
 905 }
 906 Mackie::LedState
 907 MackieControlProtocol::audioinstruments_release (Mackie::Button&)
 908 {
 909         return none;
 910 }
 911 Mackie::LedState
 912 MackieControlProtocol::aux_press (Mackie::Button&)
 913 {
 914         return none;
 915 }
 916 Mackie::LedState
 917 MackieControlProtocol::aux_release (Mackie::Button&)
 918 {
 919         set_view_mode (Auxes);
 920         return none;
 921 }
 922 Mackie::LedState
 923 MackieControlProtocol::busses_press (Mackie::Button&)
 924 {
 925         return none;
 926 }
 927 Mackie::LedState
 928 MackieControlProtocol::busses_release (Mackie::Button&)
 929 {
 930         set_view_mode (Busses);
 931         return none;
 932 }
 933 Mackie::LedState
 934 MackieControlProtocol::outputs_press (Mackie::Button&)
 935 {
 936         return none;
 937 }
 938 Mackie::LedState
 939 MackieControlProtocol::outputs_release (Mackie::Button&)
 940 {
 941         return none;
 942 }
 943 Mackie::LedState
 944 MackieControlProtocol::user_press (Mackie::Button&)
 945 {
 946         return none;
 947 }
 948 Mackie::LedState
 949 MackieControlProtocol::user_release (Mackie::Button&)
 950 {
 951         set_view_mode (Selected);
 952         return none;
 953 }
 954 Mackie::LedState
 955 MackieControlProtocol::trim_press (Mackie::Button&)
 956 {
 957         return none;
 958 }
 959 Mackie::LedState
 960 MackieControlProtocol::trim_release (Mackie::Button&)
 961 {
 962         return none;
 963 }
 964 Mackie::LedState
 965 MackieControlProtocol::latch_press (Mackie::Button&)
 966 {
 967         return none;
 968 }
 969 Mackie::LedState
 970 MackieControlProtocol::latch_release (Mackie::Button&)
 971 {
 972         return none;
 973 }
 974 Mackie::LedState
 975 MackieControlProtocol::grp_press (Mackie::Button&)
 976 {
 977         return none;
 978 }
 979 Mackie::LedState
 980 MackieControlProtocol::grp_release (Mackie::Button&)
 981 {
 982         return none;
 983 }
 984 Mackie::LedState
 985 MackieControlProtocol::nudge_press (Mackie::Button&)
 986 {
 987         return none;
 988 }
 989 Mackie::LedState
 990 MackieControlProtocol::nudge_release (Mackie::Button&)
 991 {
 992         return none;
 993 }
 994 Mackie::LedState
 995 MackieControlProtocol::replace_press (Mackie::Button&)
 996 {
 997         return none;
 998 }
 999 Mackie::LedState
1000 MackieControlProtocol::replace_release (Mackie::Button&)
1001 {
1002         return none;
1003 }
1004 Mackie::LedState
1005 MackieControlProtocol::click_press (Mackie::Button&)
1006 {
1007         return none;
1008 }
1009 Mackie::LedState
1010 MackieControlProtocol::click_release (Mackie::Button&)
1011 {
1012         return none;
1013 }
1014 Mackie::LedState
1015 MackieControlProtocol::view_press (Mackie::Button&)
1016 {
1017         set_view_mode (Mixer);
1018         return none;
1019 }
1020 Mackie::LedState
1021 MackieControlProtocol::view_release (Mackie::Button&)
1022 {
1023         return none;
1024 }