X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fsurfaces%2Fmackie%2Fstrip.cc;h=bf3ff0d588fe4dea19269061fe6a8f6e0d6a4416;hb=82c867bf2a6f4de102707b812a87d68e3bd6e170;hp=eaeb94e72c18d8e2a2327fcbc3387c6b5a9096a1;hpb=8f7fa7d93b47665c14e452b06e0fb017d0dd653d;p=ardour.git diff --git a/libs/surfaces/mackie/strip.cc b/libs/surfaces/mackie/strip.cc index eaeb94e72c..bf3ff0d588 100644 --- a/libs/surfaces/mackie/strip.cc +++ b/libs/surfaces/mackie/strip.cc @@ -28,15 +28,20 @@ #include "pbd/compose.h" #include "pbd/convert.h" +#include "ardour/amp.h" +#include "ardour/bundle.h" #include "ardour/debug.h" #include "ardour/midi_ui.h" -#include "ardour/route.h" -#include "ardour/track.h" +#include "ardour/meter.h" #include "ardour/pannable.h" #include "ardour/panner.h" #include "ardour/panner_shell.h" #include "ardour/rc_configuration.h" -#include "ardour/meter.h" +#include "ardour/route.h" +#include "ardour/session.h" +#include "ardour/send.h" +#include "ardour/track.h" +#include "ardour/user_bundle.h" #include "mackie_control_protocol.h" #include "surface_port.h" @@ -59,7 +64,7 @@ using namespace PBD; extern PBD::EventLoop::InvalidationRecord* __invalidator (sigc::trackable& trackable, const char*, int); #define invalidator() __invalidator (*(MackieControlProtocol::instance()), __FILE__, __LINE__) -Strip::Strip (Surface& s, const std::string& name, int index, StripControlDefinition* ctls) +Strip::Strip (Surface& s, const std::string& name, int index, const map& strip_buttons) : Group (name) , _solo (0) , _recenable (0) @@ -68,6 +73,8 @@ Strip::Strip (Surface& s, const std::string& name, int index, StripControlDefini , _vselect (0) , _fader_touch (0) , _vpot (0) + , _vpot_mode (PanAzimuth) + , _preflip_vpot_mode (PanAzimuth) , _fader (0) , _index (index) , _surface (&s) @@ -76,155 +83,155 @@ Strip::Strip (Surface& s, const std::string& name, int index, StripControlDefini , _last_gain_position_written (-1.0) , _last_pan_position_written (-1.0) { - /* build the controls for this track, which will automatically add them - to the Group - */ - - for (uint32_t i = 0; ctls[i].name[0]; ++i) { - ctls[i].factory (*_surface, ctls[i].base_id + index, ctls[i].name, *this); + _fader = dynamic_cast (Fader::factory (*_surface, index, "fader", *this)); + _vpot = dynamic_cast (Pot::factory (*_surface, Pot::ID + index, "vpot", *this)); + _meter = dynamic_cast (Meter::factory (*_surface, index, "meter", *this)); + +#ifndef NDEBUG + for (map::const_iterator b = strip_buttons.begin(); b != strip_buttons.end(); ++b) { + Button* bb = dynamic_cast (Button::factory (*_surface, b->first, b->second.base_id + index, b->second.name, *this)); + DEBUG_TRACE (DEBUG::MackieControl, string_compose ("surface %1 strip %2 new button BID %3 id %4 from base %5\n", + _surface->number(), index, Button::id_to_name (bb->bid()), + bb->id(), b->second.base_id)); } +#endif } Strip::~Strip () { + /* surface is responsible for deleting all controls */ } -/** - TODO could optimise this to use enum, but it's only - called during the protocol class instantiation. -*/ -void Strip::add (Control & control) +void +Strip::add (Control & control) { - Group::add (control); - - Fader* fader; - Pot* pot; Button* button; - Meter* meter; - - if ((fader = dynamic_cast(&control)) != 0) { - - _fader = fader; - } else if ((pot = dynamic_cast(&control)) != 0) { - - _vpot = pot; + Group::add (control); - } else if ((button = dynamic_cast(&control)) != 0) { + /* fader, vpot, meter were all set explicitly */ - if (control.id() >= Button::recenable_base_id && - control.id() < Button::recenable_base_id + 8) { - + if ((button = dynamic_cast(&control)) != 0) { + switch (button->bid()) { + case Button::RecEnable: _recenable = button; - - } else if (control.id() >= Button::mute_base_id && - control.id() < Button::mute_base_id + 8) { - + break; + case Button::Mute: _mute = button; - - } else if (control.id() >= Button::solo_base_id && - control.id() < Button::solo_base_id + 8) { - + break; + case Button::Solo: _solo = button; - - } else if (control.id() >= Button::select_base_id && - control.id() < Button::select_base_id + 8) { - + break; + case Button::Select: _select = button; - - } else if (control.id() >= Button::vselect_base_id && - control.id() < Button::vselect_base_id + 8) { - + break; + case Button::VSelect: _vselect = button; - - } else if (control.id() >= Button::fader_touch_base_id && - control.id() < Button::fader_touch_base_id + 8) { - + break; + case Button::FaderTouch: _fader_touch = button; + default: + break; } - - } else if ((meter = dynamic_cast(&control)) != 0) { - _meter = meter; } } void -Strip::set_route (boost::shared_ptr r) +Strip::set_route (boost::shared_ptr r, bool with_messages) { if (_controls_locked) { return; } route_connections.drop_connections (); + + _solo->set_control (boost::shared_ptr()); + _mute->set_control (boost::shared_ptr()); + _select->set_control (boost::shared_ptr()); + _recenable->set_control (boost::shared_ptr()); + _fader->set_control (boost::shared_ptr()); + _vpot->set_control (boost::shared_ptr()); _route = r; - if (r) { - - DEBUG_TRACE (DEBUG::MackieControl, string_compose ("Surface %1 strip %2 now mapping route %3\n", - _surface->number(), _index, _route->name())); - - - if (_solo) { - _solo->set_normal_control (_route->solo_control()); - _solo->set_modified_control (boost::shared_ptr()); - _route->solo_control()->Changed.connect(route_connections, invalidator(), ui_bind (&Strip::notify_solo_changed, this), ui_context()); - } + if (!r) { + return; + } - if (_mute) { - _mute->set_normal_control (_route->mute_control()); - _mute->set_modified_control (boost::shared_ptr()); - _route->mute_control()->Changed.connect(route_connections, invalidator(), ui_bind (&Strip::notify_mute_changed, this), ui_context()); - } - - _route->gain_control()->Changed.connect(route_connections, invalidator(), ui_bind (&Strip::notify_gain_changed, this, false), ui_context()); - - _route->PropertyChanged.connect (route_connections, invalidator(), ui_bind (&Strip::notify_property_changed, this, _1), ui_context()); - - if (_route->pannable()) { - _route->pannable()->pan_azimuth_control->Changed.connect(route_connections, invalidator(), ui_bind (&Strip::notify_panner_changed, this, false), ui_context()); - _route->pannable()->pan_width_control->Changed.connect(route_connections, invalidator(), ui_bind (&Strip::notify_panner_changed, this, false), ui_context()); - } + DEBUG_TRACE (DEBUG::MackieControl, string_compose ("Surface %1 strip %2 now mapping route %3\n", + _surface->number(), _index, _route->name())); + + _solo->set_control (_route->solo_control()); + _mute->set_control (_route->mute_control()); + set_vpot_mode (PanAzimuth); + + _route->solo_control()->Changed.connect(route_connections, invalidator(), ui_bind (&Strip::notify_solo_changed, this), ui_context()); + _route->mute_control()->Changed.connect(route_connections, invalidator(), ui_bind (&Strip::notify_mute_changed, this), ui_context()); - /* bind fader & pan pot, as appropriate for current flip mode */ + boost::shared_ptr pannable = _route->pannable(); - flip_mode_changed (false); - - boost::shared_ptr trk = boost::dynamic_pointer_cast(_route); + if (pannable) { + pannable->pan_azimuth_control->Changed.connect(route_connections, invalidator(), ui_bind (&Strip::notify_panner_azi_changed, this, false), ui_context()); + pannable->pan_width_control->Changed.connect(route_connections, invalidator(), ui_bind (&Strip::notify_panner_width_changed, this, false), ui_context()); + } + _route->gain_control()->Changed.connect(route_connections, invalidator(), ui_bind (&Strip::notify_gain_changed, this, false), ui_context()); + _route->PropertyChanged.connect (route_connections, invalidator(), ui_bind (&Strip::notify_property_changed, this, _1), ui_context()); - if (trk) { - _recenable->set_normal_control (trk->rec_enable_control()); - _recenable->set_modified_control (boost::shared_ptr()); - trk->rec_enable_control()->Changed .connect(route_connections, invalidator(), ui_bind (&Strip::notify_record_enable_changed, this), ui_context()); - } - - // TODO this works when a currently-banked route is made inactive, but not - // when a route is activated which should be currently banked. - - _route->active_changed.connect (route_connections, invalidator(), ui_bind (&Strip::notify_active_changed, this), ui_context()); - _route->DropReferences.connect (route_connections, invalidator(), ui_bind (&Strip::notify_route_deleted, this), ui_context()); + boost::shared_ptr trk = boost::dynamic_pointer_cast(_route); + + if (trk) { + _recenable->set_control (trk->rec_enable_control()); + trk->rec_enable_control()->Changed .connect(route_connections, invalidator(), ui_bind (&Strip::notify_record_enable_changed, this), ui_context()); + } + + // TODO this works when a currently-banked route is made inactive, but not + // when a route is activated which should be currently banked. + + _route->active_changed.connect (route_connections, invalidator(), ui_bind (&Strip::notify_active_changed, this), ui_context()); + _route->DropReferences.connect (route_connections, invalidator(), ui_bind (&Strip::notify_route_deleted, this), ui_context()); - // TODO - // SelectedChanged - // RemoteControlIDChanged. Better handled at Session level. + /* Update */ + + notify_all (); - /* Update */ + /* setup legal VPot modes for this route */ + + build_input_list (_route->input()->n_ports()); + build_output_list (_route->output()->n_ports()); - notify_all (); - } else { - DEBUG_TRACE (DEBUG::MackieControl, string_compose ("Surface %1 strip %2 now unmapped\n", - _surface->number(), _index)); + current_pot_modes.clear(); + + if (pannable) { + boost::shared_ptr panner = pannable->panner(); + if (panner) { + set automatable = panner->what_can_be_automated (); + set::iterator a; + + if ((a = automatable.find (PanAzimuthAutomation)) != automatable.end()) { + current_pot_modes.push_back (PanAzimuth); + } + + if ((a = automatable.find (PanWidthAutomation)) != automatable.end()) { + current_pot_modes.push_back (PanWidth); + } + } } } void Strip::notify_all() { + if (!_route) { + zero (); + return; + } + notify_solo_changed (); notify_mute_changed (); notify_gain_changed (); notify_property_changed (PBD::PropertyChange (ARDOUR::Properties::name)); - notify_panner_changed (); + notify_panner_azi_changed (); + notify_panner_width_changed (); notify_record_enable_changed (); } @@ -271,8 +278,6 @@ Strip::notify_route_deleted () void Strip::notify_gain_changed (bool force_update) { - DEBUG_TRACE (DEBUG::MackieControl, string_compose ("gain changed for strip %1, flip mode %2\n", _index, _surface->mcp().flip_mode())); - if (_route) { Control* control; @@ -283,39 +288,29 @@ Strip::notify_gain_changed (bool force_update) control = _fader; } - if (!control->in_use()) { - - float pos = _route->gain_control()->internal_to_interface (_route->gain_control()->get_value()); - - if (force_update || pos != _last_gain_position_written) { - - if (_surface->mcp().flip_mode()) { - _surface->write (_vpot->set_all (pos, true, Pot::wrap)); - } else { - _surface->write (_fader->set_position (pos)); - } - float dB = fast_coefficient_to_dB (pos); - if (pos == 0.0) { - _surface->write (display (1, " 0.0")); - } else { - char buf[16]; - - snprintf (buf, sizeof (buf), "%6.1f", dB); - _surface->write (display (1, buf)); + boost::shared_ptr ac = _route->gain_control(); + + float gain_coefficient = ac->get_value(); + float normalized_position = ac->internal_to_interface (gain_coefficient); + + if (force_update || normalized_position != _last_gain_position_written) { + + if (_surface->mcp().flip_mode()) { + if (!control->in_use()) { + _surface->write (_vpot->set (normalized_position, true, Pot::wrap)); } - - queue_display_reset (500); - _last_gain_position_written = pos; - + do_parameter_display (GainAutomation, gain_coefficient); } else { - DEBUG_TRACE (DEBUG::MackieControl, "value is stale, no message sent\n"); + if (!control->in_use()) { + _surface->write (_fader->set_position (normalized_position)); + } + do_parameter_display (GainAutomation, gain_coefficient); } - } else { - DEBUG_TRACE (DEBUG::MackieControl, "fader in use, no message sent\n"); + + queue_display_reset (2000); + _last_gain_position_written = normalized_position; } - } else { - DEBUG_TRACE (DEBUG::MackieControl, "no route or no fader\n"); } } @@ -335,13 +330,13 @@ Strip::notify_property_changed (const PropertyChange& what_changed) } else { line1 = PBD::short_version (fullname, 6); } - + _surface->write (display (0, line1)); } } void -Strip::notify_panner_changed (bool force_update) +Strip::notify_panner_azi_changed (bool force_update) { if (_route) { @@ -359,6 +354,9 @@ Strip::notify_panner_changed (bool force_update) if (_surface->mcp().flip_mode()) { control = _fader; } else { + if (_vpot_mode != PanAzimuth) { + return; + } control = _vpot; } @@ -371,114 +369,255 @@ Strip::notify_panner_changed (bool force_update) if (_surface->mcp().flip_mode()) { _surface->write (_fader->set_position (pos)); - + do_parameter_display (PanAzimuthAutomation, pos); } else { - _surface->write (_vpot->set_all (pos, true, Pot::dot)); - } - - if (pannable->panner()) { - string str = pannable->panner()->value_as_string (pannable->pan_azimuth_control); - _surface->write (display (1, str)); - queue_display_reset (500); + _surface->write (_vpot->set (pos, true, Pot::dot)); + do_parameter_display (PanAzimuthAutomation, pos); } - + + queue_display_reset (2000); _last_pan_position_written = pos; } } } } -void -Strip::handle_button (Button& button, ButtonState bs) +void +Strip::notify_panner_width_changed (bool force_update) { - if (bs == press) { - button.set_in_use (true); - } else { - button.set_in_use (false); - } - - DEBUG_TRACE (DEBUG::MackieControl, string_compose ("strip %1 handling button %2\n", _index, button.id())); + if (_route) { - int lock_mod = (MackieControlProtocol::MODIFIER_CONTROL|MackieControlProtocol::MODIFIER_SHIFT); - int ms = _surface->mcp().modifier_state(); - bool modified = (ms & MackieControlProtocol::MODIFIER_CONTROL); + DEBUG_TRACE (DEBUG::MackieControl, string_compose ("pan width change for strip %1\n", _index)); - if (button.id() >= Button::select_base_id && - button.id() < Button::select_base_id + 8) { + boost::shared_ptr pannable = _route->pannable(); - DEBUG_TRACE (DEBUG::MackieControl, string_compose ("select touch, lock ? %1\n", ((ms & lock_mod) == lock_mod) ? 1 : 0)); + if (!pannable) { + _surface->write (_vpot->zero()); + return; + } - if (bs == press) { + Control* control; - if ((ms & lock_mod) == lock_mod) { - _controls_locked = !_controls_locked; + if (_surface->mcp().flip_mode()) { + control = _fader; + } else { + if (_vpot_mode != PanWidth) { return; } + control = _vpot; + } + + if (!control->in_use()) { - _surface->mcp().add_down_select_button (_surface->number(), _index); - _surface->mcp().select_range (); + double pos = pannable->pan_width_control->internal_to_interface (pannable->pan_width_control->get_value()); + + if (force_update || pos != _last_pan_position_written) { + + if (_surface->mcp().flip_mode()) { + + _surface->write (_fader->set_position (pos)); + do_parameter_display (PanWidthAutomation, pos); + } else { + _surface->write (_vpot->set (pos, true, Pot::spread)); + do_parameter_display (PanWidthAutomation, pos); + } - } else { - _surface->mcp().remove_down_select_button (_surface->number(), _index); + queue_display_reset (2000); + _last_pan_position_written = pos; + } } - - return; } +} - if (button.id() >= Button::fader_touch_base_id && - button.id() < Button::fader_touch_base_id + 8) { - - DEBUG_TRACE (DEBUG::MackieControl, string_compose ("fader touch, press ? %1\n", (bs == press))); - - bool state = (bs == press); +void +Strip::select_event (Button& button, ButtonState bs) +{ + DEBUG_TRACE (DEBUG::MackieControl, "select button\n"); + + if (bs == press) { - _fader->set_in_use (state); - _fader->start_touch (_surface->mcp().transport_frame(), modified); + int ms = _surface->mcp().modifier_state(); - if (bs != press) { - /* fader touch ended, revert back to label display for fader */ - _surface->write (display (1, static_display_string())); + if (ms & MackieControlProtocol::MODIFIER_CMDALT) { + _controls_locked = !_controls_locked; + _surface->write (display (1,_controls_locked ? "Locked" : "Unlock")); + queue_display_reset (1000); + return; } - return; + if (ms & MackieControlProtocol::MODIFIER_SHIFT) { + /* reset to default */ + boost::shared_ptr ac = _vpot->control (); + if (ac) { + ac->set_value (ac->normal()); + } + return; + } + + DEBUG_TRACE (DEBUG::MackieControl, "add select button on press\n"); + _surface->mcp().add_down_select_button (_surface->number(), _index); + _surface->mcp().select_range (); + + } else { + DEBUG_TRACE (DEBUG::MackieControl, "remove select button on release\n"); + _surface->mcp().remove_down_select_button (_surface->number(), _index); } +} - boost::shared_ptr control = button.control (modified); - - if (control) { +void +Strip::vselect_event (Button& button, ButtonState bs) +{ + if (bs == press) { - if (bs == press) { - _surface->mcp().add_down_button ((AutomationType) control->parameter().type(), _surface->number(), _index); - - float new_value; - if (ms & MackieControlProtocol::MODIFIER_OPTION) { + int ms = _surface->mcp().modifier_state(); + + if (ms & MackieControlProtocol::MODIFIER_SHIFT) { + boost::shared_ptr ac = button.control (); + + if (ac) { + /* reset to default/normal value */ - new_value = control->normal(); - } else { - new_value = control->get_value() ? 0.0 : 1.0; + ac->set_value (ac->normal()); } - /* get all controls that either have their - * button down or are within a range of - * several down buttons - */ - - MackieControlProtocol::ControlList controls = _surface->mcp().down_controls ((AutomationType) control->parameter().type()); - + } else { + DEBUG_TRACE (DEBUG::MackieControl, "switching to next pot mode\n"); + next_pot_mode (); + } + + } +} + +void +Strip::fader_touch_event (Button& button, ButtonState bs) +{ + DEBUG_TRACE (DEBUG::MackieControl, string_compose ("fader touch, press ? %1\n", (bs == press))); + + /* never use the modified control for fader stuff */ + + if (bs == press) { + + _fader->set_in_use (true); + _fader->start_touch (_surface->mcp().transport_frame()); + boost::shared_ptr ac = _fader->control (); + if (ac) { + do_parameter_display ((AutomationType) ac->parameter().type(), ac->internal_to_interface (ac->get_value())); + queue_display_reset (2000); + } - /* apply change */ + } else { + + _fader->set_in_use (false); + _fader->stop_touch (_surface->mcp().transport_frame(), true); + + } +} - for (MackieControlProtocol::ControlList::iterator c = controls.begin(); c != controls.end(); ++c) { - (*c)->set_value (new_value); + +void +Strip::handle_button (Button& button, ButtonState bs) +{ + boost::shared_ptr control; + + if (bs == press) { + button.set_in_use (true); + } else { + button.set_in_use (false); + } + + DEBUG_TRACE (DEBUG::MackieControl, string_compose ("strip %1 handling button %2 press ? %3\n", _index, button.bid(), (bs == press))); + + switch (button.bid()) { + case Button::Select: + select_event (button, bs); + break; + + case Button::VSelect: + vselect_event (button, bs); + break; + + case Button::FaderTouch: + fader_touch_event (button, bs); + break; + + default: + if ((control = button.control ())) { + if (bs == press) { + DEBUG_TRACE (DEBUG::MackieControl, "add button on press\n"); + _surface->mcp().add_down_button ((AutomationType) control->parameter().type(), _surface->number(), _index); + + float new_value; + int ms = _surface->mcp().modifier_state(); + + if (ms & MackieControlProtocol::MODIFIER_SHIFT) { + /* reset to default/normal value */ + new_value = control->normal(); + } else { + new_value = control->get_value() ? 0.0 : 1.0; + } + + /* get all controls that either have their + * button down or are within a range of + * several down buttons + */ + + MackieControlProtocol::ControlList controls = _surface->mcp().down_controls ((AutomationType) control->parameter().type()); + + + DEBUG_TRACE (DEBUG::MackieControl, string_compose ("there are %1 buttons down for control type %2, new value = %3\n", + controls.size(), control->parameter().type(), new_value)); + + /* apply change */ + + for (MackieControlProtocol::ControlList::iterator c = controls.begin(); c != controls.end(); ++c) { + (*c)->set_value (new_value); + } + + } else { + DEBUG_TRACE (DEBUG::MackieControl, "remove button on release\n"); + _surface->mcp().remove_down_button ((AutomationType) control->parameter().type(), _surface->number(), _index); } + } + break; + } +} +void +Strip::do_parameter_display (AutomationType type, float val) +{ + switch (type) { + case GainAutomation: + if (val == 0.0) { + _surface->write (display (1, " -inf ")); } else { - _surface->mcp().remove_down_button ((AutomationType) control->parameter().type(), _surface->number(), _index); + char buf[16]; + float dB = accurate_coefficient_to_dB (val); + snprintf (buf, sizeof (buf), "%6.1f", dB); + _surface->write (display (1, buf)); + } + break; + + case PanAzimuthAutomation: + if (_route) { + boost::shared_ptr p = _route->pannable(); + if (p && p->panner()) { + string str = p->panner()->value_as_string (p->pan_azimuth_control); + _surface->write (display (1, str)); + } } - - } else { - DEBUG_TRACE (DEBUG::MackieControl, string_compose ("button has no control at present (modified ? %1)\n", modified)); + break; + + case PanWidthAutomation: + if (_route) { + char buf[16]; + snprintf (buf, sizeof (buf), "%5ld%%", lrintf (val * 100.0)); + _surface->write (display (1, buf)); + } + break; + + default: + break; } } @@ -487,15 +626,10 @@ Strip::handle_fader (Fader& fader, float position) { DEBUG_TRACE (DEBUG::MackieControl, string_compose ("fader to %1\n", position)); - bool modified = (_surface->mcp().modifier_state() & MackieControlProtocol::MODIFIER_CONTROL); - - fader.set_value (position, modified); - fader.start_touch (_surface->mcp().transport_frame(), modified); + fader.set_value (position); + fader.start_touch (_surface->mcp().transport_frame()); + queue_display_reset (2000); - if (!_surface->mcp().device_info().has_touch_sense_faders()) { - _surface->mcp().add_in_use_timeout (*_surface, fader, fader.control (modified)); - } - // must echo bytes back to slider now, because // the notifier only works if the fader is not being // touched. Which it is if we're getting input. @@ -510,15 +644,12 @@ Strip::handle_pot (Pot& pot, float delta) stop moving. So to get a stop event, we need to use a timeout. */ - bool modified = (_surface->mcp().modifier_state() & MackieControlProtocol::MODIFIER_CONTROL); - pot.start_touch (_surface->mcp().transport_frame(), modified); - _surface->mcp().add_in_use_timeout (*_surface, pot, pot.control (modified)); - - double p = pot.get_value (modified); + boost::shared_ptr ac = pot.control(); + double p = pot.get_value (); p += delta; - p = min (1.0, p); - p = max (0.0, p); - pot.set_value (p, modified); + p = max (ac->lower(), p); + p = min (ac->upper(), p); + pot.set_value (p); } void @@ -548,7 +679,8 @@ Strip::update_automation () if (_route->panner()) { ARDOUR::AutoState panner_state = _route->panner()->automation_state(); if (panner_state == Touch || panner_state == Play) { - notify_panner_changed (false); + notify_panner_azi_changed (false); + notify_panner_width_changed (false); } } } @@ -562,19 +694,15 @@ Strip::update_meter () } } -MidiByteArray +void Strip::zero () { - MidiByteArray retval; - for (Group::Controls::const_iterator it = _controls.begin(); it != _controls.end(); ++it) { - retval << (*it)->zero (); + _surface->write ((*it)->zero ()); } - retval << blank_display (0); - retval << blank_display (1); - - return retval; + _surface->write (blank_display (0)); + _surface->write (blank_display (1)); } MidiByteArray @@ -615,8 +743,6 @@ Strip::display (uint32_t line_number, const std::string& line) // sysex trailer retval << MIDI::eox; - DEBUG_TRACE (DEBUG::MackieControl, string_compose ("MackieMidiBuilder::strip_display midi: %1\n", retval)); - return retval; } @@ -645,13 +771,44 @@ Strip::gui_selection_changed (ARDOUR::RouteNotificationListPtr rl) } string -Strip::static_display_string () const +Strip::vpot_mode_string () const { - if (_surface->mcp().flip_mode()) { + switch (_vpot_mode) { + case Gain: return "Fader"; - } else { + case PanAzimuth: return "Pan"; + case PanWidth: + return "Width"; + case PanElevation: + return "Elev"; + case PanFrontBack: + return "F/Rear"; + case PanLFE: + return "LFE"; + case Input: + return "Input"; + case Output: + return "Output"; + case Send1: + return "Send 1"; + case Send2: + return "Send 2"; + case Send3: + return "Send 3"; + case Send4: + return "Send 4"; + case Send5: + return "Send 5"; + case Send6: + return "Send 6"; + case Send7: + return "Send 7"; + case Send8: + return "Send 8"; } + + return "???"; } void @@ -661,30 +818,21 @@ Strip::flip_mode_changed (bool notify) return; } - boost::shared_ptr pannable = _route->pannable(); - if (_surface->mcp().flip_mode()) { - - if (pannable) { - _fader->set_normal_control (pannable->pan_azimuth_control); - _fader->set_modified_control (pannable->pan_width_control); - } - _vpot->set_normal_control (_route->gain_control()); - _vpot->set_modified_control (boost::shared_ptr()); - - _surface->write (display (1, static_display_string ())); - + /* flip mode is on - save what it used to be */ + _preflip_vpot_mode = _vpot_mode; } else { + /* flip mode is off - restore flip mode to what it used to be */ + _vpot_mode = _preflip_vpot_mode; + } - if (pannable) { - _vpot->set_normal_control (pannable->pan_azimuth_control); - _vpot->set_modified_control (pannable->pan_width_control); - } - _fader->set_normal_control (_route->gain_control()); - _fader->set_modified_control (boost::shared_ptr()); + boost::shared_ptr fader_controllable = _fader->control (); + boost::shared_ptr vpot_controllable = _vpot->control (); - _surface->write (display (1, static_display_string())); - } + _fader->set_control (vpot_controllable); + _vpot->set_control (fader_controllable); + + _surface->write (display (1, vpot_mode_string ())); if (notify) { notify_all (); @@ -716,7 +864,229 @@ Strip::clear_display_reset () void Strip::reset_display () { - _surface->write (display (1, static_display_string())); + if (_route) { + _surface->write (display (1, vpot_mode_string())); + } else { + _surface->write (blank_display (1)); + } + clear_display_reset (); } +struct RouteCompareByName { + bool operator() (boost::shared_ptr a, boost::shared_ptr b) { + return a->name().compare (b->name()) < 0; + } +}; + +void +Strip::maybe_add_to_bundle_map (BundleMap& bm, boost::shared_ptr b, bool for_input, const ChanCount& channels) +{ + if (b->ports_are_outputs() == !for_input || b->nchannels() != channels) { + return; + } + + bm[b->name()] = b; +} + +void +Strip::build_input_list (const ChanCount& channels) +{ + boost::shared_ptr b = _surface->mcp().get_session().bundles (); + + input_bundles.clear (); + + /* give user bundles first chance at being in the menu */ + + for (ARDOUR::BundleList::iterator i = b->begin(); i != b->end(); ++i) { + if (boost::dynamic_pointer_cast (*i)) { + maybe_add_to_bundle_map (input_bundles, *i, true, channels); + } + } + + for (ARDOUR::BundleList::iterator i = b->begin(); i != b->end(); ++i) { + if (boost::dynamic_pointer_cast (*i) == 0) { + maybe_add_to_bundle_map (input_bundles, *i, true, channels); + } + } + + boost::shared_ptr routes = _surface->mcp().get_session().get_routes (); + RouteList copy = *routes; + copy.sort (RouteCompareByName ()); + + for (ARDOUR::RouteList::const_iterator i = copy.begin(); i != copy.end(); ++i) { + maybe_add_to_bundle_map (input_bundles, (*i)->output()->bundle(), true, channels); + } + +} + +void +Strip::build_output_list (const ChanCount& channels) +{ + boost::shared_ptr b = _surface->mcp().get_session().bundles (); + + output_bundles.clear (); + + /* give user bundles first chance at being in the menu */ + + for (ARDOUR::BundleList::iterator i = b->begin(); i != b->end(); ++i) { + if (boost::dynamic_pointer_cast (*i)) { + maybe_add_to_bundle_map (output_bundles, *i, false, channels); + } + } + + for (ARDOUR::BundleList::iterator i = b->begin(); i != b->end(); ++i) { + if (boost::dynamic_pointer_cast (*i) == 0) { + maybe_add_to_bundle_map (output_bundles, *i, false, channels); + } + } + + boost::shared_ptr routes = _surface->mcp().get_session().get_routes (); + RouteList copy = *routes; + copy.sort (RouteCompareByName ()); + + for (ARDOUR::RouteList::const_iterator i = copy.begin(); i != copy.end(); ++i) { + maybe_add_to_bundle_map (output_bundles, (*i)->input()->bundle(), false, channels); + } +} + +void +Strip::next_pot_mode () +{ + vector::iterator i; + + if (_surface->mcp().flip_mode()) { + /* do not change vpot mode while in flipped mode */ + DEBUG_TRACE (DEBUG::MackieControl, "not stepping pot mode - in flip mode\n"); + _surface->write (display (1, "Flip")); + queue_display_reset (1000); + return; + } + + for (i = current_pot_modes.begin(); i != current_pot_modes.end(); ++i) { + if ((*i) == _vpot_mode) { + break; + } + } + + /* move to the next mode in the list, or back to the start (which will + also happen if the current mode is not in the current pot mode list) + */ + + if (i != current_pot_modes.end()) { + ++i; + } + + if (i == current_pot_modes.end()) { + i = current_pot_modes.begin(); + } + + set_vpot_mode (*i); +} + +void +Strip::set_vpot_mode (PotMode m) +{ + boost::shared_ptr send; + boost::shared_ptr pannable; + + DEBUG_TRACE (DEBUG::MackieControl, string_compose ("switch to vpot mode %1\n", m)); + + if (!_route) { + return; + } + + _vpot_mode = m; + + /* one of these is unnecessary, but its not worth trying to find + out which - it will just cause one additional message to be + sent to the surface. + */ + + _last_pan_position_written = -1; + _last_gain_position_written = -1; + + switch (_vpot_mode) { + case Gain: + break; + case PanAzimuth: + pannable = _route->pannable (); + if (pannable) { + if (_surface->mcp().flip_mode()) { + /* gain to vpot, pan azi to fader */ + _vpot->set_control (_route->gain_control()); + if (pannable) { + _fader->set_control (pannable->pan_azimuth_control); + } + _vpot_mode = Gain; + } else { + /* gain to fader, pan azi to vpot */ + _fader->set_control (_route->gain_control()); + if (pannable) { + _vpot->set_control (pannable->pan_azimuth_control); + } + } + } + break; + case PanWidth: + pannable = _route->pannable (); + if (pannable) { + if (_surface->mcp().flip_mode()) { + /* gain to vpot, pan width to fader */ + _vpot->set_control (_route->gain_control()); + if (pannable) { + _fader->set_control (pannable->pan_width_control); + } + _vpot_mode = Gain; + } else { + /* gain to fader, pan width to vpot */ + _fader->set_control (_route->gain_control()); + if (pannable) { + _vpot->set_control (pannable->pan_width_control); + } + } + } + break; + case PanElevation: + break; + case PanFrontBack: + break; + case PanLFE: + break; + case Input: + break; + case Output: + break; + case Send1: + send = boost::dynamic_pointer_cast (_route->nth_send (0)); + if (send) { + if (_surface->mcp().flip_mode()) { + /* route gain to vpot, send gain to fader */ + _fader->set_control (send->amp()->gain_control()); + _vpot->set_control (_route->gain_control()); + _vpot_mode = Gain; + } else { + /* route gain to fader, send gain to vpot */ + _vpot->set_control (send->amp()->gain_control()); + _fader->set_control (_route->gain_control()); + } + } + break; + case Send2: + break; + case Send3: + break; + case Send4: + break; + case Send5: + break; + case Send6: + break; + case Send7: + break; + case Send8: + break; + }; + + _surface->write (display (1, vpot_mode_string())); +}