X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=libs%2Fsurfaces%2Fmackie%2Fstrip.cc;h=fcb544a92ebd50a352a1198a28f5b8b868f84362;hb=6b356448e314f7a280f0a04b5bccd221876c62dd;hp=3633430e9843bcdd71dff0a0922fdd4f329c67a8;hpb=6899bd7c158834d3dc795a408ab37b049ada5e72;p=ardour.git

diff --git a/libs/surfaces/mackie/strip.cc b/libs/surfaces/mackie/strip.cc
index 3633430e98..fcb544a92e 100644
--- a/libs/surfaces/mackie/strip.cc
+++ b/libs/surfaces/mackie/strip.cc
@@ -18,8 +18,9 @@
 */
 
 #include <sstream>
+#include <vector>
+
 #include <stdint.h>
-#include "strip.h"
 
 #include <sys/time.h>
 
@@ -35,6 +36,7 @@
 #include "ardour/debug.h"
 #include "ardour/midi_ui.h"
 #include "ardour/meter.h"
+#include "ardour/plugin_insert.h"
 #include "ardour/pannable.h"
 #include "ardour/panner.h"
 #include "ardour/panner_shell.h"
@@ -43,11 +45,14 @@
 #include "ardour/session.h"
 #include "ardour/send.h"
 #include "ardour/track.h"
+#include "ardour/midi_track.h"
 #include "ardour/user_bundle.h"
+#include "ardour/profile.h"
 
 #include "mackie_control_protocol.h"
 #include "surface_port.h"
 #include "surface.h"
+#include "strip.h"
 #include "button.h"
 #include "led.h"
 #include "pot.h"
@@ -92,12 +97,17 @@ Strip::Strip (Surface& s, const std::string& name, int index, const map<Button::
 	, _controls_locked (false)
 	, _transport_is_rolling (false)
 	, _metering_active (true)
-	, _reset_display_at (0)
+	, _block_vpot_mode_redisplay_until (0)
+	, _block_screen_redisplay_until (0)
+	, eq_band (-1)
 	, _pan_mode (PanAzimuthAutomation)
+	, _trim_mode (TrimAutomation)
+	, vpot_parameter (PanAzimuthAutomation)
 	, _last_gain_position_written (-1.0)
 	, _last_pan_azi_position_written (-1.0)
 	, _last_pan_width_position_written (-1.0)
 	, _last_trim_position_written (-1.0)
+	, _current_send (0)
 	, redisplay_requests (256)
 {
 	_fader = dynamic_cast<Fader*> (Fader::factory (*_surface, index, "fader", *this));
@@ -162,6 +172,8 @@ Strip::set_route (boost::shared_ptr<Route> r, bool /*with_messages*/)
 		return;
 	}
 
+	mb_pan_controllable.reset();
+
 	route_connections.drop_connections ();
 
 	_solo->set_control (boost::shared_ptr<AutomationControl>());
@@ -174,6 +186,17 @@ Strip::set_route (boost::shared_ptr<Route> r, bool /*with_messages*/)
 	_route = r;
 
 	control_by_parameter.clear ();
+
+	control_by_parameter[PanAzimuthAutomation] = (Control*) 0;
+	control_by_parameter[PanWidthAutomation] = (Control*) 0;
+	control_by_parameter[PanElevationAutomation] = (Control*) 0;
+	control_by_parameter[PanFrontBackAutomation] = (Control*) 0;
+	control_by_parameter[PanLFEAutomation] = (Control*) 0;
+	control_by_parameter[GainAutomation] = (Control*) 0;
+	control_by_parameter[TrimAutomation] = (Control*) 0;
+	control_by_parameter[PhaseAutomation] = (Control*) 0;
+	control_by_parameter[SendAutomation] = (Control*) 0;
+
 	reset_saved_values ();
 
 	if (!r) {
@@ -187,25 +210,30 @@ Strip::set_route (boost::shared_ptr<Route> r, bool /*with_messages*/)
 	_solo->set_control (_route->solo_control());
 	_mute->set_control (_route->mute_control());
 
-	_pan_mode = PanAzimuthAutomation;
-	potmode_changed (true);
-
-
 	_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());
 
-	if (_route->trim()) {
+	if (_route->trim() && route()->trim()->active()) {
 		_route->trim_control()->Changed.connect(route_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_trim_changed, this, false), ui_context());
 	}
 
-	boost::shared_ptr<Pannable> pannable = _route->pannable();
+	if (_route->phase_invert().size()) {
+		_route->phase_invert_changed.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_phase_changed, this, false), ui_context());
+		_route->phase_control()->set_channel(0);
+	}
+
+	boost::shared_ptr<AutomationControl> pan_control = _route->pan_azimuth_control();
+	if (pan_control) {
+		pan_control->Changed.connect(route_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_panner_azi_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());
+	pan_control = _route->pan_width_control();
+	if (pan_control) {
+		pan_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, 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());
 
@@ -214,8 +242,6 @@ Strip::set_route (boost::shared_ptr<Route> r, bool /*with_messages*/)
 	if (trk) {
 		_recenable->set_control (trk->rec_enable_control());
 		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
@@ -224,32 +250,50 @@ Strip::set_route (boost::shared_ptr<Route> r, bool /*with_messages*/)
 	_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 */
-
-	notify_all ();
-
 	/* setup legal VPot modes for this route */
 
-	build_input_list (_route->input()->n_ports());
-	build_output_list (_route->output()->n_ports());
-
 	possible_pot_parameters.clear();
 
-	if (pannable) {
-		boost::shared_ptr<Panner> panner = _route->panner();
-		if (panner) {
-			set<Evoral::Parameter> automatable = panner->what_can_be_automated ();
-			set<Evoral::Parameter>::iterator a;
+	if (_route->pan_azimuth_control()) {
+		possible_pot_parameters.push_back (PanAzimuthAutomation);
+	}
+	if (_route->pan_width_control()) {
+		possible_pot_parameters.push_back (PanWidthAutomation);
+	}
+	if (_route->pan_elevation_control()) {
+		possible_pot_parameters.push_back (PanElevationAutomation);
+	}
+	if (_route->pan_frontback_control()) {
+		possible_pot_parameters.push_back (PanFrontBackAutomation);
+	}
+	if (_route->pan_lfe_control()) {
+		possible_pot_parameters.push_back (PanLFEAutomation);
+	}
+
+	if (_route->trim() && route()->trim()->active()) {
+		possible_pot_parameters.push_back (TrimAutomation);
+	}
 
-			if ((a = automatable.find (PanAzimuthAutomation)) != automatable.end()) {
-				possible_pot_parameters.push_back (PanAzimuthAutomation);
-			}
+	possible_trim_parameters.clear();
 
-			if ((a = automatable.find (PanWidthAutomation)) != automatable.end()) {
-				possible_pot_parameters.push_back (PanWidthAutomation);
-			}
+	if (_route->trim() && route()->trim()->active()) {
+		possible_trim_parameters.push_back (TrimAutomation);
+		_trim_mode = TrimAutomation;
+	}
+
+	if (_route->phase_invert().size()) {
+		possible_trim_parameters.push_back (PhaseAutomation);
+		_route->phase_control()->set_channel(0);
+		if (_trim_mode != TrimAutomation) {
+			_trim_mode = PhaseAutomation;
 		}
 	}
+	_current_send = 0;
+	/* Update */
+	_pan_mode = PanAzimuthAutomation;
+	potmode_changed (false);
+	notify_all ();
+
 }
 
 void
@@ -259,6 +303,10 @@ Strip::notify_all()
 		zero ();
 		return;
 	}
+	// The active V-pot control may not be active for this strip
+	// But if we zero it in the controls function it may erase
+	// the one we do want
+	_surface->write (_vpot->zero());
 
 	notify_solo_changed ();
 	notify_mute_changed ();
@@ -268,6 +316,8 @@ Strip::notify_all()
 	notify_panner_width_changed ();
 	notify_record_enable_changed ();
 	notify_trim_changed ();
+	notify_phase_changed ();
+	notify_processor_changed ();
 }
 
 void
@@ -343,7 +393,6 @@ Strip::notify_gain_changed (bool force_update)
 				queue_parameter_display (GainAutomation, gain_coefficient);
 			}
 
-			queue_display_reset (2000);
 			_last_gain_position_written = normalized_position;
 		}
 	}
@@ -354,11 +403,17 @@ Strip::notify_trim_changed (bool force_update)
 {
 	if (_route) {
 
-		if (!_route->trim()) {
-			_surface->write (_vpot->zero());
+		if (!_route->trim() || !route()->trim()->active()) {
+			return;
+		}
+		Control* control = 0;
+		ControlParameterMap::iterator i = control_by_parameter.find (TrimAutomation);
+
+		if (i == control_by_parameter.end()) {
 			return;
 		}
-		Control* control = control_by_parameter[TrimAutomation];
+
+		control = i->second;
 
 		boost::shared_ptr<AutomationControl> ac = _route->trim_control();
 
@@ -376,8 +431,74 @@ Strip::notify_trim_changed (bool force_update)
 				queue_parameter_display (TrimAutomation, gain_coefficient);
 			}
 			_last_trim_position_written = normalized_position;
+		}
+	}
+}
+
+void
+Strip::notify_phase_changed (bool force_update)
+{
+	if (_route) {
+		if (!_route->phase_invert().size()) {
+			return;
+		}
+
+		Control* control = 0;
+		ControlParameterMap::iterator i = control_by_parameter.find (PhaseAutomation);
+
+		if (i == control_by_parameter.end()) {
+			return;
+		}
+
+		control = i->second;
+
+		float normalized_position = _route->phase_control()->get_value();
+
+		if (control == _fader) {
+			if (!_fader->in_use()) {
+				_surface->write (_fader->set_position (normalized_position));
+				queue_parameter_display (PhaseAutomation, normalized_position);
+			}
+		} else if (control == _vpot) {
+			_surface->write (_vpot->set (normalized_position, true, Pot::wrap));
+			queue_parameter_display (PhaseAutomation, normalized_position);
+		}
+	}
+}
+
+void
+Strip::notify_processor_changed (bool force_update)
+{
+	if (_route) {
+		boost::shared_ptr<Processor> p = _route->nth_send (_current_send);
+		if (!p) {
+			return;
+		}
+
+		Control* control = 0;
+		ControlParameterMap::iterator i = control_by_parameter.find (SendAutomation);
+
+		if (i == control_by_parameter.end()) {
+			return;
+		}
+
+		control = i->second;
+
+		boost::shared_ptr<Send> s =  boost::dynamic_pointer_cast<Send>(p);
+		boost::shared_ptr<Amp> a = s->amp();
+		boost::shared_ptr<AutomationControl> ac = a->gain_control();
+
+		float gain_coefficient = ac->get_value();
+		float normalized_position = ac->internal_to_interface (gain_coefficient);
 
-			queue_display_reset (2000);
+		if (control == _fader) {
+			if (!_fader->in_use()) {
+				_surface->write (_fader->set_position (normalized_position));
+				queue_parameter_display (SendAutomation, gain_coefficient);
+			}
+		} else if (control == _vpot) {
+			_surface->write (_vpot->set (normalized_position, true, Pot::dot));
+			queue_parameter_display (SendAutomation, gain_coefficient);
 		}
 	}
 }
@@ -389,102 +510,229 @@ Strip::notify_property_changed (const PropertyChange& what_changed)
 		return;
 	}
 
-	if (_route) {
-		string line1;
-		string fullname = _route->name();
+	show_route_name ();
+}
 
-		if (fullname.length() <= 6) {
-			line1 = fullname;
-		} else {
-			line1 = PBD::short_version (fullname, 6);
+void
+Strip::show_route_name ()
+{
+	MackieControlProtocol::SubViewMode svm = _surface->mcp().subview_mode();
+
+	if (svm != MackieControlProtocol::None) {
+		/* subview mode is responsible for upper line */
+		return;
+	}
+
+	string fullname = string();
+	if (!_route) {
+		// make sure first three strips get cleared of view mode
+		if (_index > 2) {
+			return;
 		}
+	} else {
+		fullname = _route->name();
+	}
+	string line1;
+
+	if (fullname.length() <= 6) {
+		line1 = fullname;
+	} else {
+		line1 = PBD::short_version (fullname, 6);
+	}
+
+	_surface->write (display (0, line1));
+}
+
+void
+Strip::notify_eq_change (AutomationType type, uint32_t band, bool force_update)
+{
+	boost::shared_ptr<Route> r = _surface->mcp().subview_route();
+
+	if (!r) {
+		/* not in subview mode */
+		return;
+	}
+
+	if (_surface->mcp().subview_mode() != MackieControlProtocol::EQ) {
+		/* no longer in EQ subview mode */
+		return;
+	}
+
+	boost::shared_ptr<AutomationControl> control;
+
+	switch (type) {
+	case EQGain:
+		control = r->eq_gain_controllable (band);
+		break;
+	case EQFrequency:
+		control = r->eq_freq_controllable (band);
+		break;
+	case EQQ:
+		control = r->eq_q_controllable (band);
+		break;
+	case EQShape:
+		control = r->eq_shape_controllable (band);
+		break;
+	case EQHPF:
+		control = r->eq_hpf_controllable ();
+		break;
+	case EQEnable:
+		control = r->eq_enable_controllable ();
+		break;
+	default:
+		break;
+	}
+
+	if (control) {
+		float val = control->get_value();
+		queue_parameter_display (type, val);
+		/* update pot/encoder */
+		_surface->write (_vpot->set (control->internal_to_interface (val), true, Pot::wrap));
+	}
+}
+
+void
+Strip::notify_dyn_change (AutomationType type, bool force_update, bool propagate_mode)
+{
+	boost::shared_ptr<Route> r = _surface->mcp().subview_route();
+
+	if (!r) {
+		/* not in subview mode */
+		return;
+	}
+
+	if (_surface->mcp().subview_mode() != MackieControlProtocol::Dynamics) {
+		/* no longer in EQ subview mode */
+		return;
+	}
+
+	boost::shared_ptr<AutomationControl> control;
+	bool reset_all = false;
+
+	switch (type) {
+	case CompThreshold:
+		control = r->comp_threshold_controllable ();
+		break;
+	case CompSpeed:
+		control = r->comp_speed_controllable ();
+		break;
+	case CompMode:
+		control = r->comp_mode_controllable ();
+		reset_all = true;
+		break;
+	case CompMakeup:
+		control = r->comp_makeup_controllable ();
+		break;
+	case CompRedux:
+		control = r->comp_redux_controllable ();
+		break;
+	case CompEnable:
+		control = r->comp_enable_controllable ();
+		break;
+	default:
+		break;
+	}
+
+	if (propagate_mode && reset_all) {
+		_surface->subview_mode_changed ();
+	}
 
-		_surface->write (display (0, line1));
+	if (control) {
+		float val = control->get_value();
+		queue_parameter_display (type, val);
+		/* update pot/encoder */
+		_surface->write (_vpot->set (control->internal_to_interface (val), true, Pot::wrap));
 	}
 }
 
 void
 Strip::notify_panner_azi_changed (bool force_update)
 {
-	if (_route) {
+	if (!_route) {
+		return;
+	}
 
-		DEBUG_TRACE (DEBUG::MackieControl, string_compose ("pan change for strip %1\n", _index));
+	DEBUG_TRACE (DEBUG::MackieControl, string_compose ("pan change for strip %1\n", _index));
 
-		boost::shared_ptr<Pannable> pannable = _route->pannable();
+	boost::shared_ptr<AutomationControl> pan_control = _route->pan_azimuth_control ();
 
-		if (!pannable || !_route->panner()) {
-			_surface->write (_vpot->zero());
-			return;
-		}
+	if (!pan_control) {
+		return;
+	}
 
-		Control* control = control_by_parameter[PanAzimuthAutomation];
+	Control* control = 0;
+	ControlParameterMap::iterator i = control_by_parameter.find (PanAzimuthAutomation);
 
-		if (!control) {
-			return;
-		}
+	if (i == control_by_parameter.end()) {
+		return;
+	}
 
-		double pos = pannable->pan_azimuth_control->internal_to_interface (pannable->pan_azimuth_control->get_value());
+	control = i->second;
 
-		if (force_update || pos != _last_pan_azi_position_written) {
+	double normalized_pos = pan_control->internal_to_interface (pan_control->get_value());
+	double internal_pos = pan_control->get_value();
 
-			if (control == _fader) {
-				if (!_fader->in_use()) {
-					_surface->write (_fader->set_position (pos));
-					queue_parameter_display (PanAzimuthAutomation, pos);
-				}
-			} else if (control == _vpot) {
-				_surface->write (_vpot->set (pos, true, Pot::dot));
-				queue_parameter_display (PanAzimuthAutomation, pos);
-			}
+	if (force_update || (normalized_pos != _last_pan_azi_position_written)) {
 
-			queue_display_reset (2000);
-			_last_pan_azi_position_written = pos;
+		if (control == _fader) {
+			if (!_fader->in_use()) {
+				_surface->write (_fader->set_position (normalized_pos));
+				/* show actual internal value to user */
+				queue_parameter_display (PanAzimuthAutomation, internal_pos);
+			}
+		} else if (control == _vpot) {
+			_surface->write (_vpot->set (normalized_pos, true, Pot::dot));
+			/* show actual internal value to user */
+			queue_parameter_display (PanAzimuthAutomation, internal_pos);
 		}
+
+		_last_pan_azi_position_written = normalized_pos;
 	}
 }
 
 void
 Strip::notify_panner_width_changed (bool force_update)
 {
-	if (_route) {
+	if (!_route) {
+		return;
+	}
 
-		DEBUG_TRACE (DEBUG::MackieControl, string_compose ("pan width change for strip %1\n", _index));
+	DEBUG_TRACE (DEBUG::MackieControl, string_compose ("pan width change for strip %1\n", _index));
 
-		boost::shared_ptr<Pannable> pannable = _route->pannable();
+	boost::shared_ptr<AutomationControl> pan_control = _route->pan_width_control ();
 
-		if (!pannable || !_route->panner()) {
-			_surface->write (_vpot->zero());
-			return;
-		}
+	if (!pan_control) {
+		return;
+	}
 
+	Control* control = 0;
+	ControlParameterMap::iterator i = control_by_parameter.find (PanWidthAutomation);
 
-		Control* control = control_by_parameter[PanWidthAutomation];
+	if (i == control_by_parameter.end()) {
+		return;
+	}
 
-		if (!control) {
-			return;
-		}
+	control = i->second;
 
-		double pos = pannable->pan_width_control->internal_to_interface (pannable->pan_width_control->get_value());
+	double pos = pan_control->internal_to_interface (pan_control->get_value());
 
-		if (force_update || pos != _last_pan_azi_position_written) {
+	if (force_update || pos != _last_pan_width_position_written) {
 
-			if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) {
+		if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) {
 
-				if (control == _fader) {
-					if (!control->in_use()) {
-						_surface->write (_fader->set_position (pos));
-						queue_parameter_display (PanWidthAutomation, pos);
-					}
+			if (control == _fader) {
+				if (!control->in_use()) {
+					_surface->write (_fader->set_position (pos));
+					queue_parameter_display (PanWidthAutomation, pos);
 				}
-
-			} else if (control == _vpot) {
-				_surface->write (_vpot->set (pos, true, Pot::spread));
-				queue_parameter_display (PanWidthAutomation, pos);
 			}
 
-			queue_display_reset (2000);
-			_last_pan_azi_position_written = pos;
+		} else if (control == _vpot) {
+			_surface->write (_vpot->set (pos, true, Pot::spread));
+			queue_parameter_display (PanWidthAutomation, pos);
 		}
+
+		_last_pan_width_position_written = pos;
 	}
 }
 
@@ -500,7 +748,7 @@ Strip::select_event (Button&, ButtonState bs)
 		if (ms & MackieControlProtocol::MODIFIER_CMDALT) {
 			_controls_locked = !_controls_locked;
 			_surface->write (display (1,_controls_locked ?  "Locked" : "Unlock"));
-			queue_display_reset (1000);
+			block_vpot_mode_display_for (1000);
 			return;
 		}
 
@@ -508,7 +756,7 @@ Strip::select_event (Button&, ButtonState bs)
 			/* reset to default */
 			boost::shared_ptr<AutomationControl> ac = _fader->control ();
 			if (ac) {
-				ac->set_value (ac->normal());
+				ac->set_value (ac->normal(), Controllable::NoGroup);
 			}
 			return;
 		}
@@ -526,6 +774,28 @@ Strip::select_event (Button&, ButtonState bs)
 void
 Strip::vselect_event (Button&, ButtonState bs)
 {
+	if (_surface->mcp().subview_mode() != MackieControlProtocol::None) {
+
+		/* subview mode: vpot press acts like a button for toggle parameters */
+
+		if (bs != press) {
+			return;
+		}
+
+		boost::shared_ptr<AutomationControl> control = _vpot->control ();
+		if (!control) {
+			return;
+		}
+
+		if (control->toggled()) {
+			if (control->toggled()) {
+				control->set_value (!control->get_value(), Controllable::NoGroup);
+			}
+		}
+
+		return;
+	}
+
 	if (bs == press) {
 
 		int ms = _surface->mcp().main_modifier_state();
@@ -537,7 +807,7 @@ Strip::vselect_event (Button&, ButtonState bs)
 			if (ac) {
 
 				/* reset to default/normal value */
-				ac->set_value (ac->normal());
+				ac->set_value (ac->normal(), Controllable::NoGroup);
 			}
 
 		}  else {
@@ -560,7 +830,7 @@ Strip::fader_touch_event (Button&, ButtonState bs)
 
 		if (_surface->mcp().main_modifier_state() & MackieControlProtocol::MODIFIER_SHIFT) {
 			if (ac) {
-				ac->set_value (ac->normal());
+				ac->set_value (ac->normal(), Controllable::NoGroup);
 			}
 		} else {
 
@@ -568,8 +838,7 @@ Strip::fader_touch_event (Button&, ButtonState bs)
 			_fader->start_touch (_surface->mcp().transport_frame());
 
 			if (ac) {
-				queue_parameter_display ((AutomationType) ac->parameter().type(), ac->internal_to_interface (ac->get_value()));
-				queue_display_reset (2000);
+				queue_parameter_display ((AutomationType) ac->parameter().type(), ac->get_value());
 			}
 		}
 
@@ -638,7 +907,7 @@ Strip::handle_button (Button& button, ButtonState bs)
 				/* apply change */
 
 				for (MackieControlProtocol::ControlList::iterator c = controls.begin(); c != controls.end(); ++c) {
-					(*c)->set_value (new_value);
+					(*c)->set_value (new_value, Controllable::NoGroup);
 				}
 
 			} else {
@@ -664,48 +933,109 @@ Strip::queue_parameter_display (AutomationType type, float val)
 void
 Strip::do_parameter_display (AutomationType type, float val)
 {
+	bool screen_hold = false;
+	char buf[16];
+
 	switch (type) {
 	case GainAutomation:
 		if (val == 0.0) {
 			_surface->write (display (1, " -inf "));
 		} else {
-			char buf[16];
 			float dB = accurate_coefficient_to_dB (val);
 			snprintf (buf, sizeof (buf), "%6.1f", dB);
 			_surface->write (display (1, buf));
+			screen_hold = true;
 		}
 		break;
 
 	case PanAzimuthAutomation:
-		if (_route) {
-			boost::shared_ptr<Pannable> p = _route->pannable();
-			if (p && _route->panner()) {
-				string str =_route->panner()->value_as_string (p->pan_azimuth_control);
-				_surface->write (display (1, str));
+		if (Profile->get_mixbus()) {
+			snprintf (buf, sizeof (buf), "%2.1f", val);
+			_surface->write (display (1, buf));
+			screen_hold = true;
+		} else {
+			if (_route) {
+				boost::shared_ptr<Pannable> p = _route->pannable();
+				if (p && _route->panner()) {
+					string str =_route->panner()->value_as_string (p->pan_azimuth_control);
+					_surface->write (display (1, str));
+					screen_hold = true;
+				}
 			}
 		}
 		break;
 
 	case PanWidthAutomation:
 		if (_route) {
-			char buf[16];
 			snprintf (buf, sizeof (buf), "%5ld%%", lrintf ((val * 200.0)-100));
 			_surface->write (display (1, buf));
+			screen_hold = true;
 		}
 		break;
 
 	case TrimAutomation:
 		if (_route) {
-			char buf[16];
 			float dB = accurate_coefficient_to_dB (val);
 			snprintf (buf, sizeof (buf), "%6.1f", dB);
 			_surface->write (display (1, buf));
+			screen_hold = true;
+		}
+		break;
+
+	case PhaseAutomation:
+		if (_route) {
+			if (_route->phase_control()->get_value() < 0.5) {
+				_surface->write (display (1, "Normal"));
+			} else {
+				_surface->write (display (1, "Invert"));
+			}
+			screen_hold = true;
 		}
 		break;
 
+	case SendAutomation:
+		if (val == 0.0) {
+			_surface->write (display (1, " -inf "));
+		} else {
+			float dB = accurate_coefficient_to_dB (val);
+			snprintf (buf, sizeof (buf), "%6.1f", dB);
+			_surface->write (display (1, buf));
+			screen_hold = true;
+		}
+		break;
+	case EQGain:
+	case EQFrequency:
+	case EQQ:
+	case EQShape:
+	case EQHPF:
+	case CompThreshold:
+	case CompSpeed:
+	case CompMakeup:
+	case CompRedux:
+		snprintf (buf, sizeof (buf), "%6.1f", val);
+		_surface->write (display (1, buf));
+		screen_hold = true;
+		break;
+	case EQEnable:
+	case CompEnable:
+		if (val >= 0.5) {
+			_surface->write (display (1, "on"));
+		} else {
+			_surface->write (display (1, "off"));
+		}
+		break;
+	case CompMode:
+		if (_surface->mcp().subview_route()) {
+			_surface->write (display (1, _surface->mcp().subview_route()->comp_mode_name (val)));
+		}
+		break;
 	default:
 		break;
 	}
+
+	if (screen_hold) {
+		block_vpot_mode_display_for (1000);
+	}
 }
 
 void
@@ -722,6 +1052,10 @@ void
 Strip::handle_fader (Fader& fader, float position)
 {
 	DEBUG_TRACE (DEBUG::MackieControl, string_compose ("fader to %1\n", position));
+	boost::shared_ptr<AutomationControl> ac = fader.control();
+	if (!ac) {
+		return;
+	}
 
 	fader.set_value (position);
 
@@ -746,30 +1080,80 @@ Strip::handle_pot (Pot& pot, float delta)
 	*/
 
 	boost::shared_ptr<AutomationControl> ac = pot.control();
+	if (!ac) {
+		return;
+	}
 	double p = pot.get_value ();
 	p += delta;
-	p = max (ac->lower(), p);
-	p = min (ac->upper(), p);
+	// fader and pot should be the same and fader is hard coded 0 -> 1
+	p = max (0.0, p);
+	p = min (1.0, p);
 	pot.set_value (p);
 }
 
 void
-Strip::periodic (uint64_t usecs)
+Strip::periodic (ARDOUR::microseconds_t now)
 {
+	bool reshow_vpot_mode = false;
+	bool reshow_name = false;
+	bool good_strip = true;
+
 	if (!_route) {
+		// view mode may cover as many as 3 strips
+		// needs to be cleared when there are less than 3 routes
+		if (_index > 2) {
+			return;
+		} else {
+			good_strip = false;
+		}
+	}
+
+	if (_block_screen_redisplay_until >= now) {
+		if (_surface->mcp().device_info().has_separate_meters()) {
+			goto meters;
+		}
+		/* no drawing here, for now */
+		return;
+
+	} else if (_block_screen_redisplay_until) {
+
+		/* timeout reached, reset */
+
+		_block_screen_redisplay_until = 0;
+		reshow_vpot_mode = (true && good_strip);
+		reshow_name = true;
+	}
+
+	if (_block_vpot_mode_redisplay_until >= now) {
 		return;
+	} else if (_block_vpot_mode_redisplay_until) {
+
+		/* timeout reached, reset */
+
+		_block_vpot_mode_redisplay_until = 0;
+		reshow_vpot_mode = (true && good_strip);
+	}
+
+	if (reshow_name) {
+		show_route_name ();
 	}
 
-	update_automation ();
-	update_meter ();
+	if (reshow_vpot_mode) {
+		return_to_vpot_mode_display ();
+	} else if (good_strip) {
+		/* no point doing this if we just switched back to vpot mode
+		   display */
+		update_automation ();
+	}
 
-	if (_reset_display_at && _reset_display_at < usecs) {
-		reset_display ();
+  meters:
+	if (good_strip) {
+		update_meter ();
 	}
 }
 
 void
-Strip::redisplay ()
+Strip::redisplay (ARDOUR::microseconds_t now)
 {
 	RedisplayRequest req;
 	bool have_request = false;
@@ -779,6 +1163,10 @@ Strip::redisplay ()
 		have_request = true;
 	}
 
+	if (_block_screen_redisplay_until >= now) {
+		return;
+	}
+
 	if (have_request) {
 		do_parameter_display (req.type, req.val);
 	}
@@ -787,20 +1175,33 @@ Strip::redisplay ()
 void
 Strip::update_automation ()
 {
-	ARDOUR::AutoState gain_state = _route->gain_control()->automation_state();
+	if (!_route) {
+		return;
+	}
 
-	if (gain_state == Touch || gain_state == Play) {
+	ARDOUR::AutoState state = _route->gain_control()->automation_state();
+
+	if (state == Touch || state == Play) {
 		notify_gain_changed (false);
 	}
 
-	if (_route->panner()) {
-		ARDOUR::AutoState panner_state = _route->panner()->automation_state();
-		if (panner_state == Touch || panner_state == Play) {
+	boost::shared_ptr<AutomationControl> pan_control = _route->pan_azimuth_control ();
+	if (pan_control) {
+		state = pan_control->automation_state ();
+		if (state == Touch || state == Play) {
 			notify_panner_azi_changed (false);
+		}
+	}
+
+	pan_control = _route->pan_width_control ();
+	if (pan_control) {
+		state = pan_control->automation_state ();
+		if (state == Touch || state == Play) {
 			notify_panner_width_changed (false);
 		}
 	}
-	if (_route->trim()) {
+
+	if (_route->trim() && route()->trim()->active()) {
 		ARDOUR::AutoState trim_state = _route->trim_control()->automation_state();
 		if (trim_state == Touch || trim_state == Play) {
 			notify_trim_changed (false);
@@ -811,6 +1212,10 @@ Strip::update_automation ()
 void
 Strip::update_meter ()
 {
+	if (_surface->mcp().subview_mode() != MackieControlProtocol::None) {
+		return;
+	}
+
 	if (_meter && _transport_is_rolling && _metering_active) {
 		float dB = const_cast<PeakMeter&> (_route->peak_meter()).meter_level (0, MeterMCP);
 		_meter->send_update (*_surface, dB);
@@ -901,31 +1306,41 @@ Strip::gui_selection_changed (const ARDOUR::StrongRouteNotificationList& rl)
 }
 
 string
-Strip::vpot_mode_string () const
+Strip::vpot_mode_string ()
 {
 	boost::shared_ptr<AutomationControl> ac = _vpot->control();
-
 	if (!ac) {
 		return string();
 	}
 
-	switch (ac->parameter().type()) {
-	case GainAutomation:
+	if (control_by_parameter.find (GainAutomation)->second == _vpot) {
 		return "Fader";
-	case TrimAutomation:
+	} else if (control_by_parameter.find (TrimAutomation)->second == _vpot) {
 		return "Trim";
-	case PanAzimuthAutomation:
+	} else if (control_by_parameter.find (PhaseAutomation)->second == _vpot) {
+		return string_compose ("Phase%1", _route->phase_control()->channel() + 1);
+	} else if (control_by_parameter.find (SendAutomation)->second == _vpot) {
+		// should be bus name
+		boost::shared_ptr<Processor> p = _route->nth_send (_current_send);
+		if (p) {
+			return p->name();
+		}
+	} else if (control_by_parameter.find (PanAzimuthAutomation)->second == _vpot) {
 		return "Pan";
-	case PanWidthAutomation:
+	} else if (control_by_parameter.find (PanWidthAutomation)->second == _vpot) {
 		return "Width";
-	case PanElevationAutomation:
+	} else if (control_by_parameter.find (PanElevationAutomation)->second == _vpot) {
 		return "Elev";
-	case PanFrontBackAutomation:
+	} else if (control_by_parameter.find (PanFrontBackAutomation)->second == _vpot) {
 		return "F/Rear";
-	case PanLFEAutomation:
+	} else if (control_by_parameter.find (PanLFEAutomation)->second == _vpot) {
 		return "LFE";
 	}
 
+	if (_surface->mcp().subview_mode() != MackieControlProtocol::None) {
+		return string();
+	}
+
 	return "???";
 }
 
@@ -936,244 +1351,445 @@ Strip::potmode_changed (bool notify)
 		return;
 	}
 
-	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 (1000);
-		return;
-	}
 	// WIP
 	int pm = _surface->mcp().pot_mode();
 	switch (pm) {
-		case MackieControlProtocol::Pan:
-			// This needs to set current pan mode (azimuth or width... or whatever)
-			set_vpot_parameter (_pan_mode);
-			DEBUG_TRACE (DEBUG::MackieControl, "Assign pot to Pan mode.\n");
-			break;
-		case MackieControlProtocol::Tracks: // should change the Tracks to Trim
-			DEBUG_TRACE (DEBUG::MackieControl, "Assign pot to Trim mode.\n");
-			set_vpot_parameter (TrimAutomation);
-			break;
-		case MackieControlProtocol::Send:
-			DEBUG_TRACE (DEBUG::MackieControl, "Assign pot to Send mode.\n");
-			// set to current send
-			break;
-		default:
-			break;
-		}
-
-	if (notify) {
-		notify_all ();
-	}
-}
-
-void
-Strip::flip_mode_changed (bool notify)
-{
-	if (!_route) {
-		return;
+	case MackieControlProtocol::Pan:
+		// This needs to set current pan mode (azimuth or width... or whatever)
+		DEBUG_TRACE (DEBUG::MackieControl, string_compose ("Assign pot to Pan mode %1\n", enum_2_string (_pan_mode)));
+		set_vpot_parameter (_pan_mode);
+		break;
+	case MackieControlProtocol::Trim:
+		DEBUG_TRACE (DEBUG::MackieControl, "Assign pot to Trim mode.\n");
+		set_vpot_parameter (_trim_mode);
+		break;
+	case MackieControlProtocol::Send:
+		// _current_send has the number of the send we will show
+		DEBUG_TRACE (DEBUG::MackieControl, "Assign pot to Send mode.\n");
+		set_vpot_parameter (SendAutomation);
+		break;
 	}
 
-	reset_saved_values ();
-
-	boost::shared_ptr<AutomationControl> fader_controllable = _fader->control ();
-	boost::shared_ptr<AutomationControl> 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) {
 		notify_all ();
 	}
 }
 
 void
-Strip::queue_display_reset (uint32_t msecs)
+Strip::block_screen_display_for (uint32_t msecs)
 {
-	struct timeval now;
-	struct timeval delta;
-	struct timeval when;
-	gettimeofday (&now, 0);
-
-	delta.tv_sec = msecs/1000;
-	delta.tv_usec = (msecs - ((msecs/1000) * 1000)) * 1000;
-
-	timeradd (&now, &delta, &when);
-
-	_reset_display_at = (when.tv_sec * 1000000) + when.tv_usec;
+	_block_screen_redisplay_until = ARDOUR::get_microseconds() + (msecs * 1000);
 }
 
 void
-Strip::clear_display_reset ()
+Strip::block_vpot_mode_display_for (uint32_t msecs)
 {
-	_reset_display_at = 0;
+	_block_vpot_mode_redisplay_until = ARDOUR::get_microseconds() + (msecs * 1000);
 }
 
 void
-Strip::reset_display ()
+Strip::return_to_vpot_mode_display ()
 {
-	if (_route) {
+	/* returns the second line of the two-line per-strip display
+	   back the mode where it shows what the VPot controls.
+	*/
+
+	if (_surface->mcp().subview_mode() != MackieControlProtocol::None) {
+		/* do nothing - second line shows value of current subview parameter */
+		return;
+	} else 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<Route> a, boost::shared_ptr<Route> b) {
-		return a->name().compare (b->name()) < 0;
-	}
-};
-
 void
-Strip::maybe_add_to_bundle_map (BundleMap& bm, boost::shared_ptr<Bundle> b, bool for_input, const ChanCount& channels)
+Strip::next_pot_mode ()
 {
-	if (b->ports_are_outputs() == !for_input  || b->nchannels() != channels) {
+	vector<AutomationType>::iterator i;
+
+	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"));
+		block_vpot_mode_display_for (1000);
 		return;
 	}
 
-	bm[b->name()] = b;
-}
 
-void
-Strip::build_input_list (const ChanCount& channels)
-{
-	boost::shared_ptr<ARDOUR::BundleList> b = _surface->mcp().get_session().bundles ();
+	boost::shared_ptr<AutomationControl> ac = _vpot->control();
+
+	if (!ac) {
+		return;
+	}
 
-	input_bundles.clear ();
 
-	/* give user bundles first chance at being in the menu */
+	if (_surface->mcp().pot_mode() == MackieControlProtocol::Pan) {
 
-	for (ARDOUR::BundleList::iterator i = b->begin(); i != b->end(); ++i) {
-		if (boost::dynamic_pointer_cast<UserBundle> (*i)) {
-			maybe_add_to_bundle_map (input_bundles, *i, true, channels);
+		if (possible_pot_parameters.empty() || (possible_pot_parameters.size() == 1 && possible_pot_parameters.front() == ac->parameter().type())) {
+			return;
 		}
-	}
 
-	for (ARDOUR::BundleList::iterator i = b->begin(); i != b->end(); ++i) {
-		if (boost::dynamic_pointer_cast<UserBundle> (*i) == 0) {
-			maybe_add_to_bundle_map (input_bundles, *i, true, channels);
+		for (i = possible_pot_parameters.begin(); i != possible_pot_parameters.end(); ++i) {
+			if ((*i) == ac->parameter().type()) {
+				break;
+			}
 		}
-	}
 
-	boost::shared_ptr<ARDOUR::RouteList> routes = _surface->mcp().get_session().get_routes ();
-	RouteList copy = *routes;
-	copy.sort (RouteCompareByName ());
+		/* 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)
+		*/
 
-	for (ARDOUR::RouteList::const_iterator i = copy.begin(); i != copy.end(); ++i) {
-		maybe_add_to_bundle_map (input_bundles, (*i)->output()->bundle(), true, channels);
-	}
+		if (i != possible_pot_parameters.end()) {
+			++i;
+		}
+
+		if (i == possible_pot_parameters.end()) {
+			i = possible_pot_parameters.begin();
+		}
+
+		set_vpot_parameter (*i);
+	} else if (_surface->mcp().pot_mode() == MackieControlProtocol::Trim) {
+		if (possible_trim_parameters.empty() || (possible_trim_parameters.size() == 1 && possible_trim_parameters.front() == ac->parameter().type())) {
+			return;
+		}
 
+		for (i = possible_trim_parameters.begin(); i != possible_trim_parameters.end(); ++i) {
+			if ((*i) == ac->parameter().type()) {
+				break;
+			}
+		}
+		if ((*i) == PhaseAutomation && _route->phase_invert().size() > 1) {
+			// There are more than one channel of phase
+			if ((_route->phase_control()->channel() + 1) < _route->phase_invert().size()) {
+				_route->phase_control()->set_channel(_route->phase_control()->channel() + 1);
+				set_vpot_parameter (*i);
+				return;
+			} else {
+				_route->phase_control()->set_channel(0);
+			}
+		}
+		/* 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 != possible_trim_parameters.end()) {
+			++i;
+		}
+
+		if (i == possible_trim_parameters.end()) {
+			i = possible_trim_parameters.begin();
+		}
+		set_vpot_parameter (*i);
+	} else if (_surface->mcp().pot_mode() == MackieControlProtocol::Send) {
+		boost::shared_ptr<Processor> p = _route->nth_send (_current_send);
+		if (!p) {
+			return;
+		}
+		p = _route->nth_send (_current_send + 1);
+		if (p) {
+			_current_send++;
+			if (p->name() == "Monitor 1") { // skip monitor
+				p = _route->nth_send (_current_send + 1);
+				if (p) {
+					_current_send++;
+				} else {
+					_current_send = 0;
+				}
+			}
+		} else {
+			_current_send = 0;
+		}
+		set_vpot_parameter (SendAutomation);
+	}
 }
 
 void
-Strip::build_output_list (const ChanCount& channels)
+Strip::subview_mode_changed ()
 {
-	boost::shared_ptr<ARDOUR::BundleList> b = _surface->mcp().get_session().bundles ();
+	boost::shared_ptr<Route> r = _surface->mcp().subview_route();
 
-	output_bundles.clear ();
+	subview_connections.drop_connections ();
 
-	/* give user bundles first chance at being in the menu */
+	switch (_surface->mcp().subview_mode()) {
+	case MackieControlProtocol::None:
+		set_vpot_parameter (vpot_parameter);
+		notify_metering_state_changed ();
+		eq_band = -1;
+		break;
 
-	for (ARDOUR::BundleList::iterator i = b->begin(); i != b->end(); ++i) {
-		if (boost::dynamic_pointer_cast<UserBundle> (*i)) {
-			maybe_add_to_bundle_map (output_bundles, *i, false, channels);
+	case MackieControlProtocol::EQ:
+		if (r) {
+			setup_eq_vpot (r);
+		} else {
+			/* leave it as it was */
 		}
-	}
+		break;
 
-	for (ARDOUR::BundleList::iterator i = b->begin(); i != b->end(); ++i) {
-		if (boost::dynamic_pointer_cast<UserBundle> (*i) == 0) {
-			maybe_add_to_bundle_map (output_bundles, *i, false, channels);
+	case MackieControlProtocol::Dynamics:
+		if (r) {
+			setup_dyn_vpot (r);
+		} else {
+			/* leave it as it was */
 		}
+		break;
 	}
+}
 
-	boost::shared_ptr<ARDOUR::RouteList> routes = _surface->mcp().get_session().get_routes ();
-	RouteList copy = *routes;
-	copy.sort (RouteCompareByName ());
+void
+Strip::setup_dyn_vpot (boost::shared_ptr<Route> r)
+{
+	if (!r) {
+		return;
+	}
 
-	for (ARDOUR::RouteList::const_iterator i = copy.begin(); i != copy.end(); ++i) {
-		maybe_add_to_bundle_map (output_bundles, (*i)->input()->bundle(), false, channels);
+	boost::shared_ptr<AutomationControl> tc = r->comp_threshold_controllable ();
+	boost::shared_ptr<AutomationControl> sc = r->comp_speed_controllable ();
+	boost::shared_ptr<AutomationControl> mc = r->comp_mode_controllable ();
+	boost::shared_ptr<AutomationControl> kc = r->comp_makeup_controllable ();
+	boost::shared_ptr<AutomationControl> rc = r->comp_redux_controllable ();
+	boost::shared_ptr<AutomationControl> ec = r->comp_enable_controllable ();
+
+	uint32_t pos = _surface->mcp().global_index (*this);
+
+	/* we will control the pos-th available parameter, from the list in the
+	 * order shown above.
+	 */
+
+	vector<boost::shared_ptr<AutomationControl> > available;
+	vector<AutomationType> params;
+
+	if (tc) { available.push_back (tc); params.push_back (CompThreshold); }
+	if (sc) { available.push_back (sc); params.push_back (CompSpeed); }
+	if (mc) { available.push_back (mc); params.push_back (CompMode); }
+	if (kc) { available.push_back (kc); params.push_back (CompMakeup); }
+	if (rc) { available.push_back (rc); params.push_back (CompRedux); }
+	if (ec) { available.push_back (ec); params.push_back (CompEnable); }
+
+	if (pos >= available.size()) {
+		/* this knob is not needed to control the available parameters */
+		_vpot->set_control (boost::shared_ptr<AutomationControl>());
+		_surface->write (display (0, string()));
+		_surface->write (display (1, string()));
+		return;
 	}
+
+	boost::shared_ptr<AutomationControl> pc;
+	AutomationType param;
+
+	pc = available[pos];
+	param = params[pos];
+
+	pc->Changed.connect (subview_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_dyn_change, this, param, false, true), ui_context());
+	_vpot->set_control (pc);
+
+	string pot_id;
+
+	switch (param) {
+	case CompThreshold:
+		pot_id = "Thresh";
+		break;
+	case CompSpeed:
+		if (mc) {
+			pot_id = r->comp_speed_name (mc->get_value());
+		} else {
+			pot_id = "Speed";
+		}
+		break;
+	case CompMode:
+		pot_id = "Mode";
+		break;
+	case CompMakeup:
+		pot_id = "Makeup";
+		break;
+	case CompRedux:
+		pot_id = "Redux";
+		break;
+	case CompEnable:
+		pot_id = "on/off";
+		break;
+	default:
+		break;
+	}
+
+	if (!pot_id.empty()) {
+		_surface->write (display (0, pot_id));
+	}
+
+	notify_dyn_change (param, true, false);
 }
 
 void
-Strip::next_pot_mode ()
+Strip::setup_eq_vpot (boost::shared_ptr<Route> r)
 {
-	vector<Evoral::Parameter>::iterator i;
+	uint32_t bands = r->eq_band_cnt ();
 
-	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 (1000);
+	if (bands == 0) {
+		/* should never get here */
 		return;
 	}
 
+	/* figure out how many params per band are available */
 
-	boost::shared_ptr<AutomationControl> ac = _vpot->control();
+	boost::shared_ptr<AutomationControl> pc;
+	uint32_t params_per_band = 0;
 
-	if (!ac) {
-		return;
+	if ((pc = r->eq_gain_controllable (0))) {
+		params_per_band += 1;
 	}
-	if (_surface->mcp().pot_mode() == MackieControlProtocol::Pan) {
-		if (possible_pot_parameters.empty() || (possible_pot_parameters.size() == 1 && possible_pot_parameters.front() == ac->parameter())) {
-			return;
+	if ((pc = r->eq_freq_controllable (0))) {
+		params_per_band += 1;
+	}
+	if ((pc = r->eq_q_controllable (0))) {
+		params_per_band += 1;
+	}
+	if ((pc = r->eq_shape_controllable (0))) {
+		params_per_band += 1;
+	}
+
+	/* pick the one for this strip, based on its global position across
+	 * all surfaces
+	 */
+
+	pc.reset ();
+
+	const uint32_t total_band_parameters = bands * params_per_band;
+	const uint32_t global_pos = _surface->mcp().global_index (*this);
+	AutomationType param = NullAutomation;
+	string band_name;
+
+	eq_band = -1;
+
+	if (global_pos < total_band_parameters) {
+
+		/* show a parameter for an EQ band */
+
+		const uint32_t parameter = global_pos % params_per_band;
+		eq_band = global_pos / params_per_band;
+		band_name = r->eq_band_name (eq_band);
+
+		switch (parameter) {
+		case 0:
+			pc = r->eq_gain_controllable (eq_band);
+			param = EQGain;
+			break;
+		case 1:
+			pc = r->eq_freq_controllable (eq_band);
+			param = EQFrequency;
+			break;
+		case 2:
+			pc = r->eq_q_controllable (eq_band);
+			param = EQQ;
+			break;
+		case 3:
+			pc = r->eq_shape_controllable (eq_band);
+			param = EQShape;
+			break;
 		}
 
-		for (i = possible_pot_parameters.begin(); i != possible_pot_parameters.end(); ++i) {
-			if ((*i) == ac->parameter()) {
-				break;
-			}
+	} else {
+
+		/* show a non-band parameter (HPF or enable)
+		 */
+
+		uint32_t parameter = global_pos - total_band_parameters;
+
+		switch (parameter) {
+		case 0: /* first control after band parameters */
+			pc = r->eq_hpf_controllable();
+			param = EQHPF;
+			break;
+		case 1: /* second control after band parameters */
+			pc = r->eq_enable_controllable();
+			param = EQEnable;
+			break;
+		default:
+			/* nothing to control */
+			_vpot->set_control (boost::shared_ptr<AutomationControl>());
+			_surface->write (display (0, string()));
+			_surface->write (display (1, string()));
+			/* done */
+			return;
+			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 != possible_pot_parameters.end()) {
-			++i;
+	if (pc) {
+		pc->Changed.connect (subview_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_eq_change, this, param, eq_band, false), ui_context());
+		_vpot->set_control (pc);
+
+		string pot_id;
+
+		switch (param) {
+		case EQGain:
+			pot_id = band_name + "Gain";
+			break;
+		case EQFrequency:
+			pot_id = band_name + "Freq";
+			break;
+		case EQQ:
+			pot_id = band_name + " Q";
+			break;
+		case EQShape:
+			pot_id = band_name + " Shp";
+			break;
+		case EQHPF:
+			pot_id = "HPFreq";
+			break;
+		case EQEnable:
+			pot_id = "on/off";
+			break;
+		default:
+			break;
 		}
 
-		if (i == possible_pot_parameters.end()) {
-			i = possible_pot_parameters.begin();
+		if (!pot_id.empty()) {
+			_surface->write (display (0, pot_id));
 		}
-		set_vpot_parameter (*i);
+
+		notify_eq_change (param, eq_band, true);
 	}
 }
 
 void
-Strip::set_vpot_parameter (Evoral::Parameter p)
+Strip::set_vpot_parameter (AutomationType p)
 {
-	boost::shared_ptr<Pannable> pannable;
+	if (!_route || (p == NullAutomation)) {
+		control_by_parameter[vpot_parameter] = 0;
+		vpot_parameter = NullAutomation;
+		_vpot->set_control (boost::shared_ptr<AutomationControl>());
+		_surface->write (display (1, string()));
+		return;
+	}
+
+	boost::shared_ptr<AutomationControl> pan_control;
 
 	DEBUG_TRACE (DEBUG::MackieControl, string_compose ("switch to vpot mode %1\n", p));
 
 	reset_saved_values ();
-	for (int i = 0;  i <= TrimAutomation; ++i) {
-		if (control_by_parameter[i] == _vpot) {
-			control_by_parameter[i] = 0;
+
+	/* unset any mapping between the vpot and any existing parameters */
+
+	for (ControlParameterMap::iterator i = control_by_parameter.begin(); i != control_by_parameter.end(); ++i) {
+
+		if (i != control_by_parameter.end() && i->second == _vpot) {
+			i->second = 0;
 		}
 	}
 
-	switch (p.type()) {
+	switch (p) {
 	case PanAzimuthAutomation:
-		_pan_mode = PanAzimuthAutomation;
-		pannable = _route->pannable ();
-		if (pannable) {
+		if ((pan_control = _route->pan_azimuth_control ())) {
 			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);
+				_pan_mode = PanAzimuthAutomation;
+				if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) {
+					/* gain to vpot, pan azi to fader */
+					_vpot->set_control (_route->gain_control());
+					vpot_parameter = GainAutomation;
+					control_by_parameter[GainAutomation] = _vpot;
+					_fader->set_control (pan_control);
 					control_by_parameter[PanAzimuthAutomation] = _fader;
 				} else {
 					_fader->set_control (boost::shared_ptr<AutomationControl>());
@@ -1181,28 +1797,28 @@ Strip::set_vpot_parameter (Evoral::Parameter p)
 				}
 			} else {
 				/* gain to fader, pan azi to vpot */
+				vpot_parameter = PanAzimuthAutomation;
 				_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<AutomationControl>());
-					control_by_parameter[PanAzimuthAutomation] = 0;
-				}
+				_vpot->set_control (pan_control);
+				control_by_parameter[PanAzimuthAutomation] = _vpot;
 			}
+		} else {
+			_vpot->set_control (boost::shared_ptr<AutomationControl>());
+			control_by_parameter[PanAzimuthAutomation] = 0;
 		}
 		break;
+
 	case PanWidthAutomation:
-		_pan_mode = PanWidthAutomation;
-		pannable = _route->pannable ();
-		if (pannable) {
+		if ((pan_control = _route->pan_width_control ())) {
 			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);
+				_pan_mode = PanWidthAutomation;
+				if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) {
+					/* gain to vpot, pan width to fader */
+					_vpot->set_control (_route->gain_control());
+					vpot_parameter = GainAutomation;
+					control_by_parameter[GainAutomation] = _vpot;
+					_fader->set_control (pan_control);
 					control_by_parameter[PanWidthAutomation] = _fader;
 				} else {
 					_fader->set_control (boost::shared_ptr<AutomationControl>());
@@ -1210,18 +1826,18 @@ Strip::set_vpot_parameter (Evoral::Parameter p)
 				}
 			} else {
 				/* gain to fader, pan width to vpot */
+				vpot_parameter = PanWidthAutomation;
 				_fader->set_control (_route->gain_control());
 				control_by_parameter[GainAutomation] = _fader;
-				if (pannable) {
-					_vpot->set_control (pannable->pan_width_control);
-					control_by_parameter[PanWidthAutomation] = _vpot;
-				} else {
-					_vpot->set_control (boost::shared_ptr<AutomationControl>());
-					control_by_parameter[PanWidthAutomation] = 0;
-				}
+				_vpot->set_control (pan_control);
+				control_by_parameter[PanWidthAutomation] = _vpot;
 			}
+		} else {
+			_vpot->set_control (boost::shared_ptr<AutomationControl>());
+			control_by_parameter[PanWidthAutomation] = 0;
 		}
 		break;
+
 	case PanElevationAutomation:
 		break;
 	case PanFrontBackAutomation:
@@ -1229,23 +1845,111 @@ Strip::set_vpot_parameter (Evoral::Parameter p)
 	case PanLFEAutomation:
 		break;
 	case TrimAutomation:
-		if (_route->trim()) {
+		_trim_mode = TrimAutomation;
+		vpot_parameter = TrimAutomation;
+		if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) {
+			/* gain to vpot, trim to fader */
+			_vpot->set_control (_route->gain_control());
+			control_by_parameter[GainAutomation] = _vpot;
+			if (_route->trim() && route()->trim()->active()) {
+				_fader->set_control (_route->trim_control());
+				control_by_parameter[TrimAutomation] = _fader;
+			} else {
+				_fader->set_control (boost::shared_ptr<AutomationControl>());
+				control_by_parameter[TrimAutomation] = 0;
+			}
+		} else {
+			/* gain to fader, trim to vpot */
+			_fader->set_control (_route->gain_control());
+			control_by_parameter[GainAutomation] = _fader;
+			if (_route->trim() && route()->trim()->active()) {
+				_vpot->set_control (_route->trim_control());
+				control_by_parameter[TrimAutomation] = _vpot;
+			} else {
+				_vpot->set_control (boost::shared_ptr<AutomationControl>());
+				control_by_parameter[TrimAutomation] = 0;
+			}
+		}
+		break;
+	case PhaseAutomation:
+		_trim_mode = PhaseAutomation;
+		vpot_parameter = PhaseAutomation;
+		if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) {
+			/* gain to vpot, phase to fader */
+			_vpot->set_control (_route->gain_control());
+			control_by_parameter[GainAutomation] = _vpot;
+			if (_route->phase_invert().size()) {
+				_fader->set_control (_route->phase_control());
+				control_by_parameter[PhaseAutomation] = _fader;
+			} else {
+				_fader->set_control (boost::shared_ptr<AutomationControl>());
+				control_by_parameter[PhaseAutomation] = 0;
+			}
+		} else {
+			/* gain to fader, phase to vpot */
+			_fader->set_control (_route->gain_control());
+			control_by_parameter[GainAutomation] = _fader;
+			if (_route->phase_invert().size()) {
+				_vpot->set_control (_route->phase_control());
+				control_by_parameter[PhaseAutomation] = _vpot;
+			} else {
+				_vpot->set_control (boost::shared_ptr<AutomationControl>());
+				control_by_parameter[PhaseAutomation] = 0;
+			}
+		}
+		break;
+	case SendAutomation:
+		if (!Profile->get_mixbus()) {
 			if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) {
-				/* gain to vpot, trim to fader */
+				// gain to vpot, send to fader
 				_vpot->set_control (_route->gain_control());
 				control_by_parameter[GainAutomation] = _vpot;
-					_fader->set_control (_route->trim_control());
-					control_by_parameter[TrimAutomation] = _fader;
+				// test for send to control
+				boost::shared_ptr<Processor> p = _route->nth_send (_current_send);
+				if (p && p->name() != "Monitor 1") {
+					boost::shared_ptr<Send> s =  boost::dynamic_pointer_cast<Send>(p);
+					boost::shared_ptr<Amp> a = s->amp();
+					_fader->set_control (a->gain_control());
+					// connect to signal
+					send_connections.drop_connections ();
+					a->gain_control()->Changed.connect(send_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_processor_changed, this, false), ui_context());
+					control_by_parameter[SendAutomation] = _fader;
+				} else {
+					_fader->set_control (boost::shared_ptr<AutomationControl>());
+					control_by_parameter[SendAutomation] = 0;
+				}
 			} else {
-				/* gain to fader, trim to vpot */
+				// gain to fader, send to vpot
 				_fader->set_control (_route->gain_control());
 				control_by_parameter[GainAutomation] = _fader;
-					_vpot->set_control (_route->trim_control());
-					control_by_parameter[TrimAutomation] = _vpot;
+				boost::shared_ptr<Processor> p = _route->nth_send (_current_send);
+				if (p && p->name() != "Monitor 1") {
+					boost::shared_ptr<Send> s =  boost::dynamic_pointer_cast<Send>(p);
+					boost::shared_ptr<Amp> a = s->amp();
+					_vpot->set_control (a->gain_control());
+					// connect to signal
+					send_connections.drop_connections ();
+					a->gain_control()->Changed.connect(send_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_processor_changed, this, false), ui_context());
+					control_by_parameter[SendAutomation] = _vpot;
+				} else {
+					// gain to fader, send to vpot
+					_fader->set_control (_route->gain_control());
+					control_by_parameter[GainAutomation] = _fader;
+					boost::shared_ptr<Processor> p = _route->nth_send (_current_send);
+					if (p && p->name() != "Monitor 1") {
+						boost::shared_ptr<Send> s =  boost::dynamic_pointer_cast<Send>(p);
+						boost::shared_ptr<Amp> a = s->amp();
+						_vpot->set_control (a->gain_control());
+						// connect to signal
+						send_connections.drop_connections ();
+						a->gain_control()->Changed.connect(send_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_processor_changed, this, false), ui_context());
+						control_by_parameter[SendAutomation] = _vpot;
+					} else {
+						_vpot->set_control (boost::shared_ptr<AutomationControl>());
+						control_by_parameter[SendAutomation] = 0;
+					}
+				}
 			}
-		} else {
-			_vpot->set_control (boost::shared_ptr<AutomationControl>());
-			control_by_parameter[TrimAutomation] = 0;
 		}
 		break;
 	default:
@@ -1257,6 +1961,12 @@ Strip::set_vpot_parameter (Evoral::Parameter p)
 	_surface->write (display (1, vpot_mode_string()));
 }
 
+bool
+Strip::is_midi_track () const
+{
+	return boost::dynamic_pointer_cast<MidiTrack>(_route) != 0;
+}
+
 void
 Strip::reset_saved_values ()
 {
@@ -1270,6 +1980,10 @@ Strip::reset_saved_values ()
 void
 Strip::notify_metering_state_changed()
 {
+	if (_surface->mcp().subview_mode() != MackieControlProtocol::None) {
+		return;
+	}
+
 	if (!_route || !_meter) {
 		return;
 	}