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