libs/surfaces/mackie/mackie_control_protocol.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 <fcntl.h>
  21 #include <iostream>
  22 #include <algorithm>
  23 #include <cmath>
  24 #include <sstream>
  25 #include <vector>
  26 #include <iomanip>
  27
  28 #include <inttypes.h>
  29 #include <float.h>
  30 #include <sys/time.h>
  31 #include <errno.h>
  32
  33 #include <boost/shared_array.hpp>
  34 #include <glibmm/miscutils.h>
  35
  36 #include "midi++/types.h"
  37 #include "midi++/port.h"
  38 #include "midi++/ipmidi_port.h"
  39 #include "pbd/pthread_utils.h"
  40 #include "pbd/error.h"
  41 #include "pbd/memento_command.h"
  42 #include "pbd/convert.h"
  43
  44 #include "ardour/audio_track.h"
  45 #include "ardour/automation_control.h"
  46 #include "ardour/async_midi_port.h"
  47 #include "ardour/dB.h"
  48 #include "ardour/debug.h"
  49 #include "ardour/location.h"
  50 #include "ardour/meter.h"
  51 #include "ardour/midi_track.h"
  52 #include "ardour/panner.h"
  53 #include "ardour/panner_shell.h"
  54 #include "ardour/profile.h"
  55 #include "ardour/route.h"
  56 #include "ardour/route_group.h"
  57 #include "ardour/session.h"
  58 #include "ardour/tempo.h"
  59 #include "ardour/track.h"
  60 #include "ardour/types.h"
  61 #include "ardour/audioengine.h"
  62
  63 #include "mackie_control_protocol.h"
  64
  65 #include "midi_byte_array.h"
  66 #include "mackie_control_exception.h"
  67 #include "device_profile.h"
  68 #include "surface_port.h"
  69 #include "surface.h"
  70 #include "strip.h"
  71 #include "control_group.h"
  72 #include "meter.h"
  73 #include "button.h"
  74 #include "fader.h"
  75 #include "pot.h"
  76
  77 using namespace ARDOUR;
  78 using namespace std;
  79 using namespace PBD;
  80 using namespace Glib;
  81 using namespace ArdourSurface;
  82 using namespace Mackie;
  83
  84 #include "i18n.h"
  85
  86 #include "pbd/abstract_ui.cc" // instantiate template
  87
  88 const int MackieControlProtocol::MODIFIER_OPTION = 0x1;
  89 const int MackieControlProtocol::MODIFIER_CONTROL = 0x2;
  90 const int MackieControlProtocol::MODIFIER_SHIFT = 0x4;
  91 const int MackieControlProtocol::MODIFIER_CMDALT = 0x8;
  92 const int MackieControlProtocol::MODIFIER_ZOOM = 0x10;
  93 const int MackieControlProtocol::MODIFIER_SCRUB = 0x20;
  94 const int MackieControlProtocol::MODIFIER_MARKER = 0x40;
  95 const int MackieControlProtocol::MODIFIER_NUDGE = 0x80;
  96 const int MackieControlProtocol::MAIN_MODIFIER_MASK = (MackieControlProtocol::MODIFIER_OPTION|
  97                                                        MackieControlProtocol::MODIFIER_CONTROL|
  98                                                        MackieControlProtocol::MODIFIER_SHIFT|
  99                                                        MackieControlProtocol::MODIFIER_CMDALT);
 100
 101 MackieControlProtocol* MackieControlProtocol::_instance = 0;
 102
 103 bool MackieControlProtocol::probe()
 104 {
 105         return true;
 106 }
 107
 108 MackieControlProtocol::MackieControlProtocol (Session& session)
 109         : ControlProtocol (session, X_("Mackie"))
 110         , AbstractUI<MackieControlUIRequest> (name())
 111         , _current_initial_bank (0)
 112         , _frame_last (0)
 113         , _timecode_type (ARDOUR::AnyTime::BBT)
 114         , _gui (0)
 115         , _scrub_mode (false)
 116         , _flip_mode (Normal)
 117         , _view_mode (Mixer)
 118         , _subview_mode (None)
 119         , _pot_mode (Pan)
 120         , _current_selected_track (-1)
 121         , _modifier_state (0)
 122         , _ipmidi_base (MIDI::IPMIDIPort::lowest_ipmidi_port_default)
 123         , needs_ipmidi_restart (false)
 124         , _metering_active (true)
 125         , _initialized (false)
 126         , configuration_state (0)
 127         , state_version (0)
 128         , marker_modifier_consumed_by_button (false)
 129         , nudge_modifier_consumed_by_button (false)
 130 {
 131         DEBUG_TRACE (DEBUG::MackieControl, "MackieControlProtocol::MackieControlProtocol\n");
 132
 133         DeviceInfo::reload_device_info ();
 134         DeviceProfile::reload_device_profiles ();
 135
 136         for (int i = 0; i < 9; i++) {
 137                 _last_bank[i] = 0;
 138         }
 139
 140         _last_bank[Mixer] = _current_selected_track;
 141
 142         TrackSelectionChanged.connect (gui_connections, MISSING_INVALIDATOR, boost::bind (&MackieControlProtocol::gui_track_selection_changed, this, _1, true), this);
 143
 144         _instance = this;
 145
 146         build_button_map ();
 147 }
 148
 149 MackieControlProtocol::~MackieControlProtocol()
 150 {
 151         DEBUG_TRACE (DEBUG::MackieControl, "MackieControlProtocol::~MackieControlProtocol init\n");
 152
 153         for (Surfaces::const_iterator si = surfaces.begin(); si != surfaces.end(); ++si) {
 154                 (*si)->reset ();
 155         }
 156
 157         DEBUG_TRACE (DEBUG::MackieControl, "MackieControlProtocol::~MackieControlProtocol drop_connections ()\n");
 158         drop_connections ();
 159
 160         DEBUG_TRACE (DEBUG::MackieControl, "MackieControlProtocol::~MackieControlProtocol tear_down_gui ()\n");
 161         tear_down_gui ();
 162
 163         delete configuration_state;
 164
 165         /* stop event loop */
 166         DEBUG_TRACE (DEBUG::MackieControl, "MackieControlProtocol::~MackieControlProtocol BaseUI::quit ()\n");
 167         BaseUI::quit ();
 168
 169         try {
 170                 DEBUG_TRACE (DEBUG::MackieControl, "MackieControlProtocol::~MackieControlProtocol close()\n");
 171                 close();
 172         }
 173         catch (exception & e) {
 174                 cout << "~MackieControlProtocol caught " << e.what() << endl;
 175         }
 176         catch (...) {
 177                 cout << "~MackieControlProtocol caught unknown" << endl;
 178         }
 179
 180         _instance = 0;
 181
 182         DEBUG_TRACE (DEBUG::MackieControl, "MackieControlProtocol::~MackieControlProtocol done\n");
 183 }
 184
 185 void
 186 MackieControlProtocol::thread_init ()
 187 {
 188         struct sched_param rtparam;
 189
 190         pthread_set_name (event_loop_name().c_str());
 191
 192         PBD::notify_event_loops_about_thread_creation (pthread_self(), event_loop_name(), 2048);
 193         ARDOUR::SessionEvent::create_per_thread_pool (event_loop_name(), 128);
 194
 195         memset (&rtparam, 0, sizeof (rtparam));
 196         rtparam.sched_priority = 9; /* XXX should be relative to audio (JACK) thread */
 197
 198         if (pthread_setschedparam (pthread_self(), SCHED_FIFO, &rtparam) != 0) {
 199                 // do we care? not particularly.
 200         }
 201 }
 202
 203 void
 204 MackieControlProtocol::ping_devices ()
 205 {
 206         /* should not be called if surfaces are not connected, but will not
 207          * malfunction if it is.
 208          */
 209
 210         for (Surfaces::const_iterator si = surfaces.begin(); si != surfaces.end(); ++si) {
 211                 (*si)->connected ();
 212         }
 213 }
 214
 215 // go to the previous track.
 216 // Assume that get_sorted_routes().size() > route_table.size()
 217 void
 218 MackieControlProtocol::prev_track()
 219 {
 220         if (_current_initial_bank >= 1) {
 221                 switch_banks (_current_initial_bank - 1);
 222         }
 223 }
 224
 225 // go to the next track.
 226 // Assume that get_sorted_routes().size() > route_table.size()
 227 void
 228 MackieControlProtocol::next_track()
 229 {
 230         Sorted sorted = get_sorted_routes();
 231         if (_current_initial_bank + n_strips() < sorted.size()) {
 232                 switch_banks (_current_initial_bank + 1);
 233         }
 234 }
 235
 236 bool
 237 MackieControlProtocol::route_is_locked_to_strip (boost::shared_ptr<Route> r) const
 238 {
 239         for (Surfaces::const_iterator si = surfaces.begin(); si != surfaces.end(); ++si) {
 240                 if ((*si)->route_is_locked_to_strip (r)) {
 241                         return true;
 242                 }
 243         }
 244         return false;
 245 }
 246
 247 // predicate for sort call in get_sorted_routes
 248 struct RouteByRemoteId
 249 {
 250         bool operator () (const boost::shared_ptr<Route> & a, const boost::shared_ptr<Route> & b) const
 251         {
 252                 return a->remote_control_id() < b->remote_control_id();
 253         }
 254
 255         bool operator () (const Route & a, const Route & b) const
 256         {
 257                 return a.remote_control_id() < b.remote_control_id();
 258         }
 259
 260         bool operator () (const Route * a, const Route * b) const
 261         {
 262                 return a->remote_control_id() < b->remote_control_id();
 263         }
 264 };
 265
 266 MackieControlProtocol::Sorted
 267 MackieControlProtocol::get_sorted_routes()
 268 {
 269         Sorted sorted;
 270
 271         // fetch all routes
 272         boost::shared_ptr<RouteList> routes = session->get_routes();
 273         set<uint32_t> remote_ids;
 274
 275         // routes with remote_id 0 should never be added
 276         // TODO verify this with ardour devs
 277         // remote_ids.insert (0);
 278
 279         // sort in remote_id order, and exclude master, control and hidden routes
 280         // and any routes that are already set.
 281
 282         for (RouteList::iterator it = routes->begin(); it != routes->end(); ++it) {
 283
 284                 boost::shared_ptr<Route> route = *it;
 285
 286                 if (remote_ids.find (route->remote_control_id()) != remote_ids.end()) {
 287                         continue;
 288                 }
 289
 290                 if (route->is_auditioner() || route->is_master() || route->is_monitor()) {
 291                         continue;
 292                 }
 293
 294                 /* don't include locked routes */
 295
 296                 if (route_is_locked_to_strip(route)) {
 297                         continue;
 298                 }
 299
 300                 switch (_view_mode) {
 301                 case Mixer:
 302                         if (! is_hidden(route)) {
 303                                 sorted.push_back (route);
 304                                 remote_ids.insert (route->remote_control_id());
 305                         }
 306                         break;
 307                 case AudioTracks:
 308                         if (is_audio_track(route) && !is_hidden(route)) {
 309                                 sorted.push_back (route);
 310                                 remote_ids.insert (route->remote_control_id());
 311                         }
 312                         break;
 313                 case Busses:
 314                         if (Profile->get_mixbus()) {
 315 #ifdef MIXBUS
 316                                 if (route->mixbus()) {
 317                                         sorted.push_back (route);
 318                                         remote_ids.insert (route->remote_control_id());
 319                                 }
 320 #endif
 321                         } else {
 322                                 if (!is_track(route) && !is_hidden(route)) {
 323                                         sorted.push_back (route);
 324                                         remote_ids.insert (route->remote_control_id());
 325                                 }
 326                         }
 327                         break;
 328                 case MidiTracks:
 329                         if (is_midi_track(route) && !is_hidden(route)) {
 330                                 sorted.push_back (route);
 331                                 remote_ids.insert (route->remote_control_id());
 332                         }
 333                         break;
 334                 case Plugins:
 335                         break;
 336                 case Auxes: // in ardour, for now aux and buss are same. for mixbus, "Busses" are mixbuses, "Auxes" are ardour buses
 337 #ifdef MIXBUS
 338                         if (!route->mixbus() && !is_track(route) && !is_hidden(route))
 339 #else
 340                         if (!is_track(route) && !is_hidden(route))
 341 #endif
 342                         {
 343                                 sorted.push_back (route);
 344                                 remote_ids.insert (route->remote_control_id());
 345                         }
 346                         break;
 347                 case Hidden: // Show all the tracks we have hidden
 348                         if (is_hidden(route)) {
 349                                 // maybe separate groups
 350                                 sorted.push_back (route);
 351                                 remote_ids.insert (route->remote_control_id());
 352                         }
 353                         break;
 354                 case Selected: // For example: a group (this is USER)
 355                         if (selected(route) && !is_hidden(route)) {
 356                                 sorted.push_back (route);
 357                                 remote_ids.insert (route->remote_control_id());
 358                         }
 359                         break;
 360                 }
 361
 362         }
 363
 364         sort (sorted.begin(), sorted.end(), RouteByRemoteId());
 365         return sorted;
 366 }
 367
 368 void
 369 MackieControlProtocol::refresh_current_bank()
 370 {
 371         switch_banks (_current_initial_bank, true);
 372 }
 373
 374 uint32_t
 375 MackieControlProtocol::n_strips (bool with_locked_strips) const
 376 {
 377         uint32_t strip_count = 0;
 378
 379         for (Surfaces::const_iterator si = surfaces.begin(); si != surfaces.end(); ++si) {
 380                 strip_count += (*si)->n_strips (with_locked_strips);
 381         }
 382
 383         return strip_count;
 384 }
 385
 386 int
 387 MackieControlProtocol::switch_banks (uint32_t initial, bool force)
 388 {
 389         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("switch banking to start at %1 force ? %2 current = %3\n", initial, force, _current_initial_bank));
 390
 391         if (initial == _current_initial_bank && !force) {
 392                 /* everything is as it should be */
 393                 return 0;
 394         }
 395
 396         Sorted sorted = get_sorted_routes();
 397         uint32_t strip_cnt = n_strips (false); // do not include locked strips
 398                                                // in this count
 399
 400         if (initial >= sorted.size()) {
 401                 /* too high, we can't get there */
 402                 return -1;
 403         }
 404
 405         if (sorted.size() <= strip_cnt && _current_initial_bank == 0 && !force) {
 406                 /* no banking - not enough routes to fill all strips and we're
 407                  * not at the first one.
 408                  */
 409                 return -1;
 410         }
 411
 412         _current_initial_bank = initial;
 413         _current_selected_track = -1;
 414
 415         // Map current bank of routes onto each surface(+strip)
 416
 417         if (_current_initial_bank < sorted.size()) {
 418
 419                 DEBUG_TRACE (DEBUG::MackieControl, string_compose ("switch to %1, %2, available routes %3 on %4 surfaces\n",
 420                                                                    _current_initial_bank, strip_cnt, sorted.size(),
 421                                                                    surfaces.size()));
 422
 423                 // link routes to strips
 424
 425                 Sorted::iterator r = sorted.begin() + _current_initial_bank;
 426
 427                 for (Surfaces::iterator si = surfaces.begin(); si != surfaces.end(); ++si) {
 428                         vector<boost::shared_ptr<Route> > routes;
 429                         uint32_t added = 0;
 430
 431                         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("surface has %1 unlockedstrips\n", (*si)->n_strips (false)));
 432
 433                         for (; r != sorted.end() && added < (*si)->n_strips (false); ++r, ++added) {
 434                                 routes.push_back (*r);
 435                         }
 436
 437                         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("give surface %1 routes\n", routes.size()));
 438
 439                         (*si)->map_routes (routes);
 440                 }
 441
 442         } else {
 443                 return -1;
 444         }
 445
 446         /* make sure selection is correct */
 447
 448         _gui_track_selection_changed (&_last_selected_routes, false, false);
 449
 450         /* current bank has not been saved */
 451         session->set_dirty();
 452
 453         return 0;
 454 }
 455
 456 int
 457 MackieControlProtocol::set_active (bool yn)
 458 {
 459         DEBUG_TRACE (DEBUG::MackieControl, string_compose("MackieControlProtocol::set_active init with yn: '%1'\n", yn));
 460
 461         if (yn == active()) {
 462                 return 0;
 463         }
 464
 465         if (yn) {
 466
 467                 /* start event loop */
 468
 469                 BaseUI::run ();
 470
 471                 connect_session_signals ();
 472
 473                 if (!_device_info.name().empty()) {
 474                         set_device (_device_info.name(), true);
 475                 }
 476
 477                 /* set up periodic task for timecode display and metering and automation
 478                  */
 479
 480                 Glib::RefPtr<Glib::TimeoutSource> periodic_timeout = Glib::TimeoutSource::create (100); // milliseconds
 481                 periodic_connection = periodic_timeout->connect (sigc::mem_fun (*this, &MackieControlProtocol::periodic));
 482                 periodic_timeout->attach (main_loop()->get_context());
 483
 484                 /* periodic task used to update strip displays */
 485
 486                 Glib::RefPtr<Glib::TimeoutSource> redisplay_timeout = Glib::TimeoutSource::create (10); // milliseconds
 487                 redisplay_connection = redisplay_timeout->connect (sigc::mem_fun (*this, &MackieControlProtocol::redisplay));
 488                 redisplay_timeout->attach (main_loop()->get_context());
 489
 490         } else {
 491
 492                 BaseUI::quit ();
 493                 close ();
 494
 495         }
 496
 497         ControlProtocol::set_active (yn);
 498
 499         DEBUG_TRACE (DEBUG::MackieControl, string_compose("MackieControlProtocol::set_active done with yn: '%1'\n", yn));
 500
 501         return 0;
 502 }
 503
 504 bool
 505 MackieControlProtocol::hui_heartbeat ()
 506 {
 507         Glib::Threads::Mutex::Lock lm (surfaces_lock);
 508
 509         for (Surfaces::iterator s = surfaces.begin(); s != surfaces.end(); ++s) {
 510                 (*s)->hui_heartbeat ();
 511         }
 512
 513         return true;
 514 }
 515
 516 bool
 517 MackieControlProtocol::periodic ()
 518 {
 519         if (!active()) {
 520                 return false;
 521         }
 522
 523         if (!_initialized) {
 524                 /* wait for higher-frequency redisplay() callback to initialize
 525                  * us
 526                  */
 527                 return true;
 528         }
 529
 530         update_timecode_display ();
 531
 532         ARDOUR::microseconds_t now_usecs = ARDOUR::get_microseconds ();
 533
 534         {
 535                 Glib::Threads::Mutex::Lock lm (surfaces_lock);
 536
 537                 for (Surfaces::iterator s = surfaces.begin(); s != surfaces.end(); ++s) {
 538                         (*s)->periodic (now_usecs);
 539                 }
 540         }
 541
 542         return true;
 543 }
 544
 545 bool
 546 MackieControlProtocol::redisplay ()
 547 {
 548         if (!active()) {
 549                 return false;
 550         }
 551
 552         if (needs_ipmidi_restart) {
 553                 ipmidi_restart ();
 554                 return true;
 555         }
 556
 557         if (!_initialized) {
 558                 initialize();
 559         }
 560
 561         ARDOUR::microseconds_t now = ARDOUR::get_microseconds ();
 562
 563         {
 564                 Glib::Threads::Mutex::Lock lm (surfaces_lock);
 565
 566                 for (Surfaces::iterator s = surfaces.begin(); s != surfaces.end(); ++s) {
 567                         (*s)->redisplay (now, false);
 568                 }
 569         }
 570
 571         return true;
 572 }
 573
 574 void
 575 MackieControlProtocol::update_timecode_beats_led()
 576 {
 577         if (!_device_info.has_timecode_display()) {
 578                 return;
 579         }
 580
 581         DEBUG_TRACE (DEBUG::MackieControl, string_compose("MackieControlProtocol::update_timecode_beats_led(): %1\n", _timecode_type));
 582         switch (_timecode_type) {
 583                 case ARDOUR::AnyTime::BBT:
 584                         update_global_led (Led::Beats, on);
 585                         update_global_led (Led::Timecode, off);
 586                         break;
 587                 case ARDOUR::AnyTime::Timecode:
 588                         update_global_led (Led::Timecode, on);
 589                         update_global_led (Led::Beats, off);
 590                         break;
 591                 default:
 592                         ostringstream os;
 593                         os << "Unknown Anytime::Type " << _timecode_type;
 594                         throw runtime_error (os.str());
 595         }
 596 }
 597
 598 void
 599 MackieControlProtocol::update_global_button (int id, LedState ls)
 600 {
 601         boost::shared_ptr<Surface> surface;
 602
 603         {
 604                 Glib::Threads::Mutex::Lock lm (surfaces_lock);
 605
 606                 if (surfaces.empty()) {
 607                         return;
 608                 }
 609
 610                 if (!_device_info.has_global_controls()) {
 611                         return;
 612                 }
 613                 // surface needs to be master surface
 614                 surface = _master_surface;
 615         }
 616
 617         map<int,Control*>::iterator x = surface->controls_by_device_independent_id.find (id);
 618         if (x != surface->controls_by_device_independent_id.end()) {
 619                 Button * button = dynamic_cast<Button*> (x->second);
 620                 surface->write (button->set_state (ls));
 621         } else {
 622                 DEBUG_TRACE (DEBUG::MackieControl, string_compose ("Button %1 not found\n", id));
 623         }
 624 }
 625
 626 void
 627 MackieControlProtocol::update_global_led (int id, LedState ls)
 628 {
 629         Glib::Threads::Mutex::Lock lm (surfaces_lock);
 630
 631         if (surfaces.empty()) {
 632                 return;
 633         }
 634
 635         if (!_device_info.has_global_controls()) {
 636                 return;
 637         }
 638         boost::shared_ptr<Surface> surface = _master_surface;
 639
 640         map<int,Control*>::iterator x = surface->controls_by_device_independent_id.find (id);
 641
 642         if (x != surface->controls_by_device_independent_id.end()) {
 643                 Led * led = dynamic_cast<Led*> (x->second);
 644                 DEBUG_TRACE (DEBUG::MackieControl, "Writing LedState\n");
 645                 surface->write (led->set_state (ls));
 646         } else {
 647                 DEBUG_TRACE (DEBUG::MackieControl, string_compose ("Led %1 not found\n", id));
 648         }
 649 }
 650
 651 void
 652 MackieControlProtocol::device_ready ()
 653 {
 654         /* this is not required to be called, but for devices which do
 655          * handshaking, it can be called once the device has verified the
 656          * connection.
 657          */
 658
 659         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("device ready init (active=%1)\n", active()));
 660         update_surfaces ();
 661         set_pot_mode (_pot_mode);
 662 }
 663
 664 // send messages to surface to set controls to correct values
 665 void
 666 MackieControlProtocol::update_surfaces()
 667 {
 668         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("MackieControlProtocol::update_surfaces() init (active=%1)\n", active()));
 669         if (!active()) {
 670                 return;
 671         }
 672
 673         // do the initial bank switch to connect signals
 674         // _current_initial_bank is initialised by set_state
 675         (void) switch_banks (_current_initial_bank, true);
 676
 677         DEBUG_TRACE (DEBUG::MackieControl, "MackieControlProtocol::update_surfaces() finished\n");
 678 }
 679
 680 void
 681 MackieControlProtocol::initialize()
 682 {
 683         {
 684                 Glib::Threads::Mutex::Lock lm (surfaces_lock);
 685
 686                 if (surfaces.empty()) {
 687                         return;
 688                 }
 689
 690                 if (!_master_surface->active ()) {
 691                         return;
 692                 }
 693
 694                 // sometimes the jog wheel is a pot
 695                 if (_device_info.has_jog_wheel()) {
 696                         _master_surface->blank_jog_ring ();
 697                 }
 698         }
 699
 700         // update global buttons and displays
 701
 702         notify_record_state_changed();
 703         notify_transport_state_changed();
 704         update_timecode_beats_led();
 705
 706         _initialized = true;
 707 }
 708
 709 void
 710 MackieControlProtocol::connect_session_signals()
 711 {
 712         // receive routes added
 713         session->RouteAdded.connect(session_connections, MISSING_INVALIDATOR, boost::bind (&MackieControlProtocol::notify_route_added, this, _1), this);
 714         session->RouteAddedOrRemoved.connect(session_connections, MISSING_INVALIDATOR, boost::bind (&MackieControlProtocol::notify_route_added_or_removed, this), this);
 715         // receive record state toggled
 716         session->RecordStateChanged.connect(session_connections, MISSING_INVALIDATOR, boost::bind (&MackieControlProtocol::notify_record_state_changed, this), this);
 717         // receive transport state changed
 718         session->TransportStateChange.connect(session_connections, MISSING_INVALIDATOR, boost::bind (&MackieControlProtocol::notify_transport_state_changed, this), this);
 719         session->TransportLooped.connect (session_connections, MISSING_INVALIDATOR, boost::bind (&MackieControlProtocol::notify_loop_state_changed, this), this);
 720         // receive punch-in and punch-out
 721         Config->ParameterChanged.connect(session_connections, MISSING_INVALIDATOR, boost::bind (&MackieControlProtocol::notify_parameter_changed, this, _1), this);
 722         session->config.ParameterChanged.connect (session_connections, MISSING_INVALIDATOR, boost::bind (&MackieControlProtocol::notify_parameter_changed, this, _1), this);
 723         // receive rude solo changed
 724         session->SoloActive.connect(session_connections, MISSING_INVALIDATOR, boost::bind (&MackieControlProtocol::notify_solo_active_changed, this, _1), this);
 725
 726         // make sure remote id changed signals reach here
 727         // see also notify_route_added
 728         Sorted sorted = get_sorted_routes();
 729
 730         for (Sorted::iterator it = sorted.begin(); it != sorted.end(); ++it) {
 731                 (*it)->RemoteControlIDChanged.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&MackieControlProtocol::notify_remote_id_changed, this), this);
 732         }
 733 }
 734
 735 void
 736 MackieControlProtocol::set_profile (const string& profile_name)
 737 {
 738         map<string,DeviceProfile>::iterator d = DeviceProfile::device_profiles.find (profile_name);
 739
 740         if (d == DeviceProfile::device_profiles.end()) {
 741                 _device_profile = DeviceProfile (profile_name);
 742                 return;
 743         }
 744
 745         _device_profile = d->second;
 746 }
 747
 748 int
 749 MackieControlProtocol::set_device_info (const string& device_name)
 750 {
 751         map<string,DeviceInfo>::iterator d = DeviceInfo::device_info.find (device_name);
 752
 753         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("new device chosen %1\n", device_name));
 754
 755         if (d == DeviceInfo::device_info.end()) {
 756                 return -1;
 757         }
 758
 759         _device_info = d->second;
 760
 761         return 0;
 762 }
 763
 764 int
 765 MackieControlProtocol::set_device (const string& device_name, bool force)
 766 {
 767         if (device_name == device_info().name() && !force) {
 768                 /* already using that device, nothing to do */
 769                 return 0;
 770         }
 771         /* get state from the current setup, and make sure it is stored in
 772            the configuration_states node so that if we switch back to this device,
 773            we will have its state available.
 774         */
 775
 776         {
 777                 Glib::Threads::Mutex::Lock lm (surfaces_lock);
 778                 if (!surfaces.empty()) {
 779                         update_configuration_state ();
 780                 }
 781         }
 782
 783         if (set_device_info (device_name)) {
 784                 return -1;
 785         }
 786
 787         clear_surfaces ();
 788         port_connection.disconnect ();
 789         hui_connection.disconnect ();
 790
 791         if (_device_info.device_type() == DeviceInfo::HUI) {
 792                 Glib::RefPtr<Glib::TimeoutSource> hui_timeout = Glib::TimeoutSource::create (1000); // milliseconds
 793                 hui_connection = hui_timeout->connect (sigc::mem_fun (*this, &MackieControlProtocol::hui_heartbeat));
 794                 hui_timeout->attach (main_loop()->get_context());
 795         }
 796
 797         if (!_device_info.uses_ipmidi()) {
 798                 /* notice that the handler for this will execute in our event
 799                    loop, not in the thread where the
 800                    PortConnectedOrDisconnected signal is emitted.
 801                 */
 802                 ARDOUR::AudioEngine::instance()->PortConnectedOrDisconnected.connect (port_connection, MISSING_INVALIDATOR, boost::bind (&MackieControlProtocol::connection_handler, this, _1, _2, _3, _4, _5), this);
 803         }
 804
 805         if (create_surfaces ()) {
 806                 return -1;
 807         }
 808
 809         DeviceChanged ();
 810
 811         return 0;
 812 }
 813
 814 gboolean
 815 ArdourSurface::ipmidi_input_handler (GIOChannel*, GIOCondition condition, void *data)
 816 {
 817         ArdourSurface::MackieControlProtocol::ipMIDIHandler* ipm = static_cast<ArdourSurface::MackieControlProtocol::ipMIDIHandler*>(data);
 818         return ipm->mcp->midi_input_handler (Glib::IOCondition (condition), ipm->port);
 819 }
 820
 821 int
 822 MackieControlProtocol::create_surfaces ()
 823 {
 824         string device_name;
 825         surface_type_t stype = mcu; // type not yet determined
 826
 827         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("Create %1 surfaces for %2\n", 1 + _device_info.extenders(), _device_info.name()));
 828
 829         if (!_device_info.uses_ipmidi()) {
 830                 _input_bundle.reset (new ARDOUR::Bundle (_("Mackie Control In"), true));
 831                 _output_bundle.reset (new ARDOUR::Bundle (_("Mackie Control Out"), false));
 832         } else {
 833                 _input_bundle.reset ();
 834                 _output_bundle.reset ();
 835
 836         }
 837         for (uint32_t n = 0; n < 1 + _device_info.extenders(); ++n) {
 838                 bool is_master = false;
 839
 840                 if (n == _device_info.master_position()) {
 841                         is_master = true;
 842                         if (_device_info.extenders() == 0) {
 843                                 device_name = _device_info.name();
 844                         } else {
 845                                 device_name = X_("mackie control");
 846                         }
 847
 848                 }
 849
 850                 if (!is_master) {
 851                         device_name = string_compose (X_("mackie control ext %1"), n+1);
 852                 }
 853
 854                 DEBUG_TRACE (DEBUG::MackieControl, string_compose ("Port Name for surface %1 is %2\n", n, device_name));
 855
 856                 boost::shared_ptr<Surface> surface;
 857
 858                 if (is_master) {
 859                         stype = mcu;
 860                 } else {
 861                         stype = ext;
 862                 }
 863                 try {
 864                         surface.reset (new Surface (*this, device_name, n, stype));
 865                 } catch (...) {
 866                         return -1;
 867                 }
 868
 869                 if (is_master) {
 870                         _master_surface = surface;
 871                 }
 872
 873                 if (configuration_state) {
 874                         XMLNode* this_device = 0;
 875                         XMLNodeList const& devices = configuration_state->children();
 876                         for (XMLNodeList::const_iterator d = devices.begin(); d != devices.end(); ++d) {
 877                                 XMLProperty* prop = (*d)->property (X_("name"));
 878                                 if (prop && prop->value() == _device_info.name()) {
 879                                         this_device = *d;
 880                                         break;
 881                                 }
 882                         }
 883                         if (this_device) {
 884                                 XMLNode* snode = this_device->child (X_("Surfaces"));
 885                                 if (snode) {
 886                                         surface->set_state (*snode, state_version);
 887                                 }
 888                         }
 889                 }
 890
 891                 {
 892                         Glib::Threads::Mutex::Lock lm (surfaces_lock);
 893                         surfaces.push_back (surface);
 894                 }
 895
 896                 if (!_device_info.uses_ipmidi()) {
 897
 898                         _input_bundle->add_channel (
 899                                 surface->port().input_port().name(),
 900                                 ARDOUR::DataType::MIDI,
 901                                 session->engine().make_port_name_non_relative (surface->port().input_port().name())
 902                                 );
 903
 904                         _output_bundle->add_channel (
 905                                 surface->port().output_port().name(),
 906                                 ARDOUR::DataType::MIDI,
 907                                 session->engine().make_port_name_non_relative (surface->port().output_port().name())
 908                                 );
 909                 }
 910
 911                 MIDI::Port& input_port (surface->port().input_port());
 912                 AsyncMIDIPort* asp = dynamic_cast<AsyncMIDIPort*> (&input_port);
 913
 914                 if (asp) {
 915
 916                         /* async MIDI port */
 917
 918                         asp->xthread().set_receive_handler (sigc::bind (sigc::mem_fun (this, &MackieControlProtocol::midi_input_handler), &input_port));
 919                         asp->xthread().attach (main_loop()->get_context());
 920
 921                 } else {
 922
 923                         /* ipMIDI port, no IOSource method at this time */
 924
 925                         int fd;
 926
 927                         if ((fd = input_port.selectable ()) >= 0) {
 928
 929                                 GIOChannel* ioc = g_io_channel_unix_new (fd);
 930                                 surface->input_source = g_io_create_watch (ioc, GIOCondition (G_IO_IN|G_IO_HUP|G_IO_ERR));
 931
 932                                 /* make surface's input source now hold the
 933                                  * only reference on the IO channel
 934                                  */
 935                                 g_io_channel_unref (ioc);
 936
 937                                 /* hack up an object so that in the callback from the event loop
 938                                    we have both the MackieControlProtocol and the input port.
 939
 940                                    If we were using C++ for this stuff we wouldn't need this
 941                                    but a nasty, not-fixable bug in the binding between C
 942                                    and C++ makes it necessary to avoid C++ for the IO
 943                                    callback setup.
 944                                 */
 945
 946                                 ipMIDIHandler* ipm = new ipMIDIHandler (); /* we will leak this sizeof(pointer)*2 sized object */
 947                                 ipm->mcp = this;
 948                                 ipm->port = &input_port;
 949
 950                                 g_source_set_callback (surface->input_source, (GSourceFunc) ipmidi_input_handler, ipm, NULL);
 951                                 g_source_attach (surface->input_source, main_loop()->get_context()->gobj());
 952                         }
 953                 }
 954         }
 955
 956         if (!_device_info.uses_ipmidi()) {
 957                 Glib::Threads::Mutex::Lock lm (surfaces_lock);
 958                 for (Surfaces::iterator s = surfaces.begin(); s != surfaces.end(); ++s) {
 959                         (*s)->port().reconnect ();
 960                 }
 961         }
 962
 963         session->BundleAddedOrRemoved ();
 964
 965         assert (_master_surface);
 966
 967         return 0;
 968 }
 969
 970 void
 971 MackieControlProtocol::close()
 972 {
 973         port_connection.disconnect ();
 974         session_connections.drop_connections ();
 975         route_connections.drop_connections ();
 976         periodic_connection.disconnect ();
 977
 978         clear_surfaces();
 979 }
 980
 981 /** Ensure that the configuration_state XML node contains an up-to-date
 982  *  copy of the state node the current device. If configuration_state already
 983  *  contains a state node for the device, it will deleted and replaced.
 984  */
 985 void
 986 MackieControlProtocol::update_configuration_state ()
 987 {
 988         /* CALLER MUST HOLD SURFACES LOCK */
 989
 990         if (!configuration_state) {
 991                 configuration_state = new XMLNode (X_("Configurations"));
 992         }
 993
 994         XMLNode* devnode = new XMLNode (X_("Configuration"));
 995         devnode->add_property (X_("name"), _device_info.name());
 996
 997         configuration_state->remove_nodes_and_delete (X_("name"), _device_info.name());
 998         configuration_state->add_child_nocopy (*devnode);
 999
1000         XMLNode* snode = new XMLNode (X_("Surfaces"));
1001
1002         for (Surfaces::iterator s = surfaces.begin(); s != surfaces.end(); ++s) {
1003                 snode->add_child_nocopy ((*s)->get_state());
1004         }
1005
1006         devnode->add_child_nocopy (*snode);
1007 }
1008
1009 XMLNode&
1010 MackieControlProtocol::get_state()
1011 {
1012         XMLNode& node (ControlProtocol::get_state());
1013
1014         DEBUG_TRACE (DEBUG::MackieControl, "MackieControlProtocol::get_state init\n");
1015         char buf[16];
1016
1017         // add current bank
1018         snprintf (buf, sizeof (buf), "%d", _current_initial_bank);
1019         node.add_property (X_("bank"), buf);
1020
1021         // ipMIDI base port (possibly not used)
1022         snprintf (buf, sizeof (buf), "%d", _ipmidi_base);
1023         node.add_property (X_("ipmidi-base"), buf);
1024
1025         node.add_property (X_("device-profile"), _device_profile.name());
1026         node.add_property (X_("device-name"), _device_info.name());
1027
1028         {
1029                 Glib::Threads::Mutex::Lock lm (surfaces_lock);
1030                 update_configuration_state ();
1031         }
1032
1033         /* force a copy of the _surfaces_state node, because we want to retain ownership */
1034         node.add_child_copy (*configuration_state);
1035
1036         DEBUG_TRACE (DEBUG::MackieControl, "MackieControlProtocol::get_state done\n");
1037
1038         return node;
1039 }
1040
1041 int
1042 MackieControlProtocol::set_state (const XMLNode & node, int version)
1043 {
1044         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("MackieControlProtocol::set_state: active %1\n", active()));
1045
1046         int retval = 0;
1047         const XMLProperty* prop;
1048         uint32_t bank = 0;
1049
1050         if (ControlProtocol::set_state (node, version)) {
1051                 return -1;
1052         }
1053
1054         if ((prop = node.property (X_("ipmidi-base"))) != 0) {
1055                 set_ipmidi_base (atoi (prop->value()));
1056         }
1057
1058         // fetch current bank
1059         if ((prop = node.property (X_("bank"))) != 0) {
1060                 bank = atoi (prop->value());
1061         }
1062
1063         if ((prop = node.property (X_("device-name"))) != 0) {
1064                 set_device_info (prop->value());
1065         }
1066
1067         if ((prop = node.property (X_("device-profile"))) != 0) {
1068                 if (prop->value().empty()) {
1069                         string default_profile_name;
1070
1071                         default_profile_name = Glib::get_user_name();
1072                         default_profile_name += ' ';
1073                         default_profile_name += _device_info.name();
1074
1075                         set_profile (default_profile_name);
1076                 } else {
1077                         set_profile (prop->value());
1078                 }
1079         }
1080
1081         XMLNode* dnode = node.child (X_("Configurations"));
1082
1083         delete configuration_state;
1084         configuration_state = 0;
1085
1086         if (dnode) {
1087                 configuration_state = new XMLNode (*dnode);
1088                 state_version = version;
1089         }
1090
1091         (void) switch_banks (bank, true);
1092
1093         DEBUG_TRACE (DEBUG::MackieControl, "MackieControlProtocol::set_state done\n");
1094
1095         return retval;
1096 }
1097
1098 string
1099 MackieControlProtocol::format_bbt_timecode (framepos_t now_frame)
1100 {
1101         Timecode::BBT_Time bbt_time;
1102
1103         session->bbt_time (now_frame, bbt_time);
1104
1105         // The Mackie protocol spec is built around a BBT time display of
1106         //
1107         // digits:     888/88/88/888
1108         // semantics:  BBB/bb/ss/ttt
1109         //
1110         // The third field is "subdivisions" which is a concept found in Logic
1111         // but not present in Ardour. Instead Ardour displays a 4 digit tick
1112         // count, which we need to spread across the 5 digits of ss/ttt.
1113
1114         ostringstream os;
1115
1116         os << setw(3) << setfill('0') << bbt_time.bars;
1117         os << setw(2) << setfill('0') << bbt_time.beats;
1118         os << ' ';
1119         os << setw(1) << setfill('0') << bbt_time.ticks / 1000;
1120         os << setw(3) << setfill('0') << bbt_time.ticks % 1000;
1121
1122         return os.str();
1123 }
1124
1125 string
1126 MackieControlProtocol::format_timecode_timecode (framepos_t now_frame)
1127 {
1128         Timecode::Time timecode;
1129         session->timecode_time (now_frame, timecode);
1130
1131         // According to the Logic docs
1132         // digits: 888/88/88/888
1133         // Timecode mode: Hours/Minutes/Seconds/Frames
1134         ostringstream os;
1135         os << setw(2) << setfill('0') << timecode.hours;
1136         os << ' ';
1137         os << setw(2) << setfill('0') << timecode.minutes;
1138         os << setw(2) << setfill('0') << timecode.seconds;
1139         os << ' ';
1140         os << setw(2) << setfill('0') << timecode.frames;
1141
1142         return os.str();
1143 }
1144
1145 void
1146 MackieControlProtocol::update_timecode_display()
1147 {
1148         Glib::Threads::Mutex::Lock lm (surfaces_lock);
1149
1150         if (surfaces.empty()) {
1151                 return;
1152         }
1153
1154         boost::shared_ptr<Surface> surface = _master_surface;
1155
1156         if (surface->type() != mcu || !_device_info.has_timecode_display() || !surface->active ()) {
1157                 return;
1158         }
1159
1160         // do assignment here so current_frame is fixed
1161         framepos_t current_frame = session->transport_frame();
1162         string timecode;
1163         // For large jumps in play head possition do full reset
1164         int moved = (current_frame - _frame_last) / session->frame_rate ();
1165         if (moved) {
1166                 DEBUG_TRACE (DEBUG::MackieControl, "Timecode reset\n");
1167                 _timecode_last = string (10, ' ');
1168         }
1169         _frame_last = current_frame;
1170
1171         switch (_timecode_type) {
1172         case ARDOUR::AnyTime::BBT:
1173                 timecode = format_bbt_timecode (current_frame);
1174                 break;
1175         case ARDOUR::AnyTime::Timecode:
1176                 timecode = format_timecode_timecode (current_frame);
1177                 break;
1178         default:
1179                 return;
1180         }
1181
1182         // only write the timecode string to the MCU if it's changed
1183         // since last time. This is to reduce midi bandwidth used.
1184         if (timecode != _timecode_last) {
1185                 surface->display_timecode (timecode, _timecode_last);
1186                 _timecode_last = timecode;
1187         }
1188 }
1189
1190 ///////////////////////////////////////////
1191 // Session signals
1192 ///////////////////////////////////////////
1193
1194 void MackieControlProtocol::notify_parameter_changed (std::string const & p)
1195 {
1196         if (p == "punch-in") {
1197                 // no such button right now
1198                 // update_global_button (Button::PunchIn, session->config.get_punch_in());
1199         } else if (p == "punch-out") {
1200                 // no such button right now
1201                 // update_global_button (Button::PunchOut, session->config.get_punch_out());
1202         } else if (p == "clicking") {
1203                 update_global_button (Button::Click, Config->get_clicking());
1204         } else {
1205                 DEBUG_TRACE (DEBUG::MackieControl, string_compose ("parameter changed: %1\n", p));
1206         }
1207 }
1208
1209 void
1210 MackieControlProtocol::notify_route_added_or_removed ()
1211 {
1212         Glib::Threads::Mutex::Lock lm (surfaces_lock);
1213         for (Surfaces::iterator s = surfaces.begin(); s != surfaces.end(); ++s) {
1214                 (*s)->master_monitor_may_have_changed ();
1215         }
1216 }
1217
1218 // RouteList is the set of routes that have just been added
1219 void
1220 MackieControlProtocol::notify_route_added (ARDOUR::RouteList & rl)
1221 {
1222         {
1223                 Glib::Threads::Mutex::Lock lm (surfaces_lock);
1224
1225                 if (surfaces.empty()) {
1226                         return;
1227                 }
1228         }
1229
1230         /* special case: single route, and it is the monitor or master out */
1231
1232         if (rl.size() == 1 && (rl.front()->is_monitor() || rl.front()->is_master())) {
1233                 Glib::Threads::Mutex::Lock lm (surfaces_lock);
1234                 for (Surfaces::iterator s = surfaces.begin(); s != surfaces.end(); ++s) {
1235                         (*s)->master_monitor_may_have_changed ();
1236                 }
1237         }
1238
1239         // currently assigned banks are less than the full set of
1240         // strips, so activate the new strip now.
1241
1242         refresh_current_bank();
1243
1244         // otherwise route added, but current bank needs no updating
1245
1246         // make sure remote id changes in the new route are handled
1247         typedef ARDOUR::RouteList ARS;
1248
1249         for (ARS::iterator it = rl.begin(); it != rl.end(); ++it) {
1250                 (*it)->RemoteControlIDChanged.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&MackieControlProtocol::notify_remote_id_changed, this), this);
1251         }
1252 }
1253
1254 void
1255 MackieControlProtocol::notify_solo_active_changed (bool active)
1256 {
1257         boost::shared_ptr<Surface> surface;
1258
1259         {
1260                 Glib::Threads::Mutex::Lock lm (surfaces_lock);
1261
1262                 if (surfaces.empty()) {
1263                         return;
1264                 }
1265
1266                 surface = _master_surface;
1267         }
1268
1269         map<int,Control*>::iterator x = surface->controls_by_device_independent_id.find (Led::RudeSolo);
1270         if (x != surface->controls_by_device_independent_id.end()) {
1271                 Led* rude_solo = dynamic_cast<Led*> (x->second);
1272                 if (rude_solo) {
1273                         surface->write (rude_solo->set_state (active ? flashing : off));
1274                 }
1275         }
1276 }
1277
1278 void
1279 MackieControlProtocol::notify_remote_id_changed()
1280 {
1281         {
1282                 Glib::Threads::Mutex::Lock lm (surfaces_lock);
1283
1284                 if (surfaces.empty()) {
1285                         return;
1286                 }
1287         }
1288
1289         Sorted sorted = get_sorted_routes();
1290         uint32_t sz = n_strips();
1291
1292         // if a remote id has been moved off the end, we need to shift
1293         // the current bank backwards.
1294
1295         if (sorted.size() - _current_initial_bank < sz) {
1296                 // but don't shift backwards past the zeroth channel
1297                 if (sorted.size() < sz) {  // avoid unsigned math mistake below
1298                         (void) switch_banks(0, true);
1299                 } else {
1300                         (void) switch_banks (max((Sorted::size_type) 0, sorted.size() - sz), true);
1301                 }
1302         } else {
1303                 // Otherwise just refresh the current bank
1304                 refresh_current_bank();
1305         }
1306 }
1307
1308 ///////////////////////////////////////////
1309 // Transport signals
1310 ///////////////////////////////////////////
1311
1312 void
1313 MackieControlProtocol::notify_loop_state_changed()
1314 {
1315         update_global_button (Button::Loop, session->get_play_loop());
1316 }
1317
1318 void
1319 MackieControlProtocol::notify_transport_state_changed()
1320 {
1321         if (!_device_info.has_global_controls()) {
1322                 return;
1323         }
1324
1325         // switch various play and stop buttons on / off
1326         update_global_button (Button::Loop, session->get_play_loop());
1327         update_global_button (Button::Play, session->transport_speed() == 1.0);
1328         update_global_button (Button::Stop, session->transport_stopped ());
1329         update_global_button (Button::Rewind, session->transport_speed() < 0.0);
1330         update_global_button (Button::Ffwd, session->transport_speed() > 1.0);
1331
1332         /* turn off any LEDs for range buttons */
1333
1334         update_global_button (Button::Drop, off);
1335         update_global_button (Button::Replace, off);
1336
1337         // sometimes a return to start leaves time code at old time
1338         _timecode_last = string (10, ' ');
1339
1340         notify_metering_state_changed ();
1341 }
1342
1343 void
1344 MackieControlProtocol::notify_metering_state_changed()
1345 {
1346         Glib::Threads::Mutex::Lock lm (surfaces_lock);
1347
1348         for (Surfaces::iterator s = surfaces.begin(); s != surfaces.end(); ++s) {
1349                 (*s)->notify_metering_state_changed ();
1350         }
1351 }
1352
1353 void
1354 MackieControlProtocol::notify_record_state_changed ()
1355 {
1356         if (!_device_info.has_global_controls()) {
1357                 return;
1358         }
1359
1360         boost::shared_ptr<Surface> surface;
1361
1362         {
1363                 Glib::Threads::Mutex::Lock lm (surfaces_lock);
1364                 if (surfaces.empty()) {
1365                         return;
1366                 }
1367                 surface = _master_surface;
1368         }
1369
1370         /* rec is a tristate */
1371
1372         map<int,Control*>::iterator x = surface->controls_by_device_independent_id.find (Button::Record);
1373         if (x != surface->controls_by_device_independent_id.end()) {
1374                 Button * rec = dynamic_cast<Button*> (x->second);
1375                 if (rec) {
1376                         LedState ls;
1377
1378                         switch (session->record_status()) {
1379                         case Session::Disabled:
1380                                 DEBUG_TRACE (DEBUG::MackieControl, "record state changed to disabled, LED off\n");
1381                                 ls = off;
1382                                 break;
1383                         case Session::Recording:
1384                                 DEBUG_TRACE (DEBUG::MackieControl, "record state changed to recording, LED on\n");
1385                                 ls = on;
1386                                 break;
1387                         case Session::Enabled:
1388                                 DEBUG_TRACE (DEBUG::MackieControl, "record state changed to enabled, LED flashing\n");
1389                                 ls = flashing;
1390                                 break;
1391                         }
1392
1393                         surface->write (rec->set_state (ls));
1394                 }
1395         }
1396 }
1397
1398 list<boost::shared_ptr<ARDOUR::Bundle> >
1399 MackieControlProtocol::bundles ()
1400 {
1401         list<boost::shared_ptr<ARDOUR::Bundle> > b;
1402
1403         if (_input_bundle) {
1404                 b.push_back (_input_bundle);
1405                 b.push_back (_output_bundle);
1406         }
1407
1408         return b;
1409 }
1410
1411 void
1412 MackieControlProtocol::do_request (MackieControlUIRequest* req)
1413 {
1414         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("doing request type %1\n", req->type));
1415         if (req->type == CallSlot) {
1416
1417                 call_slot (MISSING_INVALIDATOR, req->the_slot);
1418
1419         } else if (req->type == Quit) {
1420
1421                 stop ();
1422         }
1423 }
1424
1425 int
1426 MackieControlProtocol::stop ()
1427 {
1428         BaseUI::quit ();
1429
1430         return 0;
1431 }
1432
1433 void
1434 MackieControlProtocol::update_led (Surface& surface, Button& button, Mackie::LedState ls)
1435 {
1436         if (ls != none) {
1437                 surface.port().write (button.set_state (ls));
1438         }
1439 }
1440
1441 void
1442 MackieControlProtocol::build_button_map ()
1443 {
1444         /* this maps our device-independent button codes to the methods that handle them.
1445          */
1446
1447 #define DEFINE_BUTTON_HANDLER(b,p,r) button_map.insert (pair<Button::ID,ButtonHandlers> ((b), ButtonHandlers ((p),(r))));
1448
1449         DEFINE_BUTTON_HANDLER (Button::Track, &MackieControlProtocol::track_press, &MackieControlProtocol::track_release);
1450         DEFINE_BUTTON_HANDLER (Button::Send, &MackieControlProtocol::send_press, &MackieControlProtocol::send_release);
1451         DEFINE_BUTTON_HANDLER (Button::Pan, &MackieControlProtocol::pan_press, &MackieControlProtocol::pan_release);
1452         DEFINE_BUTTON_HANDLER (Button::Plugin, &MackieControlProtocol::plugin_press, &MackieControlProtocol::plugin_release);
1453         DEFINE_BUTTON_HANDLER (Button::Eq, &MackieControlProtocol::eq_press, &MackieControlProtocol::eq_release);
1454         DEFINE_BUTTON_HANDLER (Button::Dyn, &MackieControlProtocol::dyn_press, &MackieControlProtocol::dyn_release);
1455         DEFINE_BUTTON_HANDLER (Button::Left, &MackieControlProtocol::left_press, &MackieControlProtocol::left_release);
1456         DEFINE_BUTTON_HANDLER (Button::Right, &MackieControlProtocol::right_press, &MackieControlProtocol::right_release);
1457         DEFINE_BUTTON_HANDLER (Button::ChannelLeft, &MackieControlProtocol::channel_left_press, &MackieControlProtocol::channel_left_release);
1458         DEFINE_BUTTON_HANDLER (Button::ChannelRight, &MackieControlProtocol::channel_right_press, &MackieControlProtocol::channel_right_release);
1459         DEFINE_BUTTON_HANDLER (Button::Flip, &MackieControlProtocol::flip_press, &MackieControlProtocol::flip_release);
1460         DEFINE_BUTTON_HANDLER (Button::View, &MackieControlProtocol::view_press, &MackieControlProtocol::view_release);
1461         DEFINE_BUTTON_HANDLER (Button::NameValue, &MackieControlProtocol::name_value_press, &MackieControlProtocol::name_value_release);
1462         DEFINE_BUTTON_HANDLER (Button::TimecodeBeats, &MackieControlProtocol::timecode_beats_press, &MackieControlProtocol::timecode_beats_release);
1463         DEFINE_BUTTON_HANDLER (Button::F1, &MackieControlProtocol::F1_press, &MackieControlProtocol::F1_release);
1464         DEFINE_BUTTON_HANDLER (Button::F2, &MackieControlProtocol::F2_press, &MackieControlProtocol::F2_release);
1465         DEFINE_BUTTON_HANDLER (Button::F3, &MackieControlProtocol::F3_press, &MackieControlProtocol::F3_release);
1466         DEFINE_BUTTON_HANDLER (Button::F4, &MackieControlProtocol::F4_press, &MackieControlProtocol::F4_release);
1467         DEFINE_BUTTON_HANDLER (Button::F5, &MackieControlProtocol::F5_press, &MackieControlProtocol::F5_release);
1468         DEFINE_BUTTON_HANDLER (Button::F6, &MackieControlProtocol::F6_press, &MackieControlProtocol::F6_release);
1469         DEFINE_BUTTON_HANDLER (Button::F7, &MackieControlProtocol::F7_press, &MackieControlProtocol::F7_release);
1470         DEFINE_BUTTON_HANDLER (Button::F8, &MackieControlProtocol::F8_press, &MackieControlProtocol::F8_release);
1471         DEFINE_BUTTON_HANDLER (Button::MidiTracks, &MackieControlProtocol::miditracks_press, &MackieControlProtocol::miditracks_release);
1472         DEFINE_BUTTON_HANDLER (Button::Inputs, &MackieControlProtocol::inputs_press, &MackieControlProtocol::inputs_release);
1473         DEFINE_BUTTON_HANDLER (Button::AudioTracks, &MackieControlProtocol::audiotracks_press, &MackieControlProtocol::audiotracks_release);
1474         DEFINE_BUTTON_HANDLER (Button::AudioInstruments, &MackieControlProtocol::audioinstruments_press, &MackieControlProtocol::audioinstruments_release);
1475         DEFINE_BUTTON_HANDLER (Button::Aux, &MackieControlProtocol::aux_press, &MackieControlProtocol::aux_release);
1476         DEFINE_BUTTON_HANDLER (Button::Busses, &MackieControlProtocol::busses_press, &MackieControlProtocol::busses_release);
1477         DEFINE_BUTTON_HANDLER (Button::Outputs, &MackieControlProtocol::outputs_press, &MackieControlProtocol::outputs_release);
1478         DEFINE_BUTTON_HANDLER (Button::User, &MackieControlProtocol::user_press, &MackieControlProtocol::user_release);
1479         DEFINE_BUTTON_HANDLER (Button::Shift, &MackieControlProtocol::shift_press, &MackieControlProtocol::shift_release);
1480         DEFINE_BUTTON_HANDLER (Button::Option, &MackieControlProtocol::option_press, &MackieControlProtocol::option_release);
1481         DEFINE_BUTTON_HANDLER (Button::Ctrl, &MackieControlProtocol::control_press, &MackieControlProtocol::control_release);
1482         DEFINE_BUTTON_HANDLER (Button::CmdAlt, &MackieControlProtocol::cmd_alt_press, &MackieControlProtocol::cmd_alt_release);
1483         DEFINE_BUTTON_HANDLER (Button::Read, &MackieControlProtocol::read_press, &MackieControlProtocol::read_release);
1484         DEFINE_BUTTON_HANDLER (Button::Write, &MackieControlProtocol::write_press, &MackieControlProtocol::write_release);
1485         DEFINE_BUTTON_HANDLER (Button::Trim, &MackieControlProtocol::trim_press, &MackieControlProtocol::trim_release);
1486         DEFINE_BUTTON_HANDLER (Button::Touch, &MackieControlProtocol::touch_press, &MackieControlProtocol::touch_release);
1487         DEFINE_BUTTON_HANDLER (Button::Latch, &MackieControlProtocol::latch_press, &MackieControlProtocol::latch_release);
1488         DEFINE_BUTTON_HANDLER (Button::Grp, &MackieControlProtocol::grp_press, &MackieControlProtocol::grp_release);
1489         DEFINE_BUTTON_HANDLER (Button::Save, &MackieControlProtocol::save_press, &MackieControlProtocol::save_release);
1490         DEFINE_BUTTON_HANDLER (Button::Undo, &MackieControlProtocol::undo_press, &MackieControlProtocol::undo_release);
1491         DEFINE_BUTTON_HANDLER (Button::Cancel, &MackieControlProtocol::cancel_press, &MackieControlProtocol::cancel_release);
1492         DEFINE_BUTTON_HANDLER (Button::Enter, &MackieControlProtocol::enter_press, &MackieControlProtocol::enter_release);
1493         DEFINE_BUTTON_HANDLER (Button::Marker, &MackieControlProtocol::marker_press, &MackieControlProtocol::marker_release);
1494         DEFINE_BUTTON_HANDLER (Button::Nudge, &MackieControlProtocol::nudge_press, &MackieControlProtocol::nudge_release);
1495         DEFINE_BUTTON_HANDLER (Button::Loop, &MackieControlProtocol::loop_press, &MackieControlProtocol::loop_release);
1496         DEFINE_BUTTON_HANDLER (Button::Drop, &MackieControlProtocol::drop_press, &MackieControlProtocol::drop_release);
1497         DEFINE_BUTTON_HANDLER (Button::Replace, &MackieControlProtocol::replace_press, &MackieControlProtocol::replace_release);
1498         DEFINE_BUTTON_HANDLER (Button::Click, &MackieControlProtocol::click_press, &MackieControlProtocol::click_release);
1499         DEFINE_BUTTON_HANDLER (Button::ClearSolo, &MackieControlProtocol::clearsolo_press, &MackieControlProtocol::clearsolo_release);
1500         DEFINE_BUTTON_HANDLER (Button::Rewind, &MackieControlProtocol::rewind_press, &MackieControlProtocol::rewind_release);
1501         DEFINE_BUTTON_HANDLER (Button::Ffwd, &MackieControlProtocol::ffwd_press, &MackieControlProtocol::ffwd_release);
1502         DEFINE_BUTTON_HANDLER (Button::Stop, &MackieControlProtocol::stop_press, &MackieControlProtocol::stop_release);
1503         DEFINE_BUTTON_HANDLER (Button::Play, &MackieControlProtocol::play_press, &MackieControlProtocol::play_release);
1504         DEFINE_BUTTON_HANDLER (Button::Record, &MackieControlProtocol::record_press, &MackieControlProtocol::record_release);
1505         DEFINE_BUTTON_HANDLER (Button::CursorUp, &MackieControlProtocol::cursor_up_press, &MackieControlProtocol::cursor_up_release);
1506         DEFINE_BUTTON_HANDLER (Button::CursorDown, &MackieControlProtocol::cursor_down_press, &MackieControlProtocol::cursor_down_release);
1507         DEFINE_BUTTON_HANDLER (Button::CursorLeft, &MackieControlProtocol::cursor_left_press, &MackieControlProtocol::cursor_left_release);
1508         DEFINE_BUTTON_HANDLER (Button::CursorRight, &MackieControlProtocol::cursor_right_press, &MackieControlProtocol::cursor_right_release);
1509         DEFINE_BUTTON_HANDLER (Button::Zoom, &MackieControlProtocol::zoom_press, &MackieControlProtocol::zoom_release);
1510         DEFINE_BUTTON_HANDLER (Button::Scrub, &MackieControlProtocol::scrub_press, &MackieControlProtocol::scrub_release);
1511         DEFINE_BUTTON_HANDLER (Button::UserA, &MackieControlProtocol::user_a_press, &MackieControlProtocol::user_a_release);
1512         DEFINE_BUTTON_HANDLER (Button::UserB, &MackieControlProtocol::user_b_press, &MackieControlProtocol::user_b_release);
1513         DEFINE_BUTTON_HANDLER (Button::MasterFaderTouch, &MackieControlProtocol::master_fader_touch_press, &MackieControlProtocol::master_fader_touch_release);
1514 }
1515
1516 void
1517 MackieControlProtocol::handle_button_event (Surface& surface, Button& button, ButtonState bs)
1518 {
1519         Button::ID button_id = button.bid();
1520
1521         if  (bs != press && bs != release) {
1522                 update_led (surface, button, none);
1523                 return;
1524         }
1525
1526         if ((button_id != Button::Marker) && (modifier_state() & MODIFIER_MARKER)) {
1527                 marker_modifier_consumed_by_button = true;
1528         }
1529
1530         if ((button_id != Button::Nudge) && (modifier_state() & MODIFIER_NUDGE)) {
1531                 nudge_modifier_consumed_by_button = true;
1532         }
1533
1534         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("Handling %1 for button %2 (%3)\n", (bs == press ? "press" : "release"), button.id(),
1535                                                            Button::id_to_name (button.bid())));
1536
1537         /* check profile first */
1538
1539         string action = _device_profile.get_button_action (button.bid(), _modifier_state);
1540
1541         if (!action.empty()) {
1542
1543                 if (action.find ('/') != string::npos) { /* good chance that this is really an action */
1544
1545                         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("Looked up action for button %1 with modifier %2, got [%3]\n",
1546                                                                            button.bid(), _modifier_state, action));
1547
1548                         /* if there is a bound action for this button, and this is a press event,
1549                            carry out the action. If its a release event, do nothing since we
1550                            don't bind to them at all but don't want any other handling to
1551                            occur either.
1552                         */
1553                         if (bs == press) {
1554                                 DEBUG_TRACE (DEBUG::MackieControl, string_compose ("executing action %1\n", action));
1555                                 access_action (action);
1556                         }
1557
1558                         return;
1559
1560                 } else {
1561
1562                         /* "action" is more likely to be a button name. We use this to
1563                          * allow remapping buttons to different (builtin) functionality
1564                          * associated with an existing button. This is similar to the
1565                          * way that (for example) Nuendo moves the "Shift" function to
1566                          * the "Enter" key of the MCU Pro.
1567                          */
1568
1569                         int bid = Button::name_to_id (action);
1570
1571                         if (bid < 0) {
1572                                 DEBUG_TRACE (DEBUG::MackieControl, string_compose ("apparent button name %1 not found\n", action));
1573                                 return;
1574                         }
1575
1576                         button_id = (Button::ID) bid;
1577                         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("handling button %1 as if it was %2 (%3)\n", Button::id_to_name (button.bid()), button_id, Button::id_to_name (button_id)));
1578                 }
1579         }
1580
1581         /* lookup using the device-INDEPENDENT button ID */
1582
1583         ButtonMap::iterator b = button_map.find (button_id);
1584
1585         if (b != button_map.end()) {
1586
1587                 ButtonHandlers& bh (b->second);
1588
1589                 switch  (bs) {
1590                 case press:
1591                         surface.write (button.set_state ((this->*(bh.press)) (button)));
1592                         break;
1593                 case release:
1594                         surface.write (button.set_state ((this->*(bh.release)) (button)));
1595                         break;
1596                 default:
1597                         break;
1598                 }
1599         } else {
1600                 DEBUG_TRACE (DEBUG::MackieControl, string_compose ("no button handlers for button ID %1 (device ID %2)\n",
1601                                                                    button.bid(), button.id()));
1602                 error << string_compose ("no button handlers for button ID %1 (device ID %2)\n",
1603                                          button.bid(), button.id()) << endmsg;
1604         }
1605 }
1606
1607 bool
1608 MackieControlProtocol::midi_input_handler (IOCondition ioc, MIDI::Port* port)
1609 {
1610         if (ioc & ~IO_IN) {
1611                 DEBUG_TRACE (DEBUG::MackieControl, "MIDI port closed\n");
1612                 return false;
1613         }
1614
1615         if (ioc & IO_IN) {
1616
1617                 DEBUG_TRACE (DEBUG::MackieControl, string_compose ("something happend on  %1\n", port->name()));
1618
1619                 /* Devices using regular JACK MIDI ports will need to have
1620                    the x-thread FIFO drained to avoid burning endless CPU.
1621
1622                    Devices using ipMIDI have port->selectable() as the same
1623                    file descriptor that data arrives on, so doing this
1624                    for them will simply throw all incoming data away.
1625                 */
1626
1627                 if (!_device_info.uses_ipmidi()) {
1628                         AsyncMIDIPort* asp = dynamic_cast<AsyncMIDIPort*>(port);
1629                         if (asp) {
1630                                 asp->clear ();
1631                         }
1632                 }
1633
1634                 DEBUG_TRACE (DEBUG::MackieControl, string_compose ("data available on %1\n", port->name()));
1635                 framepos_t now = session->engine().sample_time();
1636                 port->parse (now);
1637         }
1638
1639         return true;
1640 }
1641
1642 void
1643 MackieControlProtocol::clear_ports ()
1644 {
1645         if (_input_bundle) {
1646                 _input_bundle->remove_channels ();
1647                 _output_bundle->remove_channels ();
1648         }
1649 }
1650
1651 void
1652 MackieControlProtocol::notify_subview_route_deleted ()
1653 {
1654         /* return to global/mixer view */
1655         _subview_route.reset ();
1656         set_view_mode (Mixer);
1657 }
1658
1659 bool
1660 MackieControlProtocol::subview_mode_would_be_ok (SubViewMode mode, boost::shared_ptr<Route> r)
1661 {
1662         switch (mode) {
1663         case None:
1664                 return true;
1665                 break;
1666
1667         case Sends:
1668                 if (r && r->send_level_controllable (0)) {
1669                         return true;
1670                 }
1671                 break;
1672
1673         case EQ:
1674                 if (r && r->eq_band_cnt() > 0) {
1675                         return true;
1676                 }
1677                 break;
1678
1679         case Dynamics:
1680                 if (r && r->comp_enable_controllable()) {
1681                         return true;
1682                 }
1683                 break;
1684
1685         case TrackView:
1686                 if (r) {
1687                         return true;
1688                 }
1689         }
1690
1691         return false;
1692 }
1693
1694 bool
1695 MackieControlProtocol::redisplay_subview_mode ()
1696 {
1697         Surfaces copy; /* can't hold surfaces lock while calling Strip::subview_mode_changed */
1698
1699         {
1700                 Glib::Threads::Mutex::Lock lm (surfaces_lock);
1701                 copy = surfaces;
1702         }
1703
1704         for (Surfaces::iterator s = copy.begin(); s != copy.end(); ++s) {
1705                 (*s)->subview_mode_changed ();
1706         }
1707
1708         /* don't call this again from a timeout */
1709         return false;
1710 }
1711
1712 int
1713 MackieControlProtocol::set_subview_mode (SubViewMode sm, boost::shared_ptr<Route> r)
1714 {
1715         SubViewMode old_mode = _subview_mode;
1716         boost::shared_ptr<Route> old_route = _subview_route;
1717
1718         if (!subview_mode_would_be_ok (sm, r)) {
1719
1720                 if (r) {
1721
1722                         Glib::Threads::Mutex::Lock lm (surfaces_lock);
1723
1724                         if (!surfaces.empty()) {
1725
1726                                 string msg;
1727
1728                                 switch (sm) {
1729                                 case Sends:
1730                                         msg = _("no sends for selected track/bus");
1731                                         break;
1732                                 case EQ:
1733                                         msg = _("no EQ in the track/bus");
1734                                         break;
1735                                 case Dynamics:
1736                                         msg = _("no dynamics in selected track/bus");
1737                                         break;
1738                                 case TrackView:
1739                                         msg = _("no track view possible");
1740                                 default:
1741                                         break;
1742                                 }
1743                                 if (!msg.empty()) {
1744                                         surfaces.front()->display_message_for (msg, 1000);
1745                                         if (_subview_mode != None) {
1746                                                 /* redisplay current subview mode after
1747                                                    that message goes away.
1748                                                 */
1749                                                 Glib::RefPtr<Glib::TimeoutSource> redisplay_timeout = Glib::TimeoutSource::create (1000); // milliseconds
1750                                                 redisplay_timeout->connect (sigc::mem_fun (*this, &MackieControlProtocol::redisplay_subview_mode));
1751                                                 redisplay_timeout->attach (main_loop()->get_context());
1752                                         }
1753                                 }
1754                         }
1755                 }
1756
1757                 return -1;
1758         }
1759
1760         _subview_mode = sm;
1761
1762         if (r) {
1763                 /* retain _subview_route even if it is reset to null implicitly */
1764                 _subview_route = r;
1765         }
1766
1767         if ((_subview_mode != old_mode) || (_subview_route != old_route)) {
1768
1769                 if (r != old_route) {
1770                         subview_route_connections.drop_connections ();
1771                         if (_subview_route) {
1772                                 _subview_route->DropReferences.connect (subview_route_connections, MISSING_INVALIDATOR, boost::bind (&MackieControlProtocol::notify_subview_route_deleted, this), this);
1773                         }
1774                 }
1775
1776                 /* subview mode did actually change */
1777
1778                 redisplay_subview_mode ();
1779
1780                 if (_subview_mode != old_mode) {
1781
1782                         /* turn buttons related to vpot mode on or off as required */
1783
1784                         switch (_subview_mode) {
1785                         case MackieControlProtocol::None:
1786                                 pot_mode_globals ();
1787                                 break;
1788                         case MackieControlProtocol::EQ:
1789                                 update_global_button (Button::Send, off);
1790                                 update_global_button (Button::Plugin, off);
1791                                 update_global_button (Button::Eq, on);
1792                                 update_global_button (Button::Dyn, off);
1793                                 update_global_button (Button::Track, off);
1794                                 update_global_button (Button::Pan, off);
1795                                 break;
1796                         case MackieControlProtocol::Dynamics:
1797                                 update_global_button (Button::Send, off);
1798                                 update_global_button (Button::Plugin, off);
1799                                 update_global_button (Button::Eq, off);
1800                                 update_global_button (Button::Dyn, on);
1801                                 update_global_button (Button::Track, off);
1802                                 update_global_button (Button::Pan, off);
1803                                 break;
1804                         case MackieControlProtocol::Sends:
1805                                 update_global_button (Button::Send, on);
1806                                 update_global_button (Button::Plugin, off);
1807                                 update_global_button (Button::Eq, off);
1808                                 update_global_button (Button::Dyn, off);
1809                                 update_global_button (Button::Track, off);
1810                                 update_global_button (Button::Pan, off);
1811                                 break;
1812                         case MackieControlProtocol::TrackView:
1813                                 update_global_button (Button::Send, on);
1814                                 update_global_button (Button::Plugin, off);
1815                                 update_global_button (Button::Eq, off);
1816                                 update_global_button (Button::Dyn, off);
1817                                 update_global_button (Button::Track, on);
1818                                 update_global_button (Button::Pan, off);
1819                                 break;
1820                         }
1821                 }
1822         }
1823
1824         return 0;
1825 }
1826
1827 void
1828 MackieControlProtocol::set_view_mode (ViewMode m)
1829 {
1830         ViewMode old_view_mode = _view_mode;
1831
1832         _view_mode = m;
1833
1834         if (switch_banks(_last_bank[m], true)) {
1835                 _view_mode = old_view_mode;
1836                 return;
1837         }
1838
1839         _last_bank[old_view_mode] = _current_initial_bank;
1840         /* leave subview mode, whatever it was */
1841         set_subview_mode (None, boost::shared_ptr<Route>());
1842         display_view_mode ();
1843 }
1844
1845 void
1846 MackieControlProtocol::display_view_mode ()
1847 {
1848         Glib::Threads::Mutex::Lock lm (surfaces_lock);
1849
1850         for (Surfaces::iterator s = surfaces.begin(); s != surfaces.end(); ++s) {
1851                 (*s)->update_view_mode_display (true);
1852         }
1853 }
1854
1855 void
1856 MackieControlProtocol::set_flip_mode (FlipMode fm)
1857 {
1858         if (_flip_mode != fm) {
1859                 if (fm == Normal) {
1860                         update_global_button (Button::Flip, off);
1861                 } else {
1862                         update_global_button (Button::Flip, on);
1863                 }
1864
1865                 Glib::Threads::Mutex::Lock lm (surfaces_lock);
1866
1867                 _flip_mode = fm;
1868
1869                 for (Surfaces::iterator s = surfaces.begin(); s != surfaces.end(); ++s) {
1870                         (*s)->update_flip_mode_display ();
1871                 }
1872         }
1873 }
1874
1875 void
1876 MackieControlProtocol::set_pot_mode (PotMode m)
1877 {
1878         // maybe not in flip mode.
1879         if (flip_mode()) {
1880                 return;
1881         }
1882
1883         /* switch to a pot mode cancels any subview mode */
1884
1885         set_subview_mode (None, boost::shared_ptr<Route>());
1886
1887         _pot_mode = m;
1888
1889         {
1890                 Glib::Threads::Mutex::Lock lm (surfaces_lock);
1891
1892                 for (Surfaces::iterator s = surfaces.begin(); s != surfaces.end(); ++s) {
1893                         (*s)->update_potmode ();
1894
1895                 }
1896         }
1897
1898         pot_mode_globals ();
1899 }
1900
1901 void
1902 MackieControlProtocol::pot_mode_globals ()
1903 {
1904         switch (_pot_mode) {
1905         case Pan:
1906                 update_global_button (Button::Eq, off);
1907                 update_global_button (Button::Dyn, off);
1908                 update_global_button (Button::Track, off);
1909                 update_global_button (Button::Send, off);
1910                 update_global_button (Button::Plugin, off);
1911                 update_global_button (Button::Pan, on);
1912         };
1913 }
1914
1915 void
1916 MackieControlProtocol::set_master_on_surface_strip (uint32_t surface, uint32_t strip_number)
1917 {
1918         force_special_route_to_strip (session->master_out(), surface, strip_number);
1919 }
1920
1921 void
1922 MackieControlProtocol::set_monitor_on_surface_strip (uint32_t surface, uint32_t strip_number)
1923 {
1924         force_special_route_to_strip (session->monitor_out(), surface, strip_number);
1925 }
1926
1927 void
1928 MackieControlProtocol::force_special_route_to_strip (boost::shared_ptr<Route> r, uint32_t surface, uint32_t strip_number)
1929 {
1930         if (!r) {
1931                 return;
1932         }
1933
1934         Glib::Threads::Mutex::Lock lm (surfaces_lock);
1935
1936         for (Surfaces::iterator s = surfaces.begin(); s != surfaces.end(); ++s) {
1937                 if ((*s)->number() == surface) {
1938                         Strip* strip = (*s)->nth_strip (strip_number);
1939                         if (strip) {
1940                                 strip->set_route (session->master_out());
1941                                 strip->lock_controls ();
1942                         }
1943                 }
1944         }
1945 }
1946
1947 void
1948 MackieControlProtocol::gui_track_selection_changed (ARDOUR::RouteNotificationListPtr rl, bool save_list)
1949 {
1950         _gui_track_selection_changed (rl.get(), save_list, true);
1951 }
1952
1953 void
1954 MackieControlProtocol::_gui_track_selection_changed (ARDOUR::RouteNotificationList* rl, bool save_list, bool gui_selection_did_change)
1955 {
1956         /* We need to keep a list of the most recently selected routes around,
1957            but we are not allowed to keep shared_ptr<Route> unless we want to
1958            handle the complexities of route deletion. So instead, the GUI sends
1959            us a notification using weak_ptr<Route>, which we keep a copy
1960            of. For efficiency's sake, however, we convert the weak_ptr's into
1961            shared_ptr<Route> before passing them to however many surfaces (and
1962            thus strips) that we have.
1963         */
1964
1965         StrongRouteNotificationList srl;
1966
1967         for (ARDOUR::RouteNotificationList::const_iterator i = rl->begin(); i != rl->end(); ++i) {
1968                 boost::shared_ptr<ARDOUR::Route> r = (*i).lock();
1969                 if (r) {
1970                         srl.push_back (r);
1971                 }
1972         }
1973
1974         {
1975                 Glib::Threads::Mutex::Lock lm (surfaces_lock);
1976
1977                 for (Surfaces::iterator s = surfaces.begin(); s != surfaces.end(); ++s) {
1978                         (*s)->gui_selection_changed (srl);
1979                 }
1980         }
1981
1982         if (save_list) {
1983                 _last_selected_routes = *rl;
1984         }
1985
1986         if (gui_selection_did_change) {
1987
1988                 check_fader_automation_state ();
1989
1990                 /* note: this method is also called when we switch banks.
1991                  * But ... we don't allow bank switching when in subview mode.
1992                  *
1993                  * so .. we only have to care about subview mode if the
1994                  * GUI selection has changed.
1995                  *
1996                  * It is possible that first_selected_route() may return null if we
1997                  * are no longer displaying/mapping that route. In that case,
1998                  * we will exit subview mode. If first_selected_route() is
1999                  * null, and subview mode is not None, then the first call to
2000                  * set_subview_mode() will fail, and we will reset to None.
2001                  */
2002
2003                 if (set_subview_mode (_subview_mode, first_selected_route())) {
2004                         set_subview_mode (None, boost::shared_ptr<Route>());
2005                 }
2006         }
2007 }
2008
2009 void
2010 MackieControlProtocol::check_fader_automation_state ()
2011 {
2012         fader_automation_connections.drop_connections ();
2013
2014         boost::shared_ptr<Route> r = first_selected_route ();
2015
2016         if (!r) {
2017                 update_global_button (Button::Read, off);
2018                 update_global_button (Button::Write, off);
2019                 update_global_button (Button::Touch, off);
2020                 update_global_button (Button::Trim, off);
2021                 update_global_button (Button::Latch, off);
2022                 update_global_button (Button::Grp, on);
2023                 return;
2024         }
2025
2026         r->gain_control()->alist()->automation_state_changed.connect (fader_automation_connections,
2027                                                                       MISSING_INVALIDATOR,
2028                                                                       boost::bind (&MackieControlProtocol::update_fader_automation_state, this),
2029                                                                       this);
2030
2031         update_fader_automation_state ();
2032 }
2033
2034 void
2035 MackieControlProtocol::update_fader_automation_state ()
2036 {
2037         boost::shared_ptr<Route> r = first_selected_route ();
2038
2039         if (!r) {
2040                 update_global_button (Button::Read, off);
2041                 update_global_button (Button::Write, off);
2042                 update_global_button (Button::Touch, off);
2043                 update_global_button (Button::Trim, off);
2044                 update_global_button (Button::Latch, off);
2045                 update_global_button (Button::Grp, on);
2046                 return;
2047         }
2048
2049         switch (r->gain_control()->automation_state()) {
2050         case Off:
2051                 update_global_button (Button::Read, off);
2052                 update_global_button (Button::Write, off);
2053                 update_global_button (Button::Touch, off);
2054                 update_global_button (Button::Trim, off);
2055                 update_global_button (Button::Latch, off);
2056                 update_global_button (Button::Grp, on);
2057                 break;
2058         case Play:
2059                 update_global_button (Button::Read, on);
2060                 update_global_button (Button::Write, off);
2061                 update_global_button (Button::Touch, off);
2062                 update_global_button (Button::Trim, off);
2063                 update_global_button (Button::Latch, off);
2064                 update_global_button (Button::Grp, off);
2065                 break;
2066         case Write:
2067                 update_global_button (Button::Read, off);
2068                 update_global_button (Button::Write, on);
2069                 update_global_button (Button::Touch, off);
2070                 update_global_button (Button::Trim, off);
2071                 update_global_button (Button::Latch, off);
2072                 update_global_button (Button::Grp, off);
2073                 break;
2074         case Touch:
2075                 update_global_button (Button::Read, off);
2076                 update_global_button (Button::Write, off);
2077                 update_global_button (Button::Touch, on);
2078                 update_global_button (Button::Trim, off);
2079                 update_global_button (Button::Latch, off);
2080                 update_global_button (Button::Grp, off);
2081                 break;
2082         }
2083 }
2084
2085 framepos_t
2086 MackieControlProtocol::transport_frame() const
2087 {
2088         return session->transport_frame();
2089 }
2090
2091 void
2092 MackieControlProtocol::add_down_select_button (int surface, int strip)
2093 {
2094         _down_select_buttons.insert ((surface<<8)|(strip&0xf));
2095 }
2096
2097 void
2098 MackieControlProtocol::remove_down_select_button (int surface, int strip)
2099 {
2100         DownButtonList::iterator x = find (_down_select_buttons.begin(), _down_select_buttons.end(), (uint32_t) (surface<<8)|(strip&0xf));
2101         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("removing surface %1 strip %2 from down select buttons\n", surface, strip));
2102         if (x != _down_select_buttons.end()) {
2103                 _down_select_buttons.erase (x);
2104         } else {
2105                 DEBUG_TRACE (DEBUG::MackieControl, string_compose ("surface %1 strip %2 not found in down select buttons\n",
2106                                                                    surface, strip));
2107         }
2108 }
2109
2110 void
2111 MackieControlProtocol::select_range ()
2112 {
2113         RouteList routes;
2114
2115         pull_route_range (_down_select_buttons, routes);
2116
2117         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("select range: found %1 routes\n", routes.size()));
2118
2119         if (!routes.empty()) {
2120                 for (RouteList::iterator r = routes.begin(); r != routes.end(); ++r) {
2121
2122                         if (main_modifier_state() == MODIFIER_CONTROL) {
2123                                 ToggleRouteSelection ((*r)->remote_control_id ());
2124                         } else {
2125                                 if (r == routes.begin()) {
2126                                         SetRouteSelection ((*r)->remote_control_id());
2127                                 } else {
2128                                         AddRouteToSelection ((*r)->remote_control_id());
2129                                 }
2130                         }
2131                 }
2132         }
2133 }
2134
2135 void
2136 MackieControlProtocol::add_down_button (AutomationType a, int surface, int strip)
2137 {
2138         DownButtonMap::iterator m = _down_buttons.find (a);
2139
2140         if (m == _down_buttons.end()) {
2141                 _down_buttons[a] = DownButtonList();
2142         }
2143
2144         _down_buttons[a].insert ((surface<<8)|(strip&0xf));
2145 }
2146
2147 void
2148 MackieControlProtocol::remove_down_button (AutomationType a, int surface, int strip)
2149 {
2150         DownButtonMap::iterator m = _down_buttons.find (a);
2151
2152         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("removing surface %1 strip %2 from down buttons for %3\n", surface, strip, (int) a));
2153
2154         if (m == _down_buttons.end()) {
2155                 return;
2156         }
2157
2158         DownButtonList& l (m->second);
2159         DownButtonList::iterator x = find (l.begin(), l.end(), (surface<<8)|(strip&0xf));
2160
2161         if (x != l.end()) {
2162                 l.erase (x);
2163         } else {
2164                 DEBUG_TRACE (DEBUG::MackieControl, string_compose ("surface %1 strip %2 not found in down buttons for %3\n",
2165                                                                    surface, strip, (int) a));
2166         }
2167 }
2168
2169 MackieControlProtocol::ControlList
2170 MackieControlProtocol::down_controls (AutomationType p)
2171 {
2172         ControlList controls;
2173         RouteList routes;
2174
2175         DownButtonMap::iterator m = _down_buttons.find (p);
2176
2177         if (m == _down_buttons.end()) {
2178                 return controls;
2179         }
2180
2181         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("looking for down buttons for %1, got %2\n",
2182                                                            p, m->second.size()));
2183
2184         pull_route_range (m->second, routes);
2185
2186         switch (p) {
2187         case GainAutomation:
2188                 for (RouteList::iterator r = routes.begin(); r != routes.end(); ++r) {
2189                         controls.push_back ((*r)->gain_control());
2190                 }
2191                 break;
2192         case SoloAutomation:
2193                 for (RouteList::iterator r = routes.begin(); r != routes.end(); ++r) {
2194                         controls.push_back ((*r)->solo_control());
2195                 }
2196                 break;
2197         case MuteAutomation:
2198                 for (RouteList::iterator r = routes.begin(); r != routes.end(); ++r) {
2199                         controls.push_back ((*r)->mute_control());
2200                 }
2201                 break;
2202         case RecEnableAutomation:
2203                 for (RouteList::iterator r = routes.begin(); r != routes.end(); ++r) {
2204                         boost::shared_ptr<Track> trk = boost::dynamic_pointer_cast<Track> (*r);
2205                         if (trk) {
2206                                 controls.push_back (trk->rec_enable_control());
2207                         }
2208                 }
2209                 break;
2210         default:
2211                 break;
2212         }
2213
2214         return controls;
2215
2216 }
2217
2218 struct ButtonRangeSorter {
2219     bool operator() (const uint32_t& a, const uint32_t& b) {
2220             return (a>>8) < (b>>8) // a.surface < b.surface
2221                     ||
2222                     ((a>>8) == (b>>8) && (a&0xf) < (b&0xf)); // a.surface == b.surface && a.strip < b.strip
2223     }
2224 };
2225
2226 void
2227 MackieControlProtocol::pull_route_range (DownButtonList& down, RouteList& selected)
2228 {
2229         ButtonRangeSorter cmp;
2230
2231         if (down.empty()) {
2232                 return;
2233         }
2234
2235         list<uint32_t> ldown;
2236         ldown.insert (ldown.end(), down.begin(), down.end());
2237         ldown.sort (cmp);
2238
2239         uint32_t first = ldown.front();
2240         uint32_t last = ldown.back ();
2241
2242         uint32_t first_surface = first>>8;
2243         uint32_t first_strip = first&0xf;
2244
2245         uint32_t last_surface = last>>8;
2246         uint32_t last_strip = last&0xf;
2247
2248         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("PRR %5 in list %1.%2 - %3.%4\n", first_surface, first_strip, last_surface, last_strip,
2249                                                            down.size()));
2250
2251         Glib::Threads::Mutex::Lock lm (surfaces_lock);
2252
2253         for (Surfaces::const_iterator s = surfaces.begin(); s != surfaces.end(); ++s) {
2254
2255                 if ((*s)->number() >= first_surface && (*s)->number() <= last_surface) {
2256
2257                         uint32_t fs;
2258                         uint32_t ls;
2259
2260                         if ((*s)->number() == first_surface) {
2261                                 fs = first_strip;
2262                         } else {
2263                                 fs = 0;
2264                         }
2265
2266                         if ((*s)->number() == last_surface) {
2267                                 ls = last_strip;
2268                                 ls += 1;
2269                         } else {
2270                                 ls = (*s)->n_strips ();
2271                         }
2272
2273                         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("adding strips for surface %1 (%2 .. %3)\n",
2274                                                                            (*s)->number(), fs, ls));
2275
2276                         for (uint32_t n = fs; n < ls; ++n) {
2277                                 boost::shared_ptr<Route> r = (*s)->nth_strip (n)->route();
2278                                 if (r) {
2279                                         selected.push_back (r);
2280                                 }
2281                         }
2282                 }
2283         }
2284 }
2285
2286 void
2287 MackieControlProtocol::set_ipmidi_base (int16_t portnum)
2288 {
2289         /* this will not be saved without a session save, so .. */
2290
2291         session->set_dirty ();
2292
2293         _ipmidi_base = portnum;
2294
2295         /* if the current device uses ipMIDI we need
2296            to restart.
2297         */
2298
2299         if (active() && _device_info.uses_ipmidi()) {
2300                 needs_ipmidi_restart = true;
2301         }
2302 }
2303
2304 int
2305 MackieControlProtocol::ipmidi_restart ()
2306 {
2307         clear_surfaces ();
2308         if (create_surfaces ()) {
2309                 return -1;
2310         }
2311         (void) switch_banks (_current_initial_bank, true);
2312         needs_ipmidi_restart = false;
2313         return 0;
2314 }
2315
2316 void
2317 MackieControlProtocol::clear_surfaces ()
2318 {
2319         clear_ports ();
2320
2321         {
2322                 Glib::Threads::Mutex::Lock lm (surfaces_lock);
2323                 _master_surface.reset ();
2324                 surfaces.clear ();
2325         }
2326 }
2327
2328 void
2329 MackieControlProtocol::set_touch_sensitivity (int sensitivity)
2330 {
2331         sensitivity = min (9, sensitivity);
2332         sensitivity = max (0, sensitivity);
2333
2334         Glib::Threads::Mutex::Lock lm (surfaces_lock);
2335
2336         for (Surfaces::const_iterator s = surfaces.begin(); s != surfaces.end(); ++s) {
2337                 (*s)->set_touch_sensitivity (sensitivity);
2338         }
2339 }
2340
2341 void
2342 MackieControlProtocol::recalibrate_faders ()
2343 {
2344         Glib::Threads::Mutex::Lock lm (surfaces_lock);
2345
2346         for (Surfaces::const_iterator s = surfaces.begin(); s != surfaces.end(); ++s) {
2347                 (*s)->recalibrate_faders ();
2348         }
2349 }
2350
2351 void
2352 MackieControlProtocol::toggle_backlight ()
2353 {
2354         Glib::Threads::Mutex::Lock lm (surfaces_lock);
2355
2356         for (Surfaces::const_iterator s = surfaces.begin(); s != surfaces.end(); ++s) {
2357                 (*s)->toggle_backlight ();
2358         }
2359 }
2360
2361 boost::shared_ptr<Surface>
2362 MackieControlProtocol::get_surface_by_raw_pointer (void* ptr) const
2363 {
2364         Glib::Threads::Mutex::Lock lm (surfaces_lock);
2365
2366         for (Surfaces::const_iterator s = surfaces.begin(); s != surfaces.end(); ++s) {
2367                 if ((*s).get() == (Surface*) ptr) {
2368                         return *s;
2369                 }
2370         }
2371
2372         return boost::shared_ptr<Surface> ();
2373 }
2374
2375 boost::shared_ptr<Surface>
2376 MackieControlProtocol::nth_surface (uint32_t n) const
2377 {
2378         Glib::Threads::Mutex::Lock lm (surfaces_lock);
2379
2380         for (Surfaces::const_iterator s = surfaces.begin(); s != surfaces.end(); ++s, --n) {
2381                 if (n == 0) {
2382                         return *s;
2383                 }
2384         }
2385
2386         return boost::shared_ptr<Surface> ();
2387 }
2388
2389 void
2390 MackieControlProtocol::connection_handler (boost::weak_ptr<ARDOUR::Port> wp1, std::string name1, boost::weak_ptr<ARDOUR::Port> wp2, std::string name2, bool yn)
2391 {
2392         Surfaces scopy;
2393         {
2394                 Glib::Threads::Mutex::Lock lm (surfaces_lock);
2395                 scopy = surfaces;
2396         }
2397
2398         for (Surfaces::const_iterator s = scopy.begin(); s != scopy.end(); ++s) {
2399                 if ((*s)->connection_handler (wp1, name1, wp2, name2, yn)) {
2400                         ConnectionChange (*s);
2401                         break;
2402                 }
2403         }
2404 }
2405
2406 bool
2407 MackieControlProtocol::is_track (boost::shared_ptr<Route> r) const
2408 {
2409         return boost::dynamic_pointer_cast<Track>(r) != 0;
2410 }
2411
2412 bool
2413 MackieControlProtocol::is_audio_track (boost::shared_ptr<Route> r) const
2414 {
2415         return boost::dynamic_pointer_cast<AudioTrack>(r) != 0;
2416 }
2417
2418 bool
2419 MackieControlProtocol::is_midi_track (boost::shared_ptr<Route> r) const
2420 {
2421         return boost::dynamic_pointer_cast<MidiTrack>(r) != 0;
2422 }
2423
2424 bool
2425 MackieControlProtocol::selected (boost::shared_ptr<Route> r) const
2426 {
2427         const RouteNotificationList* rl = &_last_selected_routes;
2428
2429         for (ARDOUR::RouteNotificationList::const_iterator i = rl->begin(); i != rl->end(); ++i) {
2430                 boost::shared_ptr<ARDOUR::Route> rt = (*i).lock();
2431                 if (rt == r) {
2432                         return true;
2433                 }
2434         }
2435         return false;
2436 }
2437
2438 bool
2439 MackieControlProtocol::is_hidden (boost::shared_ptr<Route> r) const
2440 {
2441         if (!r) {
2442                 return false;
2443         }
2444         return (((r->remote_control_id()) >>31) != 0);
2445 }
2446
2447 bool
2448 MackieControlProtocol::is_mapped (boost::shared_ptr<Route> r) const
2449 {
2450         Glib::Threads::Mutex::Lock lm (surfaces_lock);
2451
2452         for (Surfaces::const_iterator s = surfaces.begin(); s != surfaces.end(); ++s) {
2453                 if ((*s)->route_is_mapped (r)) {
2454                         return true;
2455                 }
2456         }
2457
2458         return false;
2459 }
2460
2461 boost::shared_ptr<Route>
2462 MackieControlProtocol::first_selected_route () const
2463 {
2464         if (_last_selected_routes.empty()) {
2465                 return boost::shared_ptr<Route>();
2466         }
2467
2468         boost::shared_ptr<Route> r = _last_selected_routes.front().lock();
2469
2470         if (r) {
2471                 /* check it is on one of our surfaces */
2472
2473                 if (is_mapped (r)) {
2474                         return r;
2475                 }
2476
2477                 /* route is not mapped. thus, the currently selected route is
2478                  * not on the surfaces, and so from our perspective, there is
2479                  * no currently selected route.
2480                  */
2481
2482                 r.reset ();
2483         }
2484
2485         return r; /* may be null */
2486 }
2487
2488 boost::shared_ptr<Route>
2489 MackieControlProtocol::subview_route () const
2490 {
2491         return _subview_route;
2492 }
2493
2494 uint32_t
2495 MackieControlProtocol::global_index (Strip& strip)
2496 {
2497         Glib::Threads::Mutex::Lock lm (surfaces_lock);
2498         uint32_t global = 0;
2499
2500         for (Surfaces::const_iterator s = surfaces.begin(); s != surfaces.end(); ++s) {
2501                 if ((*s).get() == strip.surface()) {
2502                         return global + strip.index();
2503                 }
2504                 global += (*s)->n_strips ();
2505         }
2506
2507         return global;
2508 }
2509
2510 void*
2511 MackieControlProtocol::request_factory (uint32_t num_requests)
2512 {
2513         /* AbstractUI<T>::request_buffer_factory() is a template method only
2514            instantiated in this source module. To provide something visible for
2515            use in the interface/descriptor, we have this static method that is
2516            template-free.
2517         */
2518         return request_buffer_factory (num_requests);
2519 }
2520
2521 void
2522 MackieControlProtocol::set_automation_state (AutoState as)
2523 {
2524         boost::shared_ptr<Route> r = first_selected_route ();
2525
2526         if (!r) {
2527                 return;
2528         }
2529
2530         boost::shared_ptr<AutomationControl> ac = r->gain_control();
2531
2532         if (!ac) {
2533                 return;
2534         }
2535
2536         ac->set_automation_state (as);
2537 }