X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fsurfaces%2Fmackie%2Fstrip.cc;h=ef4447d900906d6a92f34957de7e1523a35b2014;hb=2b9421fd391efcddde0be3397cb66e19b744a155;hp=3b17255766b7c2795262871c6e28c8e467cdda15;hpb=7a2c0b9d9a9a38f00018e7832f62975c9a9d516f;p=ardour.git diff --git a/libs/surfaces/mackie/strip.cc b/libs/surfaces/mackie/strip.cc index 3b17255766..ef4447d900 100644 --- a/libs/surfaces/mackie/strip.cc +++ b/libs/surfaces/mackie/strip.cc @@ -59,10 +59,6 @@ using namespace ARDOUR; using namespace PBD; #define ui_context() MackieControlProtocol::instance() /* a UICallback-derived object that specifies the event loop for signal handling */ -#define ui_bind(f, ...) boost::protect (boost::bind (f, __VA_ARGS__)) - -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, const map& strip_buttons) : Group (name) @@ -73,19 +69,24 @@ Strip::Strip (Surface& s, const std::string& name, int index, const map (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)); + + if (s.mcp().device_info().has_meters()) { + _meter = dynamic_cast (Meter::factory (*_surface, index, "meter", *this)); + } 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)); @@ -128,6 +129,7 @@ Strip::add (Control & control) break; case Button::FaderTouch: _fader_touch = button; + break; default: break; } @@ -135,7 +137,7 @@ Strip::add (Control & control) } void -Strip::set_route (boost::shared_ptr r) +Strip::set_route (boost::shared_ptr r, bool /*with_messages*/) { if (_controls_locked) { return; @@ -152,7 +154,11 @@ Strip::set_route (boost::shared_ptr r) _route = r; + control_by_parameter.clear (); + reset_saved_values (); + if (!r) { + zero (); return; } @@ -161,32 +167,37 @@ Strip::set_route (boost::shared_ptr r) _solo->set_control (_route->solo_control()); _mute->set_control (_route->mute_control()); - set_vpot_mode (PanAzimuth); + + set_vpot_parameter (PanAzimuthAutomation); - _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()); + _route->solo_changed.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_solo_changed, this), ui_context()); + _route->listen_changed.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_solo_changed, this), ui_context()); + + _route->mute_control()->Changed.connect(route_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_mute_changed, this), ui_context()); boost::shared_ptr pannable = _route->pannable(); - if (pannable) { - pannable->pan_azimuth_control->Changed.connect(route_connections, invalidator(), ui_bind (&Strip::notify_panner_changed, this, false), ui_context()); - pannable->pan_width_control->Changed.connect(route_connections, invalidator(), ui_bind (&Strip::notify_panner_changed, this, false), ui_context()); + if (pannable && _route->panner()) { + pannable->pan_azimuth_control->Changed.connect(route_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_panner_azi_changed, this, false), ui_context()); + pannable->pan_width_control->Changed.connect(route_connections, MISSING_INVALIDATOR, boost::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()); + _route->gain_control()->Changed.connect(route_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_gain_changed, this, false), ui_context()); + _route->PropertyChanged.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_property_changed, this, _1), 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()); + trk->rec_enable_control()->Changed .connect(route_connections, MISSING_INVALIDATOR, boost::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()); + _route->active_changed.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_active_changed, this), ui_context()); + _route->DropReferences.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_route_deleted, this), ui_context()); /* Update */ @@ -197,61 +208,39 @@ Strip::set_route (boost::shared_ptr r) build_input_list (_route->input()->n_ports()); build_output_list (_route->output()->n_ports()); - current_pot_modes.clear(); + possible_pot_parameters.clear(); if (pannable) { - boost::shared_ptr panner = pannable->panner(); + boost::shared_ptr panner = _route->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); + possible_pot_parameters.push_back (PanAzimuthAutomation); } if ((a = automatable.find (PanWidthAutomation)) != automatable.end()) { - current_pot_modes.push_back (PanWidth); + possible_pot_parameters.push_back (PanWidthAutomation); } } } - - current_pot_modes.push_back (Input); - current_pot_modes.push_back (Output); - - if (_route->nth_send (0) != 0) { - current_pot_modes.push_back (Send1); - } - if (_route->nth_send (1) != 0) { - current_pot_modes.push_back (Send2); - } - if (_route->nth_send (2) != 0) { - current_pot_modes.push_back (Send3); - } - if (_route->nth_send (3) != 0) { - current_pot_modes.push_back (Send4); - } - if (_route->nth_send (4) != 0) { - current_pot_modes.push_back (Send5); - } - if (_route->nth_send (5) != 0) { - current_pot_modes.push_back (Send6); - } - if (_route->nth_send (6) != 0) { - current_pot_modes.push_back (Send7); - } - if (_route->nth_send (7) != 0) { - current_pot_modes.push_back (Send8); - } } 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 (); } @@ -259,7 +248,7 @@ void Strip::notify_solo_changed () { if (_route && _solo) { - _surface->write (_solo->set_state (_route->soloed() ? on : off)); + _surface->write (_solo->set_state ((_route->soloed() || _route->listening_via_monitor()) ? on : off)); } } @@ -298,47 +287,38 @@ 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; - if (_surface->mcp().flip_mode()) { + if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) { control = _vpot; } else { control = _fader; } - if (!control->in_use()) { - - 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) { - + boost::shared_ptr ac = _route->gain_control(); + + float gain_coefficient = ac->get_value(); + float normalized_position = ac->internal_to_interface (gain_coefficient); - if (_surface->mcp().flip_mode()) { - _surface->write (_vpot->set_all (normalized_position, true, Pot::wrap)); - do_parameter_display (GainAutomation, gain_coefficient); - } else { - _surface->write (_fader->set_position (normalized_position)); - do_parameter_display (GainAutomation, gain_coefficient); + if (force_update || normalized_position != _last_gain_position_written) { + + if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) { + if (!control->in_use()) { + _surface->write (_vpot->set (normalized_position, true, Pot::wrap)); } - - queue_display_reset (2000); - _last_gain_position_written = normalized_position; - + 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"); } } @@ -358,13 +338,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) { @@ -372,43 +352,82 @@ Strip::notify_panner_changed (bool force_update) boost::shared_ptr pannable = _route->pannable(); - if (!pannable) { + if (!pannable || !_route->panner()) { _surface->write (_vpot->zero()); return; } - Control* control; + Control* control = control_by_parameter[PanAzimuthAutomation]; - if (_surface->mcp().flip_mode()) { - control = _fader; - } else { - control = _vpot; + if (!control) { + return; } - if (!control->in_use()) { + double pos = pannable->pan_azimuth_control->internal_to_interface (pannable->pan_azimuth_control->get_value()); + + if (force_update || pos != _last_pan_azi_position_written) { + + if (control == _fader) { + if (!_fader->in_use()) { + _surface->write (_fader->set_position (pos)); + } + } else if (control == _vpot) { + _surface->write (_vpot->set (pos, true, Pot::dot)); + } - double pos = pannable->pan_azimuth_control->internal_to_interface (pannable->pan_azimuth_control->get_value()); + do_parameter_display (PanAzimuthAutomation, pos); + queue_display_reset (2000); + _last_pan_azi_position_written = pos; + } + } +} + +void +Strip::notify_panner_width_changed (bool force_update) +{ + if (_route) { + + DEBUG_TRACE (DEBUG::MackieControl, string_compose ("pan width change for strip %1\n", _index)); + + boost::shared_ptr pannable = _route->pannable(); + + if (!pannable || !_route->panner()) { + _surface->write (_vpot->zero()); + return; + } + + + Control* control = control_by_parameter[PanWidthAutomation]; + + if (!control) { + return; + } - if (force_update || pos != _last_pan_position_written) { - - 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)); - do_parameter_display (PanAzimuthAutomation, pos); + double pos = pannable->pan_width_control->internal_to_interface (pannable->pan_width_control->get_value()); + + if (force_update || pos != _last_pan_azi_position_written) { + + if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) { + + if (control == _fader) { + if (!control->in_use()) { + _surface->write (_fader->set_position (pos)); + } } - queue_display_reset (2000); - _last_pan_position_written = pos; + } else if (control == _vpot) { + _surface->write (_vpot->set (pos, true, Pot::spread)); } + + do_parameter_display (PanWidthAutomation, pos); + queue_display_reset (2000); + _last_pan_azi_position_written = pos; } } } void -Strip::select_event (Button& button, ButtonState bs) +Strip::select_event (Button&, ButtonState bs) { DEBUG_TRACE (DEBUG::MackieControl, "select button\n"); @@ -420,12 +439,12 @@ Strip::select_event (Button& button, ButtonState bs) _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 (); + boost::shared_ptr ac = _fader->control (); if (ac) { ac->set_value (ac->normal()); } @@ -443,16 +462,16 @@ Strip::select_event (Button& button, ButtonState bs) } void -Strip::vselect_event (Button& button, ButtonState bs) +Strip::vselect_event (Button&, ButtonState bs) { if (bs == press) { - int ms = _surface->mcp().modifier_state(); if (ms & MackieControlProtocol::MODIFIER_SHIFT) { - boost::shared_ptr ac = button.control (); + boost::shared_ptr ac = _vpot->control (); + if (ac) { /* reset to default/normal value */ @@ -460,6 +479,7 @@ Strip::vselect_event (Button& button, ButtonState bs) } } else { + DEBUG_TRACE (DEBUG::MackieControl, "switching to next pot mode\n"); next_pot_mode (); } @@ -468,21 +488,28 @@ Strip::vselect_event (Button& button, ButtonState bs) } void -Strip::fader_touch_event (Button& button, ButtonState bs) +Strip::fader_touch_event (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 (_surface->mcp().modifier_state() == MackieControlProtocol::MODIFIER_SHIFT) { + if (ac) { + ac->set_value (ac->normal()); + } + } else { + + _fader->set_in_use (true); + _fader->start_touch (_surface->mcp().transport_frame()); + if (ac) { do_parameter_display ((AutomationType) ac->parameter().type(), ac->internal_to_interface (ac->get_value())); queue_display_reset (2000); } + } } else { @@ -579,11 +606,21 @@ Strip::do_parameter_display (AutomationType type, float val) 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); + if (p && _route->panner()) { + string str =_route->panner()->value_as_string (p->pan_azimuth_control); _surface->write (display (1, str)); } } + 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; } @@ -612,12 +649,11 @@ Strip::handle_pot (Pot& pot, float delta) stop moving. So to get a stop event, we need to use a timeout. */ - pot.start_touch (_surface->mcp().transport_frame()); - + boost::shared_ptr ac = pot.control(); double p = pot.get_value (); p += delta; - p = min (1.0, p); - p = max (0.0, p); + p = max (ac->lower(), p); + p = min (ac->upper(), p); pot.set_value (p); } @@ -648,7 +684,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); } } } @@ -656,25 +693,21 @@ Strip::update_automation () void Strip::update_meter () { - if (_meter) { + if (_meter && _transport_is_rolling && _metering_active) { float dB = const_cast (_route->peak_meter()).peak_power (0); - _surface->write (_meter->update_message (dB)); + _meter->send_update (*_surface, dB); } } -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 @@ -715,8 +748,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; } @@ -732,54 +763,41 @@ Strip::unlock_controls () _controls_locked = false; } -MidiByteArray -Strip::gui_selection_changed (ARDOUR::RouteNotificationListPtr rl) +void +Strip::gui_selection_changed (const ARDOUR::StrongRouteNotificationList& rl) { - for (ARDOUR::RouteNotificationList::iterator i = rl->begin(); i != rl->end(); ++i) { + for (ARDOUR::StrongRouteNotificationList::const_iterator i = rl.begin(); i != rl.end(); ++i) { if ((*i) == _route) { - return _select->set_state (on); + _surface->write (_select->set_state (on)); + return; } } - return _select->set_state (off); + _surface->write (_select->set_state (off)); } string Strip::vpot_mode_string () const { - switch (_vpot_mode) { - case Gain: + boost::shared_ptr ac = _vpot->control(); + + if (!ac) { + return string(); + } + + switch (ac->parameter().type()) { + case GainAutomation: return "Fader"; - case PanAzimuth: + case PanAzimuthAutomation: return "Pan"; - case PanWidth: + case PanWidthAutomation: return "Width"; - case PanElevation: + case PanElevationAutomation: return "Elev"; - case PanFrontBack: + case PanFrontBackAutomation: return "F/Rear"; - case PanLFE: + case PanLFEAutomation: 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 "???"; @@ -792,12 +810,17 @@ Strip::flip_mode_changed (bool notify) return; } + reset_saved_values (); + boost::shared_ptr fader_controllable = _fader->control (); boost::shared_ptr vpot_controllable = _vpot->control (); _fader->set_control (vpot_controllable); _vpot->set_control (fader_controllable); + control_by_parameter[fader_controllable->parameter()] = _vpot; + control_by_parameter[vpot_controllable->parameter()] = _fader; + _surface->write (display (1, vpot_mode_string ())); if (notify) { @@ -830,7 +853,12 @@ Strip::clear_display_reset () void Strip::reset_display () { - _surface->write (display (1, vpot_mode_string())); + if (_route) { + _surface->write (display (1, vpot_mode_string())); + } else { + _surface->write (blank_display (1)); + } + clear_display_reset (); } @@ -914,18 +942,29 @@ Strip::build_output_list (const ChanCount& channels) void Strip::next_pot_mode () { - vector::iterator i; + vector::iterator i; - if (_surface->mcp().flip_mode()) { + if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) { /* 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 (2000); + queue_display_reset (1000); + return; + } + + + boost::shared_ptr ac = _vpot->control(); + + if (!ac) { + return; + } + + if (possible_pot_parameters.empty() || (possible_pot_parameters.size() == 1 && possible_pot_parameters.front() == ac->parameter())) { return; } - for (i = current_pot_modes.begin(); i != current_pot_modes.end(); ++i) { - if ((*i) == _vpot_mode) { + for (i = possible_pot_parameters.begin(); i != possible_pot_parameters.end(); ++i) { + if ((*i) == ac->parameter()) { break; } } @@ -934,112 +973,124 @@ Strip::next_pot_mode () also happen if the current mode is not in the current pot mode list) */ - if (i != current_pot_modes.end()) { + if (i != possible_pot_parameters.end()) { ++i; } - if (i == current_pot_modes.end()) { - i = current_pot_modes.begin(); + if (i == possible_pot_parameters.end()) { + i = possible_pot_parameters.begin(); } - set_vpot_mode (*i); + set_vpot_parameter (*i); } void -Strip::set_vpot_mode (PotMode m) +Strip::set_vpot_parameter (Evoral::Parameter p) { - boost::shared_ptr send; boost::shared_ptr pannable; - DEBUG_TRACE (DEBUG::MackieControl, string_compose ("switch to vpot mode %1\n", m)); + DEBUG_TRACE (DEBUG::MackieControl, string_compose ("switch to vpot mode %1\n", p)); - if (!_route) { - return; - } + reset_saved_values (); - _vpot_mode = m; - - switch (_vpot_mode) { - case Gain: - break; - case PanAzimuth: + switch (p.type()) { + case PanAzimuthAutomation: pannable = _route->pannable (); if (pannable) { - if (_surface->mcp().flip_mode()) { + if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) { /* gain to vpot, pan azi to fader */ _vpot->set_control (_route->gain_control()); + control_by_parameter[GainAutomation] = _vpot; if (pannable) { _fader->set_control (pannable->pan_azimuth_control); + control_by_parameter[PanAzimuthAutomation] = _fader; + } else { + _fader->set_control (boost::shared_ptr()); + control_by_parameter[PanAzimuthAutomation] = 0; } - _vpot_mode = Gain; } else { /* gain to fader, pan azi to vpot */ _fader->set_control (_route->gain_control()); + control_by_parameter[GainAutomation] = _fader; if (pannable) { _vpot->set_control (pannable->pan_azimuth_control); + control_by_parameter[PanAzimuthAutomation] = _vpot; + } else { + _vpot->set_control (boost::shared_ptr()); + control_by_parameter[PanAzimuthAutomation] = 0; } } } break; - case PanWidth: + case PanWidthAutomation: pannable = _route->pannable (); if (pannable) { - if (_surface->mcp().flip_mode()) { + if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) { /* gain to vpot, pan width to fader */ _vpot->set_control (_route->gain_control()); + control_by_parameter[GainAutomation] = _vpot; if (pannable) { _fader->set_control (pannable->pan_width_control); + control_by_parameter[PanWidthAutomation] = _fader; + } else { + _fader->set_control (boost::shared_ptr()); + control_by_parameter[PanWidthAutomation] = 0; } - _vpot_mode = Gain; } else { /* gain to fader, pan width to vpot */ _fader->set_control (_route->gain_control()); + control_by_parameter[GainAutomation] = _fader; 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; + control_by_parameter[PanWidthAutomation] = _vpot; } else { - /* route gain to fader, send gain to vpot */ - _vpot->set_control (send->amp()->gain_control()); - _fader->set_control (_route->gain_control()); + _vpot->set_control (boost::shared_ptr()); + control_by_parameter[PanWidthAutomation] = 0; + } } } break; - case Send2: - break; - case Send3: - break; - case Send4: + case PanElevationAutomation: break; - case Send5: + case PanFrontBackAutomation: break; - case Send6: + case PanLFEAutomation: break; - case Send7: - break; - case Send8: - break; - }; + } _surface->write (display (1, vpot_mode_string())); } + +void +Strip::reset_saved_values () +{ + _last_pan_azi_position_written = -1.0; + _last_pan_width_position_written = -1.0; + _last_gain_position_written = -1.0; + +} + +void +Strip::notify_metering_state_changed() +{ + if (!_route || !_meter) { + return; + } + + bool transport_is_rolling = (_surface->mcp().get_transport_speed () != 0.0f); + bool metering_active = _surface->mcp().metering_active (); + + if ((_transport_is_rolling == transport_is_rolling) && (_metering_active == metering_active)) { + return; + } + + _meter->notify_metering_state_changed (*_surface, transport_is_rolling, metering_active); + + if (!transport_is_rolling || !metering_active) { + notify_property_changed (PBD::PropertyChange (ARDOUR::Properties::name)); + notify_panner_azi_changed (true); + } + + _transport_is_rolling = transport_is_rolling; + _metering_active = metering_active; +}