X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fsurfaces%2Fmackie%2Fstrip.cc;h=9c3fc21bdacaa16089f26a4f5e12e100ff78b4b1;hb=5b5e64d860f40c949cf58d75de81fc86914f1baa;hp=cc36224fd6af04ce968a3ff014be2a9c7448eb97;hpb=69b4228176e37aac70e1928c2df76806a4b0598a;p=ardour.git

diff --git a/libs/surfaces/mackie/strip.cc b/libs/surfaces/mackie/strip.cc
index cc36224fd6..9c3fc21bda 100644
--- a/libs/surfaces/mackie/strip.cc
+++ b/libs/surfaces/mackie/strip.cc
@@ -37,14 +37,17 @@
 #include "ardour/debug.h"
 #include "ardour/midi_ui.h"
 #include "ardour/meter.h"
+#include "ardour/monitor_control.h"
 #include "ardour/plugin_insert.h"
 #include "ardour/pannable.h"
 #include "ardour/panner.h"
 #include "ardour/panner_shell.h"
+#include "ardour/phase_control.h"
 #include "ardour/rc_configuration.h"
 #include "ardour/route.h"
 #include "ardour/session.h"
 #include "ardour/send.h"
+#include "ardour/solo_isolate_control.h"
 #include "ardour/track.h"
 #include "ardour/midi_track.h"
 #include "ardour/user_bundle.h"
@@ -102,12 +105,10 @@ Strip::Strip (Surface& s, const std::string& name, int index, const map<Button::
 	, return_to_vpot_mode_display_at (UINT64_MAX)
 	, eq_band (-1)
 	, _pan_mode (PanAzimuthAutomation)
-	, 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)
 {
 	_fader = dynamic_cast<Fader*> (Fader::factory (*_surface, index, "fader", *this));
 	_vpot = dynamic_cast<Pot*> (Pot::factory (*_surface, Pot::ID + index, "vpot", *this));
@@ -184,19 +185,10 @@ 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[PhaseAutomation] = (Control*) 0;
-
 	reset_saved_values ();
 
 	if (!r) {
+		DEBUG_TRACE (DEBUG::MackieControl, string_compose ("Surface %1 Strip %2 mapped to null route\n", _surface->number(), _index));
 		zero ();
 		return;
 	}
@@ -207,20 +199,9 @@ Strip::set_route (boost::shared_ptr<Route> r, bool /*with_messages*/)
 	_solo->set_control (_route->solo_control());
 	_mute->set_control (_route->mute_control());
 
-	_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->solo_control()->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() && route()->trim()->active()) {
-		_route->trim_control()->Changed.connect(route_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_trim_changed, this, false), ui_context());
-	}
-
-	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());
@@ -267,16 +248,15 @@ Strip::set_route (boost::shared_ptr<Route> r, bool /*with_messages*/)
 		possible_pot_parameters.push_back (PanLFEAutomation);
 	}
 
-	if (_route->phase_invert().size()) {
-		possible_trim_parameters.push_back (PhaseAutomation);
-		_route->phase_control()->set_channel(0);
-	}
-	_current_send = 0;
-	/* Update */
 	_pan_mode = PanAzimuthAutomation;
-	potmode_changed (false);
-	notify_all ();
 
+	if (_surface->mcp().subview_mode() == MackieControlProtocol::None) {
+		set_vpot_parameter (_pan_mode);
+	}
+
+	_fader->set_control (_route->gain_control());
+
+	notify_all ();
 }
 
 void
@@ -298,8 +278,6 @@ Strip::notify_all()
 	notify_panner_azi_changed ();
 	notify_panner_width_changed ();
 	notify_record_enable_changed ();
-	notify_trim_changed ();
-	notify_phase_changed ();
 	notify_processor_changed ();
 }
 
@@ -307,7 +285,7 @@ void
 Strip::notify_solo_changed ()
 {
 	if (_route && _solo) {
-		_surface->write (_solo->set_state ((_route->soloed() || _route->listening_via_monitor()) ? on : off));
+		_surface->write (_solo->set_state (_route->soloed() ? on : off));
 	}
 }
 
@@ -327,7 +305,10 @@ void
 Strip::notify_record_enable_changed ()
 {
 	if (_route && _recenable)  {
-		_surface->write (_recenable->set_state (_route->record_enabled() ? on : off));
+		boost::shared_ptr<Track> trk = boost::dynamic_pointer_cast<Track> (_route);
+		if (trk) {
+			_surface->write (_recenable->set_state (trk->rec_enable_control()->get_value() ? on : off));
+		}
 	}
 }
 
@@ -346,105 +327,45 @@ Strip::notify_route_deleted ()
 void
 Strip::notify_gain_changed (bool force_update)
 {
-	if (_route) {
-
-		Control* control;
-
-		if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) {
-			control = _vpot;
-		} else {
-			control = _fader;
-		}
-
-		boost::shared_ptr<AutomationControl> 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() != MackieControlProtocol::Normal) {
-				if (!control->in_use()) {
-					_surface->write (_vpot->set (normalized_position, true, Pot::wrap));
-				}
-				do_parameter_display (GainAutomation, gain_coefficient);
-			} else {
-				if (!control->in_use()) {
-					_surface->write (_fader->set_position (normalized_position));
-				}
-				do_parameter_display (GainAutomation, gain_coefficient);
-			}
-
-			_last_gain_position_written = normalized_position;
-		}
+	if (!_route) {
+		return;
 	}
-}
 
-void
-Strip::notify_trim_changed (bool force_update)
-{
-	if (_route) {
+	boost::shared_ptr<AutomationControl> ac = _route->gain_control();
+	Control* control;
 
-		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 = i->second;
-
-		boost::shared_ptr<AutomationControl> ac = _route->trim_control();
-
-		float gain_coefficient = ac->get_value();
-		float normalized_position = ac->internal_to_interface (gain_coefficient);
-
-		if (force_update || normalized_position != _last_trim_position_written) {
-			if (control == _fader) {
-				if (!_fader->in_use()) {
-					_surface->write (_fader->set_position (normalized_position));
-					do_parameter_display (TrimAutomation, gain_coefficient);
-				}
-			} else if (control == _vpot) {
-				_surface->write (_vpot->set (normalized_position, true, Pot::dot));
-				do_parameter_display (TrimAutomation, gain_coefficient);
-			}
-			_last_trim_position_written = normalized_position;
-		}
+	if (!ac) {
+		/* doesn't seem possible but lets be safe */
+		return;
 	}
-}
-
-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);
+	/* track gain control could be on vpot or fader, depending in
+	 * flip mode.
+	 */
 
-		if (i == control_by_parameter.end()) {
-			return;
-		}
+	if (_vpot->control() == ac) {
+		control = _vpot;
+	} else if (_fader->control() == ac) {
+		control = _fader;
+	} else {
+		return;
+	}
 
-		control = i->second;
+	float gain_coefficient = ac->get_value();
+	float normalized_position = ac->internal_to_interface (gain_coefficient);
 
-		float normalized_position = _route->phase_control()->get_value();
+	if (force_update || normalized_position != _last_gain_position_written) {
 
-		if (control == _fader) {
-			if (!_fader->in_use()) {
+		if (!control->in_use()) {
+			if (control == _vpot) {
+				_surface->write (_vpot->set (normalized_position, true, Pot::wrap));
+			} else {
 				_surface->write (_fader->set_position (normalized_position));
-				do_parameter_display (PhaseAutomation, normalized_position);
 			}
-		} else if (control == _vpot) {
-			_surface->write (_vpot->set (normalized_position, true, Pot::wrap));
-			do_parameter_display (PhaseAutomation, normalized_position);
 		}
+
+		do_parameter_display (GainAutomation, gain_coefficient);
+		_last_gain_position_written = normalized_position;
 	}
 }
 
@@ -475,22 +396,16 @@ Strip::show_route_name ()
 
 	string fullname = string();
 	if (!_route) {
-		// make sure first three strips get cleared of view mode
-		if (_index > 2) {
-			return;
-		}
+		fullname = string();
 	} else {
 		fullname = _route->name();
 	}
-	string line1;
 
 	if (fullname.length() <= 6) {
-		line1 = fullname;
+		pending_display[0] = fullname;
 	} else {
-		line1 = PBD::short_version (fullname, 6);
+		pending_display[0] = PBD::short_version (fullname, 6);
 	}
-
-	pending_display[0] = line1;
 }
 
 void
@@ -504,7 +419,7 @@ Strip::notify_send_level_change (AutomationType type, uint32_t send_num, bool fo
 	}
 
 	if (_surface->mcp().subview_mode() != MackieControlProtocol::Sends) {
-		/* no longer in EQ subview mode */
+		/* no longer in Sends subview mode */
 		return;
 	}
 
@@ -515,9 +430,12 @@ Strip::notify_send_level_change (AutomationType type, uint32_t send_num, bool fo
 
 	if (control) {
 		float val = control->get_value();
-		do_parameter_display (type, control->internal_to_interface (val));
-		/* update pot/encoder */
-		_surface->write (_vpot->set (control->internal_to_interface (val), true, Pot::wrap));
+		do_parameter_display (type, val);
+
+		if (_vpot->control() == control) {
+			/* update pot/encoder */
+			_surface->write (_vpot->set (control->internal_to_interface (val), true, Pot::wrap));
+		}
 	}
 }
 
@@ -532,23 +450,44 @@ Strip::notify_trackview_change (AutomationType type, uint32_t send_num, bool for
 	}
 
 	if (_surface->mcp().subview_mode() != MackieControlProtocol::TrackView) {
-		/* no longer in EQ subview mode */
+		/* no longer in TrackViewsubview mode */
 		return;
 	}
 
 	boost::shared_ptr<AutomationControl> control;
+	boost::shared_ptr<Track> track = boost::dynamic_pointer_cast<Track> (r);
 
 	switch (type) {
 	case TrimAutomation:
 		control = r->trim_control();
 		break;
+	case SoloIsolateAutomation:
+		control = r->solo_isolate_control ();
+		break;
+	case SoloSafeAutomation:
+		control = r->solo_safe_control ();
+		break;
+	case MonitoringAutomation:
+		if (track) {
+			control = track->monitoring_control();
+		}
+		break;
+	case PhaseAutomation:
+		control = r->phase_control ();
+		break;
 	default:
 		break;
 	}
 
 	if (control) {
 		float val = control->get_value();
-		do_parameter_display (type, control->internal_to_interface (val));
+
+		/* Note: all of the displayed controllables require the display
+		 * of their *actual* ("internal") value, not the version mapped
+		 * into the normalized 0..1.0 ("interface") range.
+		 */
+
+		do_parameter_display (type, val);
 		/* update pot/encoder */
 		_surface->write (_vpot->set (control->internal_to_interface (val), true, Pot::wrap));
 	}
@@ -668,34 +607,24 @@ Strip::notify_panner_azi_changed (bool force_update)
 	boost::shared_ptr<AutomationControl> pan_control = _route->pan_azimuth_control ();
 
 	if (!pan_control) {
+		/* basically impossible, since we're here because that control
+		 *  changed, but sure, whatever.
+		 */
 		return;
 	}
 
-	Control* control = 0;
-	ControlParameterMap::iterator i = control_by_parameter.find (PanAzimuthAutomation);
-
-	if (i == control_by_parameter.end()) {
+	if (_vpot->control() != pan_control) {
 		return;
 	}
 
-	control = i->second;
-
 	double normalized_pos = pan_control->internal_to_interface (pan_control->get_value());
 	double internal_pos = pan_control->get_value();
 
 	if (force_update || (normalized_pos != _last_pan_azi_position_written)) {
 
-		if (control == _fader) {
-			if (!_fader->in_use()) {
-				_surface->write (_fader->set_position (normalized_pos));
-				/* show actual internal value to user */
-				do_parameter_display (PanAzimuthAutomation, internal_pos);
-			}
-		} else if (control == _vpot) {
-			_surface->write (_vpot->set (normalized_pos, true, Pot::dot));
-			/* show actual internal value to user */
-			do_parameter_display (PanAzimuthAutomation, internal_pos);
-		}
+		_surface->write (_vpot->set (normalized_pos, true, Pot::dot));
+		/* show actual internal value to user */
+		do_parameter_display (PanAzimuthAutomation, internal_pos);
 
 		_last_pan_azi_position_written = normalized_pos;
 	}
@@ -713,35 +642,22 @@ Strip::notify_panner_width_changed (bool force_update)
 	boost::shared_ptr<AutomationControl> pan_control = _route->pan_width_control ();
 
 	if (!pan_control) {
+		/* basically impossible, since we're here because that control
+		 *  changed, but sure, whatever.
+		 */
 		return;
 	}
 
-	Control* control = 0;
-	ControlParameterMap::iterator i = control_by_parameter.find (PanWidthAutomation);
-
-	if (i == control_by_parameter.end()) {
+	if (_vpot->control() != pan_control) {
 		return;
 	}
 
-	control = i->second;
-
 	double pos = pan_control->internal_to_interface (pan_control->get_value());
 
 	if (force_update || pos != _last_pan_width_position_written) {
 
-		if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) {
-
-			if (control == _fader) {
-				if (!control->in_use()) {
-					_surface->write (_fader->set_position (pos));
-					do_parameter_display (PanWidthAutomation, pos);
-				}
-			}
-
-		} else if (control == _vpot) {
-			_surface->write (_vpot->set (pos, true, Pot::spread));
-			do_parameter_display (PanWidthAutomation, pos);
-		}
+		_surface->write (_vpot->set (pos, true, Pot::spread));
+		do_parameter_display (PanWidthAutomation, pos);
 
 		_last_pan_width_position_written = pos;
 	}
@@ -763,15 +679,6 @@ Strip::select_event (Button&, ButtonState bs)
 			return;
 		}
 
-		if (ms & MackieControlProtocol::MODIFIER_SHIFT) {
-			/* reset to default */
-			boost::shared_ptr<AutomationControl> ac = _fader->control ();
-			if (ac) {
-				ac->set_value (ac->normal(), Controllable::NoGroup);
-			}
-			return;
-		}
-
 		DEBUG_TRACE (DEBUG::MackieControl, "add select button on press\n");
 		_surface->mcp().add_down_select_button (_surface->number(), _index);
 		_surface->mcp().select_range ();
@@ -800,14 +707,35 @@ Strip::vselect_event (Button&, ButtonState bs)
 				return;
 			}
 
+			Controllable::GroupControlDisposition gcd;
+			if (_surface->mcp().main_modifier_state() & MackieControlProtocol::MODIFIER_SHIFT) {
+				gcd = Controllable::InverseGroup;
+			} else {
+				gcd = Controllable::UseGroup;
+			}
+
 			if (control->toggled()) {
 				if (control->toggled()) {
-					control->set_value (!control->get_value(), Controllable::NoGroup);
+					control->set_value (!control->get_value(), gcd);
+				}
+
+			} else if (control->desc().enumeration || control->desc().integer_step) {
+
+				double val = control->get_value ();
+				if (val <= control->upper() - 1.0) {
+					control->set_value (val + 1.0, gcd);
+				} else {
+					control->set_value (control->lower(), gcd);
 				}
 			}
+
 		} else {
 
-			/* Send mode: press enables/disables the relevant send */
+			/* Send mode: press enables/disables the relevant
+			 * send, but the vpot is bound to the send-level so we
+			 * need to lookup the enable/disable control
+			 * explicitly.
+			 */
 
 			boost::shared_ptr<Route> r = _surface->mcp().subview_route();
 
@@ -818,7 +746,15 @@ Strip::vselect_event (Button&, ButtonState bs)
 
 				if (control) {
 					bool currently_enabled = (bool) control->get_value();
-					control->set_value (!currently_enabled, Controllable::UseGroup);
+					Controllable::GroupControlDisposition gcd;
+
+					if (_surface->mcp().main_modifier_state() & MackieControlProtocol::MODIFIER_SHIFT) {
+						gcd = Controllable::InverseGroup;
+					} else {
+						gcd = Controllable::UseGroup;
+					}
+
+					control->set_value (!currently_enabled, gcd);
 
 					if (currently_enabled) {
 						/* we just turned it off */
@@ -858,11 +794,21 @@ Strip::vselect_event (Button&, ButtonState bs)
 			if (_route) {
 				boost::shared_ptr<AutomationControl> ac = _route->master_send_enable_controllable ();
 				if (ac) {
+					Controllable::GroupControlDisposition gcd;
+
+					if (_surface->mcp().main_modifier_state() & MackieControlProtocol::MODIFIER_SHIFT) {
+						gcd = Controllable::InverseGroup;
+					} else {
+						gcd = Controllable::UseGroup;
+					}
+
 					bool enabled = ac->get_value();
-					ac->set_value (!enabled, Controllable::UseGroup);
+					ac->set_value (!enabled, gcd);
 				}
+			}
 #else
 			DEBUG_TRACE (DEBUG::MackieControl, "switching to next pot mode\n");
+			/* switch vpot to control next available parameter */
 			next_pot_mode ();
 #endif
 		}
@@ -945,7 +891,7 @@ Strip::handle_button (Button& button, ButtonState bs)
 				Controllable::GroupControlDisposition gcd;
 
 				if (_surface->mcp().main_modifier_state() & MackieControlProtocol::MODIFIER_SHIFT) {
-					gcd = Controllable::NoGroup;
+					gcd = Controllable::InverseGroup;
 				} else {
 					gcd = Controllable::UseGroup;
 				}
@@ -981,6 +927,23 @@ Strip::do_parameter_display (AutomationType type, float val)
 		}
 		break;
 
+	case BusSendLevel:
+		if (Profile->get_mixbus()) {  //Mixbus sends are already stored in dB
+			snprintf (buf, sizeof (buf), "%2.1f", val);
+			pending_display[1] = buf;
+			screen_hold = true;
+		} else {
+			if (val == 0.0) {
+				pending_display[1] = " -inf ";
+			} else {
+				float dB = accurate_coefficient_to_dB (val);
+				snprintf (buf, sizeof (buf), "%6.1f", dB);
+				pending_display[1] = buf;
+				screen_hold = true;
+			}
+		}
+		break;
+
 	case PanAzimuthAutomation:
 		if (Profile->get_mixbus()) {
 			snprintf (buf, sizeof (buf), "%2.1f", val);
@@ -1016,7 +979,7 @@ Strip::do_parameter_display (AutomationType type, float val)
 
 	case PhaseAutomation:
 		if (_route) {
-			if (_route->phase_control()->get_value() < 0.5) {
+			if (val < 0.5) {
 				pending_display[1] = "Normal";
 			} else {
 				pending_display[1] = "Invert";
@@ -1025,15 +988,6 @@ Strip::do_parameter_display (AutomationType type, float val)
 		}
 		break;
 
-	case BusSendLevel:
-		if (_route) {
-			float dB = accurate_coefficient_to_dB (val);
-			snprintf (buf, sizeof (buf), "%6.1f", dB);
-			pending_display[1] = buf;
-			screen_hold = true;
-		}
-		break;
-
 	case EQGain:
 	case EQFrequency:
 	case EQQ:
@@ -1060,6 +1014,30 @@ Strip::do_parameter_display (AutomationType type, float val)
 			pending_display[1] = _surface->mcp().subview_route()->comp_mode_name (val);
 		}
 		break;
+	case SoloSafeAutomation:
+	case SoloIsolateAutomation:
+		if (val >= 0.5) {
+			pending_display[1] = "on";
+		} else {
+			pending_display[1] = "off";
+		}
+		break;
+	case MonitoringAutomation:
+		switch (MonitorChoice ((int) val)) {
+		case MonitorAuto:
+			pending_display[1] = "auto";
+			break;
+		case MonitorInput:
+			pending_display[1] = "input";
+			break;
+		case MonitorDisk:
+			pending_display[1] = "disk";
+			break;
+		case MonitorCue: /* XXX not implemented as of jan 2016 */
+			pending_display[1] = "cue";
+			break;
+		}
+		break;
 	default:
 		break;
 	}
@@ -1094,7 +1072,7 @@ Strip::handle_fader (Fader& fader, float position)
 	Controllable::GroupControlDisposition gcd = Controllable::UseGroup;
 
 	if (_surface->mcp().main_modifier_state() & MackieControlProtocol::MODIFIER_SHIFT) {
-		gcd = Controllable::NoGroup;
+		gcd = Controllable::InverseGroup;
 	}
 
 	fader.set_value (position, gcd);
@@ -1123,12 +1101,53 @@ Strip::handle_pot (Pot& pot, float delta)
 	if (!ac) {
 		return;
 	}
-	double p = pot.get_value ();
-	p += delta;
-	// 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);
+
+	Controllable::GroupControlDisposition gcd;
+
+	if (_surface->mcp().main_modifier_state() & MackieControlProtocol::MODIFIER_SHIFT) {
+		gcd = Controllable::InverseGroup;
+	} else {
+		gcd = Controllable::UseGroup;
+	}
+
+	if (ac->toggled()) {
+
+		/* make it like a single-step, directional switch */
+
+		if (delta > 0) {
+			ac->set_value (1.0, gcd);
+		} else {
+			ac->set_value (0.0, gcd);
+		}
+
+	} else if (ac->desc().enumeration || ac->desc().integer_step) {
+
+		/* use Controllable::get_value() to avoid the
+		 * "scaling-to-interface" that takes place in
+		 * Control::get_value() via the pot member.
+		 *
+		 * an enumeration with 4 values will have interface values of
+		 * 0.0, 0.25, 0.5 and 0.75 or some similar oddness. Lets not
+		 * deal with that.
+		 */
+
+		if (delta > 0) {
+			ac->set_value (min (ac->upper(), ac->get_value() + 1.0), gcd);
+		} else {
+			ac->set_value (max (ac->lower(), ac->get_value() - 1.0), gcd);
+		}
+
+	} else {
+
+		double p = ac->get_interface();
+
+		p += delta;
+
+		p = max (0.0, p);
+		p = min (1.0, p);
+
+		ac->set_value ( ac->interface_to_internal(p), gcd);
+	}
 }
 
 void
@@ -1198,13 +1217,6 @@ Strip::update_automation ()
 			notify_panner_width_changed (false);
 		}
 	}
-
-	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);
-		}
-	}
 }
 
 void
@@ -1219,7 +1231,7 @@ Strip::update_meter ()
 	}
 
 	if (_meter && _transport_is_rolling && _metering_active) {
-		float dB = const_cast<PeakMeter&> (_route->peak_meter()).meter_level (0, MeterMCP);
+		float dB = _route->peak_meter()->meter_level (0, MeterMCP);
 		_meter->send_update (*_surface, dB);
 		return;
 	}
@@ -1315,55 +1327,64 @@ Strip::gui_selection_changed (const ARDOUR::StrongRouteNotificationList& rl)
 string
 Strip::vpot_mode_string ()
 {
+	if (_surface->mcp().subview_mode() != MackieControlProtocol::None) {
+		return string();
+	}
+
 	boost::shared_ptr<AutomationControl> ac = _vpot->control();
+
 	if (!ac) {
 		return string();
 	}
 
-	if (control_by_parameter.find (GainAutomation)->second == _vpot) {
-		return "Fader";
-	} else if (control_by_parameter.find (TrimAutomation)->second == _vpot) {
-		return "Trim";
-	} 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 (PanAzimuthAutomation)->second == _vpot) {
+	switch (ac->desc().type) {
+	case PanAzimuthAutomation:
 		return "Pan";
-	} else if (control_by_parameter.find (PanWidthAutomation)->second == _vpot) {
+	case PanWidthAutomation:
 		return "Width";
-	} else if (control_by_parameter.find (PanElevationAutomation)->second == _vpot) {
+	case PanElevationAutomation:
 		return "Elev";
-	} else if (control_by_parameter.find (PanFrontBackAutomation)->second == _vpot) {
+	case PanFrontBackAutomation:
 		return "F/Rear";
-	} else if (control_by_parameter.find (PanLFEAutomation)->second == _vpot) {
+	case PanLFEAutomation:
 		return "LFE";
-	}
-
-	if (_surface->mcp().subview_mode() != MackieControlProtocol::None) {
-		return string();
+	default:
+		break;
 	}
 
 	return "???";
 }
 
- void
-Strip::potmode_changed (bool notify)
+void
+Strip::flip_mode_changed ()
 {
-	if (!_route) {
-		return;
-	}
+	if (_surface->mcp().subview_mode() == MackieControlProtocol::Sends) {
 
-	// WIP
-	int pm = _surface->mcp().pot_mode();
-	switch (pm) {
-	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;
-	}
+		boost::shared_ptr<AutomationControl> pot_control = _vpot->control();
+		boost::shared_ptr<AutomationControl> fader_control = _fader->control();
 
-	if (notify) {
-		notify_all ();
+		if (pot_control && fader_control) {
+			_vpot->set_control (fader_control);
+			_fader->set_control (pot_control);
+		}
+
+		if (_surface->mcp().flip_mode() == MackieControlProtocol::Normal) {
+			do_parameter_display (GainAutomation, fader_control->get_value());
+		} else {
+			do_parameter_display (BusSendLevel, fader_control->get_value());
+		}
+
+		/* update fader */
+
+		_surface->write (_fader->set_position (pot_control->internal_to_interface (pot_control->get_value ())));
+
+		/* update pot */
+
+		_surface->write (_vpot->set (fader_control->internal_to_interface (fader_control->get_value()), true, Pot::wrap));
+
+
+	} else {
+		/* do nothing */
 	}
 }
 
@@ -1417,32 +1438,33 @@ Strip::next_pot_mode ()
 	}
 
 
-	if (_surface->mcp().pot_mode() == MackieControlProtocol::Pan) {
+	if (_surface->mcp().subview_mode() != MackieControlProtocol::None) {
+		return;
+	}
 
-		if (possible_pot_parameters.empty() || (possible_pot_parameters.size() == 1 && possible_pot_parameters.front() == ac->parameter().type())) {
-			return;
-		}
+	if (possible_pot_parameters.empty() || (possible_pot_parameters.size() == 1 && possible_pot_parameters.front() == ac->parameter().type())) {
+		return;
+	}
 
-		for (i = possible_pot_parameters.begin(); i != possible_pot_parameters.end(); ++i) {
-			if ((*i) == ac->parameter().type()) {
-				break;
-			}
+	for (i = possible_pot_parameters.begin(); i != possible_pot_parameters.end(); ++i) {
+		if ((*i) == ac->parameter().type()) {
+			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;
-		}
+	/* 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 = possible_pot_parameters.begin();
-		}
+	if (i != possible_pot_parameters.end()) {
+		++i;
+	}
 
-		set_vpot_parameter (*i);
+	if (i == possible_pot_parameters.end()) {
+		i = possible_pot_parameters.begin();
 	}
+
+	set_vpot_parameter (*i);
 }
 
 void
@@ -1454,9 +1476,13 @@ Strip::subview_mode_changed ()
 
 	switch (_surface->mcp().subview_mode()) {
 	case MackieControlProtocol::None:
-		set_vpot_parameter (vpot_parameter);
+		set_vpot_parameter (_pan_mode);
 		/* need to show strip name again */
 		show_route_name ();
+		if (!_route) {
+			_surface->write (_vpot->set (0, true, Pot::wrap));
+			_surface->write (_fader->set_position (0.0));
+		}
 		notify_metering_state_changed ();
 		eq_band = -1;
 		break;
@@ -1737,7 +1763,7 @@ Strip::setup_sends_vpot (boost::shared_ptr<Route> r)
 	pc->Changed.connect (subview_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_send_level_change, this, BusSendLevel, global_pos, false), ui_context());
 	_vpot->set_control (pc);
 
-	pending_display[0] = r->send_name (global_pos);
+	pending_display[0] = PBD::short_version (r->send_name (global_pos), 6);
 
 	notify_send_level_change (BusSendLevel, global_pos, true);
 }
@@ -1758,24 +1784,51 @@ Strip::setup_trackview_vpot (boost::shared_ptr<Route> r)
 	}
 
 	boost::shared_ptr<AutomationControl> pc;
+	boost::shared_ptr<Track> track = boost::dynamic_pointer_cast<Track> (r);
 	string label;
 
 	switch (global_pos) {
 	case 0:
 		pc = r->trim_control ();
-		label = "Trim";
+		if (pc) {
+			pc->Changed.connect (subview_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_trackview_change, this, TrimAutomation, global_pos, false), ui_context());
+			pending_display[0] = "Trim";
+			notify_trackview_change (TrimAutomation, global_pos, true);
+		}
 		break;
 	case 1:
-		// pc = r->trim_control ();
+		if (track) {
+			pc = track->monitoring_control();
+			if (pc) {
+				pc->Changed.connect (subview_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_trackview_change, this, MonitoringAutomation, global_pos, false), ui_context());
+				pending_display[0] = "Mon";
+				notify_trackview_change (MonitoringAutomation, global_pos, true);
+			}
+		}
 		break;
 	case 2:
-		// pc = r->trim_control ();
+		pc = r->solo_isolate_control ();
+		if (pc) {
+			pc->Changed.connect (subview_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_trackview_change, this, SoloIsolateAutomation, global_pos, false), ui_context());
+			notify_trackview_change (SoloIsolateAutomation, global_pos, true);
+			pending_display[0] = "S-Iso";
+		}
 		break;
 	case 3:
-		// pc = r->trim_control ();
+		pc = r->solo_safe_control ();
+		if (pc) {
+			pc->Changed.connect (subview_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_trackview_change, this, SoloSafeAutomation, global_pos, false), ui_context());
+			notify_trackview_change (SoloSafeAutomation, global_pos, true);
+			pending_display[0] = "S-Safe";
+		}
 		break;
 	case 4:
-		//pc = r->trim_control ();
+		pc = r->phase_control();
+		if (pc) {
+			pc->Changed.connect (subview_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_trackview_change, this, PhaseAutomation, global_pos, false), ui_context());
+			notify_trackview_change (PhaseAutomation, global_pos, true);
+			pending_display[0] = "Phase";
+		}
 		break;
 	case 5:
 		// pc = r->trim_control ();
@@ -1794,20 +1847,13 @@ Strip::setup_trackview_vpot (boost::shared_ptr<Route> r)
 		return;
 	}
 
-	pc->Changed.connect (subview_connections, MISSING_INVALIDATOR, boost::bind (&Strip::notify_trackview_change, this, TrimAutomation, global_pos, false), ui_context());
 	_vpot->set_control (pc);
-
-	pending_display[0] = label;
-
-	notify_trackview_change (TrimAutomation, global_pos, true);
 }
 
 void
 Strip::set_vpot_parameter (AutomationType p)
 {
 	if (!_route || (p == NullAutomation)) {
-		control_by_parameter[vpot_parameter] = 0;
-		vpot_parameter = NullAutomation;
 		_vpot->set_control (boost::shared_ptr<AutomationControl>());
 		pending_display[1] = string();
 		return;
@@ -1819,138 +1865,26 @@ Strip::set_vpot_parameter (AutomationType p)
 
 	reset_saved_values ();
 
-	/* 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) {
 	case PanAzimuthAutomation:
-		if ((pan_control = _route->pan_azimuth_control ())) {
-			if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) {
-				_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>());
-					control_by_parameter[PanAzimuthAutomation] = 0;
-				}
-			} else {
-				/* gain to fader, pan azi to vpot */
-				vpot_parameter = PanAzimuthAutomation;
-				_fader->set_control (_route->gain_control());
-				control_by_parameter[GainAutomation] = _fader;
-				_vpot->set_control (pan_control);
-				control_by_parameter[PanAzimuthAutomation] = _vpot;
-			}
-		} else {
-			_vpot->set_control (boost::shared_ptr<AutomationControl>());
-			control_by_parameter[PanAzimuthAutomation] = 0;
-		}
+		pan_control = _route->pan_azimuth_control ();
 		break;
-
 	case PanWidthAutomation:
-		if ((pan_control = _route->pan_width_control ())) {
-			if (_surface->mcp().flip_mode() != MackieControlProtocol::Normal) {
-				_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>());
-					control_by_parameter[PanWidthAutomation] = 0;
-				}
-			} else {
-				/* gain to fader, pan width to vpot */
-				vpot_parameter = PanWidthAutomation;
-				_fader->set_control (_route->gain_control());
-				control_by_parameter[GainAutomation] = _fader;
-				_vpot->set_control (pan_control);
-				control_by_parameter[PanWidthAutomation] = _vpot;
-			}
-		} else {
-			_vpot->set_control (boost::shared_ptr<AutomationControl>());
-			control_by_parameter[PanWidthAutomation] = 0;
-		}
+		pan_control = _route->pan_width_control ();
 		break;
-
 	case PanElevationAutomation:
 		break;
 	case PanFrontBackAutomation:
 		break;
 	case PanLFEAutomation:
 		break;
-	case TrimAutomation:
-		_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;
 	default:
-		DEBUG_TRACE (DEBUG::MackieControl, string_compose ("vpot mode %1 not known.\n", p));
-		break;
+		return;
+	}
 
+	if (pan_control) {
+		_pan_mode = p;
+		_vpot->set_control (pan_control);
 	}
 
 	pending_display[1] = vpot_mode_string ();