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 on;
  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 on;
  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 on;
  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 on;
  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 (_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 (_modifier_state == MODIFIER_CONTROL) {
 167                         page_fraction = 1.0;
 168                 } else if (_modifier_state == MODIFIER_OPTION) {
 169                         page_fraction = 0.1;
 170                 } else if (_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 (_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 (_modifier_state == MODIFIER_CONTROL) {
 201                         page_fraction = 1.0;
 202                 } else if (_modifier_state == MODIFIER_OPTION) {
 203                         page_fraction = 0.1;
 204                 } else if (_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 (_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 (_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         _zoom_mode = !_zoom_mode;
 305         return (_zoom_mode ? on : off);
 306 }
 307
 308 Mackie::LedState
 309 MackieControlProtocol::zoom_release (Mackie::Button &)
 310 {
 311         return (_zoom_mode ? on : off);
 312 }
 313
 314 Mackie::LedState
 315 MackieControlProtocol::scrub_press (Mackie::Button &)
 316 {
 317         if (!surfaces.empty()) {
 318                 surfaces.front()->next_jog_mode ();
 319         }
 320         return none;
 321 }
 322
 323 Mackie::LedState
 324 MackieControlProtocol::scrub_release (Mackie::Button &)
 325 {
 326         return none;
 327 }
 328
 329 LedState
 330 MackieControlProtocol::undo_press (Button&)
 331 {
 332         if (_modifier_state & MODIFIER_SHIFT) {
 333                 Redo(); /* EMIT SIGNAL */
 334         } else {
 335                 Undo(); /* EMIT SIGNAL */
 336         }
 337         return off;
 338 }
 339
 340 LedState
 341 MackieControlProtocol::undo_release (Button&)
 342 {
 343         return off;
 344 }
 345
 346 LedState
 347 MackieControlProtocol::drop_press (Button &)
 348 {
 349         session->remove_last_capture();
 350         return on;
 351 }
 352
 353 LedState
 354 MackieControlProtocol::drop_release (Button &)
 355 {
 356         return off;
 357 }
 358
 359 LedState
 360 MackieControlProtocol::save_press (Button &)
 361 {
 362         session->save_state ("");
 363         return on;
 364 }
 365
 366 LedState
 367 MackieControlProtocol::save_release (Button &)
 368 {
 369         return off;
 370 }
 371
 372 LedState
 373 MackieControlProtocol::timecode_beats_press (Button &)
 374 {
 375         switch (_timecode_type) {
 376         case ARDOUR::AnyTime::BBT:
 377                 _timecode_type = ARDOUR::AnyTime::Timecode;
 378                 break;
 379         case ARDOUR::AnyTime::Timecode:
 380                 _timecode_type = ARDOUR::AnyTime::BBT;
 381                 break;
 382         default:
 383                 return off;
 384         }
 385
 386         update_timecode_beats_led();
 387
 388         return on;
 389 }
 390
 391 LedState
 392 MackieControlProtocol::timecode_beats_release (Button &)
 393 {
 394         return off;
 395 }
 396
 397 /////////////////////////////////////
 398 // Functions
 399 /////////////////////////////////////
 400 LedState
 401 MackieControlProtocol::marker_press (Button &)
 402 {
 403         string markername;
 404
 405         session->locations()->next_available_name (markername,"mcu");
 406         add_marker (markername);
 407
 408         return on;
 409 }
 410
 411 LedState
 412 MackieControlProtocol::marker_release (Button &)
 413 {
 414         return off;
 415 }
 416
 417 /////////////////////////////////////
 418 // Transport Buttons
 419 /////////////////////////////////////
 420
 421 LedState
 422 MackieControlProtocol::stop_press (Button &)
 423 {
 424         transport_stop ();
 425         return on;
 426 }
 427
 428 LedState
 429 MackieControlProtocol::stop_release (Button &)
 430 {
 431         return session->transport_stopped();
 432 }
 433
 434 LedState
 435 MackieControlProtocol::play_press (Button &)
 436 {
 437         /* if we're already rolling at normal speed, and we're pressed
 438            again, jump back to where we started last time
 439         */
 440
 441         transport_play (session->transport_speed() == 1.0);
 442         return none;
 443 }
 444
 445 LedState
 446 MackieControlProtocol::play_release (Button &)
 447 {
 448         return none;
 449 }
 450
 451 LedState
 452 MackieControlProtocol::record_press (Button &)
 453 {
 454         rec_enable_toggle ();
 455         return none;
 456 }
 457
 458 LedState
 459 MackieControlProtocol::record_release (Button &)
 460 {
 461         return none;
 462 }
 463
 464 LedState
 465 MackieControlProtocol::rewind_press (Button &)
 466 {
 467         if (_modifier_state == MODIFIER_CONTROL) {
 468                 goto_start ();
 469         } else {
 470                 rewind ();
 471         }
 472         return none;
 473 }
 474
 475 LedState
 476 MackieControlProtocol::rewind_release (Button &)
 477 {
 478         return none;
 479 }
 480
 481 LedState
 482 MackieControlProtocol::ffwd_press (Button &)
 483 {
 484         if (_modifier_state == MODIFIER_CONTROL) {
 485                 goto_end();
 486         } else {
 487                 ffwd ();
 488         }
 489         return none;
 490 }
 491
 492 LedState
 493 MackieControlProtocol::ffwd_release (Button &)
 494 {
 495         return none;
 496 }
 497
 498 LedState
 499 MackieControlProtocol::loop_press (Button &)
 500 {
 501         if (_modifier_state & MODIFIER_CONTROL) {
 502                 set_view_mode (Loop);
 503                 return on;
 504         } else {
 505                 session->request_play_loop (!session->get_play_loop());
 506                 return none;
 507         }
 508 }
 509
 510 LedState
 511 MackieControlProtocol::loop_release (Button &)
 512 {
 513         return none;
 514 }
 515
 516 LedState
 517 MackieControlProtocol::clicking_press (Button &)
 518 {
 519         bool state = !Config->get_clicking();
 520         Config->set_clicking (state);
 521         return state;
 522 }
 523
 524 LedState
 525 MackieControlProtocol::clicking_release (Button &)
 526 {
 527         return Config->get_clicking();
 528 }
 529
 530 LedState MackieControlProtocol::global_solo_press (Button &)
 531 {
 532         bool state = !session->soloing();
 533         session->set_solo (session->get_routes(), state);
 534         return state;
 535 }
 536
 537 LedState MackieControlProtocol::global_solo_release (Button &)
 538 {
 539         return session->soloing();
 540 }
 541
 542 LedState
 543 MackieControlProtocol::enter_press (Button &)
 544 {
 545         Enter(); /* EMIT SIGNAL */
 546         return off;
 547 }
 548
 549 LedState
 550 MackieControlProtocol::enter_release (Button &)
 551 {
 552         return off;
 553 }
 554
 555 LedState
 556 MackieControlProtocol::F1_press (Button &)
 557 {
 558         return off;
 559 }
 560 LedState
 561 MackieControlProtocol::F1_release (Button &)
 562 {
 563         return off;
 564 }
 565 LedState
 566 MackieControlProtocol::F2_press (Button &)
 567 {
 568         return off;
 569 }
 570 LedState
 571 MackieControlProtocol::F2_release (Button &)
 572 {
 573         return off;
 574 }
 575 LedState
 576 MackieControlProtocol::F3_press (Button &)
 577 {
 578         return off;
 579 }
 580 LedState
 581 MackieControlProtocol::F3_release (Button &)
 582 {
 583         return off;
 584 }
 585 LedState
 586 MackieControlProtocol::F4_press (Button &)
 587 {
 588         return off;
 589 }
 590 LedState
 591 MackieControlProtocol::F4_release (Button &)
 592 {
 593         return off;
 594 }
 595 LedState
 596 MackieControlProtocol::F5_press (Button &)
 597 {
 598         return off;
 599 }
 600 LedState
 601 MackieControlProtocol::F5_release (Button &)
 602 {
 603         return off;
 604 }
 605 LedState
 606 MackieControlProtocol::F6_press (Button &)
 607 {
 608         return off;
 609 }
 610 LedState
 611 MackieControlProtocol::F6_release (Button &)
 612 {
 613         return off;
 614 }
 615 LedState
 616 MackieControlProtocol::F7_press (Button &)
 617 {
 618         return off;
 619 }
 620 LedState
 621 MackieControlProtocol::F7_release (Button &)
 622 {
 623         return off;
 624 }
 625 LedState
 626 MackieControlProtocol::F8_press (Button &)
 627 {
 628         CloseDialog (); /* EMIT SIGNAL */
 629         return off;
 630 }
 631 LedState
 632 MackieControlProtocol::F8_release (Button &)
 633 {
 634         return off;
 635 }
 636
 637 /* UNIMPLEMENTED */
 638
 639 LedState
 640 MackieControlProtocol::pan_press (Button &)
 641 {
 642         return off;
 643 }
 644 LedState
 645 MackieControlProtocol::pan_release (Button &)
 646 {
 647         return off;
 648 }
 649 LedState
 650 MackieControlProtocol::plugin_press (Button &)
 651 {
 652         return off;
 653 }
 654 LedState
 655 MackieControlProtocol::plugin_release (Button &)
 656 {
 657         return off;
 658 }
 659 LedState
 660 MackieControlProtocol::eq_press (Button &)
 661 {
 662         set_view_mode (EQ);
 663         return on;
 664 }
 665 LedState
 666 MackieControlProtocol::eq_release (Button &)
 667 {
 668         return none;
 669 }
 670 LedState
 671 MackieControlProtocol::dyn_press (Button &)
 672 {
 673         set_view_mode (Dynamics);
 674         return on;
 675 }
 676 LedState
 677 MackieControlProtocol::dyn_release (Button &)
 678 {
 679         return none;
 680 }
 681 LedState
 682 MackieControlProtocol::flip_press (Button &)
 683 {
 684         if (_flip_mode != Normal) {
 685                 set_flip_mode (Normal);
 686         } else {
 687                 set_flip_mode (Mirror);
 688         }
 689         return ((_flip_mode != Normal) ? on : off);
 690 }
 691 LedState
 692 MackieControlProtocol::flip_release (Button &)
 693 {
 694         return none;
 695 }
 696 LedState
 697 MackieControlProtocol::name_value_press (Button &)
 698 {
 699         return off;
 700 }
 701 LedState
 702 MackieControlProtocol::name_value_release (Button &)
 703 {
 704         return off;
 705 }
 706 LedState
 707 MackieControlProtocol::touch_press (Button &)
 708 {
 709         return off;
 710 }
 711 LedState
 712 MackieControlProtocol::touch_release (Button &)
 713 {
 714         return off;
 715 }
 716 LedState
 717 MackieControlProtocol::cancel_press (Button &)
 718 {
 719         return off;
 720 }
 721 LedState
 722 MackieControlProtocol::cancel_release (Button &)
 723 {
 724         return off;
 725 }
 726 LedState
 727 MackieControlProtocol::user_a_press (Button &)
 728 {
 729         transport_play (session->transport_speed() == 1.0);
 730         return off;
 731 }
 732 LedState
 733 MackieControlProtocol::user_a_release (Button &)
 734 {
 735         return off;
 736 }
 737 LedState
 738 MackieControlProtocol::user_b_press (Button &)
 739 {
 740         transport_stop();
 741         return off;
 742 }
 743 LedState
 744 MackieControlProtocol::user_b_release (Button &)
 745 {
 746         return off;
 747 }
 748
 749 LedState
 750 MackieControlProtocol::master_fader_touch_press (Mackie::Button &)
 751 {
 752         DEBUG_TRACE (DEBUG::MackieControl, "MackieControlProtocol::master_fader_touch_press\n");
 753
 754         Fader* master_fader = surfaces.front()->master_fader();
 755
 756         boost::shared_ptr<AutomationControl> ac = master_fader->control ();
 757
 758         master_fader->set_in_use (true);
 759         master_fader->start_touch (transport_frame());
 760
 761         return none;
 762 }
 763 LedState
 764 MackieControlProtocol::master_fader_touch_release (Mackie::Button &)
 765 {
 766         DEBUG_TRACE (DEBUG::MackieControl, "MackieControlProtocol::master_fader_touch_release\n");
 767
 768         Fader* master_fader = surfaces.front()->master_fader();
 769
 770         master_fader->set_in_use (false);
 771         master_fader->stop_touch (transport_frame(), true);
 772
 773         return none;
 774 }
 775
 776 Mackie::LedState
 777 MackieControlProtocol::read_press (Mackie::Button&)
 778 {
 779         _metering_active = !_metering_active;
 780         notify_metering_state_changed ();
 781         return _metering_active;
 782 }
 783 Mackie::LedState
 784 MackieControlProtocol::read_release (Mackie::Button&)
 785 {
 786         return _metering_active;
 787 }
 788 Mackie::LedState
 789 MackieControlProtocol::write_press (Mackie::Button&)
 790 {
 791         return none;
 792 }
 793 Mackie::LedState
 794 MackieControlProtocol::write_release (Mackie::Button&)
 795 {
 796         return none;
 797 }
 798 Mackie::LedState
 799 MackieControlProtocol::clearsolo_press (Mackie::Button&)
 800 {
 801         return none;
 802 }
 803 Mackie::LedState
 804 MackieControlProtocol::clearsolo_release (Mackie::Button&)
 805 {
 806         return none;
 807 }
 808 Mackie::LedState
 809 MackieControlProtocol::track_press (Mackie::Button&)
 810 {
 811
 812         return none;
 813 }
 814 Mackie::LedState
 815 MackieControlProtocol::track_release (Mackie::Button&)
 816 {
 817         return none;
 818 }
 819 Mackie::LedState
 820 MackieControlProtocol::send_press (Mackie::Button&)
 821 {
 822 // code moved here from "sends_press"
 823         set_view_mode (Sends);
 824         return on;
 825 //      return none;
 826 }
 827 Mackie::LedState
 828 MackieControlProtocol::send_release (Mackie::Button&)
 829 {
 830         return none;
 831 }
 832 Mackie::LedState
 833 MackieControlProtocol::miditracks_press (Mackie::Button&)
 834 {
 835         return none;
 836 }
 837 Mackie::LedState
 838 MackieControlProtocol::miditracks_release (Mackie::Button&)
 839 {
 840         return none;
 841 }
 842 Mackie::LedState
 843 MackieControlProtocol::inputs_press (Mackie::Button&)
 844 {
 845         return none;
 846 }
 847 Mackie::LedState
 848 MackieControlProtocol::inputs_release (Mackie::Button&)
 849 {
 850         return none;
 851 }
 852 Mackie::LedState
 853 MackieControlProtocol::audiotracks_press (Mackie::Button&)
 854 {
 855         return none;
 856 }
 857 Mackie::LedState
 858 MackieControlProtocol::audiotracks_release (Mackie::Button&)
 859 {
 860         return none;
 861 }
 862 Mackie::LedState
 863 MackieControlProtocol::audioinstruments_press (Mackie::Button&)
 864 {
 865         return none;
 866 }
 867 Mackie::LedState
 868 MackieControlProtocol::audioinstruments_release (Mackie::Button&)
 869 {
 870         return none;
 871 }
 872 Mackie::LedState
 873 MackieControlProtocol::aux_press (Mackie::Button&)
 874 {
 875         return none;
 876 }
 877 Mackie::LedState
 878 MackieControlProtocol::aux_release (Mackie::Button&)
 879 {
 880         return none;
 881 }
 882 Mackie::LedState
 883 MackieControlProtocol::busses_press (Mackie::Button&)
 884 {
 885         return none;
 886 }
 887 Mackie::LedState
 888 MackieControlProtocol::busses_release (Mackie::Button&)
 889 {
 890         return none;
 891 }
 892 Mackie::LedState
 893 MackieControlProtocol::outputs_press (Mackie::Button&)
 894 {
 895         return none;
 896 }
 897 Mackie::LedState
 898 MackieControlProtocol::outputs_release (Mackie::Button&)
 899 {
 900         return none;
 901 }
 902 Mackie::LedState
 903 MackieControlProtocol::user_press (Mackie::Button&)
 904 {
 905         return none;
 906 }
 907 Mackie::LedState
 908 MackieControlProtocol::user_release (Mackie::Button&)
 909 {
 910         return none;
 911 }
 912 Mackie::LedState
 913 MackieControlProtocol::trim_press (Mackie::Button&)
 914 {
 915         return none;
 916 }
 917 Mackie::LedState
 918 MackieControlProtocol::trim_release (Mackie::Button&)
 919 {
 920         return none;
 921 }
 922 Mackie::LedState
 923 MackieControlProtocol::latch_press (Mackie::Button&)
 924 {
 925         return none;
 926 }
 927 Mackie::LedState
 928 MackieControlProtocol::latch_release (Mackie::Button&)
 929 {
 930         return none;
 931 }
 932 Mackie::LedState
 933 MackieControlProtocol::grp_press (Mackie::Button&)
 934 {
 935         return none;
 936 }
 937 Mackie::LedState
 938 MackieControlProtocol::grp_release (Mackie::Button&)
 939 {
 940         return none;
 941 }
 942 Mackie::LedState
 943 MackieControlProtocol::nudge_press (Mackie::Button&)
 944 {
 945         return none;
 946 }
 947 Mackie::LedState
 948 MackieControlProtocol::nudge_release (Mackie::Button&)
 949 {
 950         return none;
 951 }
 952 Mackie::LedState
 953 MackieControlProtocol::replace_press (Mackie::Button&)
 954 {
 955         return none;
 956 }
 957 Mackie::LedState
 958 MackieControlProtocol::replace_release (Mackie::Button&)
 959 {
 960         return none;
 961 }
 962 Mackie::LedState
 963 MackieControlProtocol::click_press (Mackie::Button&)
 964 {
 965         return none;
 966 }
 967 Mackie::LedState
 968 MackieControlProtocol::click_release (Mackie::Button&)
 969 {
 970         return none;
 971 }
 972 Mackie::LedState
 973 MackieControlProtocol::view_press (Mackie::Button&)
 974 {
 975         return none;
 976 }
 977 Mackie::LedState
 978 MackieControlProtocol::view_release (Mackie::Button&)
 979 {
 980         return none;
 981 }