universal change in the design of the way Route/Track controls are designed and used. The controls now own their own state, rather than proxy for state in their owners.

Massive changes all over the code to accomodate this. Many things are not finished. Consider this a backup safety commit

15 files changed, 240 insertions, 371 deletions

diff --git a/libs/ardour/ardour/automation_control.h b/libs/ardour/ardour/automation_control.h
index 455e8891c1..d84f0a091f 100644
--- a/libs/ardour/ardour/automation_control.h
+++ b/libs/ardour/ardour/automation_control.h
@@ -41,7 +41,7 @@ namespace ARDOUR {
 
 class Session;
 class Automatable;
-
+class ControlGroup;
 
 /** A PBD::Controllable with associated automation data (AutomationList)
  */
@@ -50,7 +50,7 @@ class LIBARDOUR_API AutomationControl
 	, public Evoral::Control
 	, public boost::enable_shared_from_this<AutomationControl>
 {
-public:
+    public:
 	AutomationControl(ARDOUR::Session&,
 	                  const Evoral::Parameter&                  parameter,
 	                  const ParameterDescriptor&                desc,
@@ -87,8 +87,6 @@ public:
 	void stop_touch(bool mark, double when);
 
 	/* inherited from PBD::Controllable.
-	 * Derived classes MUST call ::writable() to verify
-	 * that writing to the parameter is legal at that time.
 	 */
 	double get_value () const;
 	/* inherited from PBD::Controllable.
@@ -99,10 +97,11 @@ public:
 	/* automation related value setting */
 	virtual bool writable () const;
 	/* Call to ::set_value() with no test for writable() because
-	 * this is only used by automation playback. We would like
-	 * to make it pure virtual
+	 * this is only used by automation playback.
 	 */
-	virtual void set_value_unchecked (double val) {}
+	void set_value_unchecked (double val) {
+		actually_set_value (val, PBD::Controllable::NoGroup);
+	}
 
 	double lower()   const { return _desc.lower; }
 	double upper()   const { return _desc.upper; }
@@ -117,6 +116,37 @@ public:
 	const ARDOUR::Session& session() const { return _session; }
 	void commit_transaction (bool did_write);
 
+	void set_group (boost::shared_ptr<ControlGroup>);
+
+  protected:
+	ARDOUR::Session& _session;
+	boost::shared_ptr<ControlGroup> _group;
+
+	const ParameterDescriptor _desc;
+
+	bool check_rt (double val, Controllable::GroupControlDisposition gcd);
+
+	/* derived classes may reimplement this, but should either
+	   call this explicitly inside their version OR make sure that the
+	   Controllable::Changed signal is emitted when necessary.
+	*/
+
+	virtual void actually_set_value (double value, PBD::Controllable::GroupControlDisposition);
+};
+
+class SlavableAutomationControl : public AutomationControl
+{
+    public:
+	SlavableAutomationControl(ARDOUR::Session&,
+	                  const Evoral::Parameter&                  parameter,
+	                  const ParameterDescriptor&                desc,
+	                  boost::shared_ptr<ARDOUR::AutomationList> l=boost::shared_ptr<ARDOUR::AutomationList>(),
+	                  const std::string&                        name="");
+
+	~SlavableAutomationControl ();
+
+	double get_value () const;
+
 	void add_master (boost::shared_ptr<AutomationControl>);
 	void remove_master (boost::shared_ptr<AutomationControl>);
 	void clear_masters ();
@@ -126,11 +156,7 @@ public:
 
 	PBD::Signal0<void> MasterStatusChange;
 
-  protected:
-	ARDOUR::Session& _session;
-
-	const ParameterDescriptor _desc;
-
+    protected:
 
 	class MasterRecord {
           public:
@@ -155,12 +181,12 @@ public:
 	typedef std::map<PBD::ID,MasterRecord> Masters;
 	Masters _masters;
 	PBD::ScopedConnectionList masters_connections;
-
 	virtual void master_changed (bool from_self, GroupControlDisposition gcd);
 	void master_going_away (boost::weak_ptr<AutomationControl>);
 	virtual void recompute_masters_ratios (double val) { /* do nothing by default */}
 	virtual double get_masters_value_locked () const;
 	double get_value_locked() const;
+
 };
 
 
diff --git a/libs/ardour/ardour/gain_control.h b/libs/ardour/ardour/gain_control.h
index 4ec538e698..f68ec00452 100644
--- a/libs/ardour/ardour/gain_control.h
+++ b/libs/ardour/ardour/gain_control.h
@@ -34,14 +34,11 @@ namespace ARDOUR {
 
 class Session;
 
-class LIBARDOUR_API GainControl : public AutomationControl {
+class LIBARDOUR_API GainControl : public SlavableAutomationControl {
   public:
 	GainControl (Session& session, const Evoral::Parameter &param,
 	             boost::shared_ptr<AutomationList> al = boost::shared_ptr<AutomationList>());
 
-	void set_value (double val, PBD::Controllable::GroupControlDisposition group_override);
-	void set_value_unchecked (double);
-
 	double internal_to_interface (double) const;
 	double interface_to_internal (double) const;
 	double internal_to_user (double) const;
@@ -54,6 +51,8 @@ class LIBARDOUR_API GainControl : public AutomationControl {
 	int set_state (XMLNode const&, int);
 	XMLNode& get_state();
 
+	void inc_gain (gain_t);
+
   private:
 	std::string masters_string;
 	PBD::ScopedConnection vca_loaded_connection;
@@ -61,7 +60,7 @@ class LIBARDOUR_API GainControl : public AutomationControl {
 	void vcas_loaded();
 	void recompute_masters_ratios (double val);
 
-	void _set_value (double val, PBD::Controllable::GroupControlDisposition group_override);
+	void actually_set_value (double val, PBD::Controllable::GroupControlDisposition group_override);
 };
 
 } /* namespace */
diff --git a/libs/ardour/ardour/midi_track.h b/libs/ardour/ardour/midi_track.h
index ed13832360..69f4981047 100644
--- a/libs/ardour/ardour/midi_track.h
+++ b/libs/ardour/ardour/midi_track.h
@@ -50,8 +50,9 @@ public:
 
 	boost::shared_ptr<Diskstream> create_diskstream ();
 	void set_diskstream (boost::shared_ptr<Diskstream>);
-	void set_record_enabled (bool yn, PBD::Controllable::GroupControlDisposition);
-	void set_record_safe (bool yn, PBD::Controllable::GroupControlDisposition);
+
+	bool can_be_record_enabled ();
+	bool can_be_record_safe ();
 
 	DataType data_type () const {
 		return DataType::MIDI;
@@ -89,14 +90,12 @@ public:
 			, _route (route)
 		{}
 
-		void set_value (double val, PBD::Controllable::GroupControlDisposition group_override);
-		void set_value_unchecked (double);
 		bool writable() const { return true; }
 
 		MidiTrack* _route;
 
 	private:
-		void _set_value (double val, PBD::Controllable::GroupControlDisposition group_override);
+		void actually_set_value (double val, PBD::Controllable::GroupControlDisposition group_override);
 	};
 
 	virtual void set_parameter_automation_state (Evoral::Parameter param, AutoState);
@@ -133,7 +132,6 @@ public:
 	PBD::Signal1<void, boost::weak_ptr<MidiSource> > DataRecorded;
 	boost::shared_ptr<MidiBuffer> get_gui_feed_buffer () const;
 
-	void set_monitoring (MonitorChoice, PBD::Controllable::GroupControlDisposition);
 	MonitorState monitoring_state () const;
 
 	void set_input_active (bool);
@@ -144,6 +142,7 @@ protected:
 	XMLNode& state (bool full);
 
 	void act_on_mute ();
+	void monitoring_changed (bool, PBD::Controllable::GroupControlDisposition);
 
 private:
 	MidiRingBuffer<framepos_t> _immediate_events;
diff --git a/libs/ardour/ardour/mute_master.h b/libs/ardour/ardour/mute_master.h
index 14597cb56b..d147a58771 100644
--- a/libs/ardour/ardour/mute_master.h
+++ b/libs/ardour/ardour/mute_master.h
@@ -20,12 +20,15 @@
 #ifndef __ardour_mute_master_h__
 #define __ardour_mute_master_h__
 
-#include "evoral/Parameter.hpp"
+#include <string>
+
 #include "pbd/signals.h"
 #include "pbd/stateful.h"
-#include <string>
+
+#include "evoral/Parameter.hpp"
 
 #include "ardour/session_handle.h"
+#include "ardour/types.h"
 
 namespace ARDOUR {
 
@@ -73,6 +76,7 @@ class LIBARDOUR_API MuteMaster : public SessionHandleRef, public PBD::Stateful
 
 	XMLNode& get_state();
 	int set_state(const XMLNode&, int version);
+	static const std::string xml_node_name;
 
   private:
 	MutePoint _mute_point;
diff --git a/libs/ardour/ardour/pan_controllable.h b/libs/ardour/ardour/pan_controllable.h
index 85a4efe2fc..26f0707ff7 100644
--- a/libs/ardour/ardour/pan_controllable.h
+++ b/libs/ardour/ardour/pan_controllable.h
@@ -47,12 +47,10 @@ class LIBARDOUR_API PanControllable : public AutomationControl
 	{}
 
 	double lower () const;
-	void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
-	void set_value_unchecked (double);
 
   private:
 	Pannable* owner;
-	void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
+	void actually_set_value (double, PBD::Controllable::GroupControlDisposition group_override);
 };
 
 } // namespace
diff --git a/libs/ardour/ardour/plugin_insert.h b/libs/ardour/ardour/plugin_insert.h
index 4b5f38964a..70bbd76a71 100644
--- a/libs/ardour/ardour/plugin_insert.h
+++ b/libs/ardour/ardour/plugin_insert.h
@@ -185,15 +185,13 @@ class LIBARDOUR_API PluginInsert : public Processor
 		               const ParameterDescriptor&        desc,
 		               boost::shared_ptr<AutomationList> list=boost::shared_ptr<AutomationList>());
 
-		void set_value (double val, PBD::Controllable::GroupControlDisposition group_override);
-		void set_value_unchecked (double);
 		double get_value (void) const;
 		void catch_up_with_external_value (double val);
 		XMLNode& get_state();
 
 	private:
 		PluginInsert* _plugin;
-		void _set_value (double val, PBD::Controllable::GroupControlDisposition group_override);
+		void actually_set_value (double val, PBD::Controllable::GroupControlDisposition group_override);
 	};
 
 	/** A control that manipulates a plugin property (message). */
@@ -204,10 +202,10 @@ class LIBARDOUR_API PluginInsert : public Processor
 		                       const ParameterDescriptor&        desc,
 		                       boost::shared_ptr<AutomationList> list=boost::shared_ptr<AutomationList>());
 
-		void set_value (double val, PBD::Controllable::GroupControlDisposition group_override);
-		void set_value_unchecked (double);
 		double get_value (void) const;
 		XMLNode& get_state();
+        protected:
+		void actually_set_value (double value, PBD::Controllable::GroupControlDisposition);
 
 	private:
 		PluginInsert* _plugin;
diff --git a/libs/ardour/ardour/route.h b/libs/ardour/ardour/route.h
index 9abe56afcb..6c0380963d 100644
--- a/libs/ardour/ardour/route.h
+++ b/libs/ardour/ardour/route.h
@@ -28,7 +28,6 @@
 
 #include <boost/shared_ptr.hpp>
 #include <boost/weak_ptr.hpp>
-#include <boost/dynamic_bitset.hpp>
 #include <boost/enable_shared_from_this.hpp>
 
 #include <glibmm/threads.h>
@@ -46,12 +45,18 @@
 #include "ardour/io_vector.h"
 #include "ardour/libardour_visibility.h"
 #include "ardour/types.h"
+#include "ardour/monitorable.h"
+#include "ardour/muteable.h"
 #include "ardour/mute_master.h"
+#include "ardour/mute_control.h"
 #include "ardour/route_group_member.h"
 #include "ardour/stripable.h"
 #include "ardour/graphnode.h"
 #include "ardour/automatable.h"
 #include "ardour/unknown_processor.h"
+#include "ardour/soloable.h"
+#include "ardour/solo_control.h"
+#include "ardour/solo_safe_control.h"
 
 class RoutePinWindowProxy;
 
@@ -74,8 +79,18 @@ class Pannable;
 class CapturingProcessor;
 class InternalSend;
 class VCA;
-
-class LIBARDOUR_API Route : public Stripable, public Automatable, public RouteGroupMember, public GraphNode, public boost::enable_shared_from_this<Route>
+class SoloIsolateControl;
+class PhaseControl;
+class MonitorControl;
+
+class LIBARDOUR_API Route : public Stripable,
+                            public Soloable,
+                            public Muteable,
+                            public Monitorable,
+                            public Automatable,
+                            public RouteGroupMember,
+                            public GraphNode,
+                            public boost::enable_shared_from_this<Route>
 {
 public:
 
@@ -119,7 +134,7 @@ public:
 	bool is_master() const { return _flags & MasterOut; }
 	bool is_monitor() const { return _flags & MonitorOut; }
 
-	virtual MonitorState monitoring_state () const;
+	MonitorState monitoring_state () const;
 	virtual MeterState metering_state () const;
 
 	/* these are the core of the API of a Route. see the protected sections as well */
@@ -135,10 +150,6 @@ public:
 
 	virtual bool can_record() { return false; }
 
-	virtual void set_record_enabled (bool /*yn*/, PBD::Controllable::GroupControlDisposition) {}
-	virtual bool record_enabled() const { return false; }
-	virtual void set_record_safe (bool /*yn*/, PBD::Controllable::GroupControlDisposition) {}
-	virtual bool record_safe () const {return false; }
 	virtual void nonrealtime_handle_transport_stopped (bool abort, bool did_locate, bool flush_processors);
 	virtual void realtime_handle_transport_stopped () {}
 	virtual void realtime_locate () {}
@@ -149,47 +160,31 @@ public:
 
 	void shift (framepos_t, framecnt_t);
 
-	void set_gain (gain_t val, PBD::Controllable::GroupControlDisposition);
-	void inc_gain (gain_t delta);
-
 	void set_trim (gain_t val, PBD::Controllable::GroupControlDisposition);
 
-	void set_mute_points (MuteMaster::MutePoint);
-	MuteMaster::MutePoint mute_points () const;
-
-	bool muted () const;
-	void set_mute (bool yn, PBD::Controllable::GroupControlDisposition);
-
-	bool muted_by_others_soloing () const;
-	bool muted_by_others () const;
-
 	/* controls use set_solo() to modify this route's solo state
 	 */
 
-	void set_solo (bool yn, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
-	bool soloed () const { return self_soloed () || soloed_by_others (); }
 	void clear_all_solo_state ();
 
-	bool soloed_by_others () const { return _soloed_by_others_upstream||_soloed_by_others_downstream; }
-	bool soloed_by_others_upstream () const { return _soloed_by_others_upstream; }
-	bool soloed_by_others_downstream () const { return _soloed_by_others_downstream; }
-	bool self_soloed () const { return _self_solo; }
-
-	void set_solo_isolated (bool yn, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
-	bool solo_isolated() const;
+	bool soloed_by_others () const { return _solo_control->soloed_by_others(); }
+	bool soloed_by_others_upstream () const { return _solo_control->soloed_by_others_upstream(); }
+	bool soloed_by_others_downstream () const { return _solo_control->soloed_by_others_downstream(); }
+	bool self_soloed () const { return _solo_control->self_soloed(); }
+	bool soloed () const { return self_soloed () || soloed_by_others (); }
 
-	void set_solo_safe (bool yn, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
-	bool solo_safe() const;
+	void push_solo_upstream (int32_t delta);
+	void push_solo_isolate_upstream (int32_t delta);
+	bool can_solo () const {
+		return !(is_master() || is_monitor() || is_auditioner());
+	}
+	bool is_safe () const {
+		return _solo_safe_control->get_value();
+	}
 
-	void set_listen (bool yn, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
 	bool listening_via_monitor () const;
 	void enable_monitor_send ();
 
-	void set_phase_invert (uint32_t, bool yn);
-	void set_phase_invert (boost::dynamic_bitset<>);
-	bool phase_invert (uint32_t) const;
-	boost::dynamic_bitset<> phase_invert () const;
-
 	void set_denormal_protection (bool yn);
 	bool denormal_protection() const;
 
@@ -353,7 +348,6 @@ public:
 	PBD::Signal0<void>       active_changed;
 	PBD::Signal0<void>       denormal_protection_changed;
 	PBD::Signal0<void>       comment_changed;
-	PBD::Signal0<void>       mute_points_changed;
 
 	/** track numbers - assigned by session
 	 * nubers > 0 indicate tracks (audio+midi)
@@ -456,185 +450,32 @@ public:
 
 	boost::shared_ptr<AutomationControl> get_control (const Evoral::Parameter& param);
 
-	class RouteAutomationControl : public AutomationControl {
-	public:
-		RouteAutomationControl (const std::string& name,
-		                        AutomationType atype,
-		                        boost::shared_ptr<AutomationList> alist,
-		                        boost::shared_ptr<Route> route);
-	protected:
-		friend class Route;
-
-		void route_set_value (double val) {
-			AutomationControl::set_value (val, Controllable::NoGroup);
-		}
-
-		boost::weak_ptr<Route> _route;
-	};
-
-	class BooleanRouteAutomationControl : public RouteAutomationControl {
-	public:
-		BooleanRouteAutomationControl (const std::string& name,
-		                               AutomationType atype,
-		                               boost::shared_ptr<AutomationList> alist,
-		                               boost::shared_ptr<Route> route)
-			: RouteAutomationControl (name, atype, alist, route) {}
-	protected:
-		double get_masters_value_locked() const;
-
-	};
-
-	class GainControllable : public GainControl  {
-	public:
-		GainControllable (Session& session,
-		                  AutomationType type,
-		                  boost::shared_ptr<Route> route);
-
-		void set_value (double val, PBD::Controllable::GroupControlDisposition group_override) {
-			boost::shared_ptr<Route> r = _route.lock();
-			if (r) {
-				/* Route must mediate group control */
-				r->set_control ((AutomationType) parameter().type(), val, group_override);
-			}
-		}
-
-	protected:
-		friend class Route;
-
-		void route_set_value (double val) {
-			GainControl::set_value (val, Controllable::NoGroup);
-		}
-
-		boost::weak_ptr<Route> _route;
-	};
-
-	class SoloControllable : public BooleanRouteAutomationControl {
-	    public:
-		SoloControllable (std::string name, boost::shared_ptr<Route>);
-		void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
-		void set_value_unchecked (double);
-		double get_value () const;
-
-		/* Export additional API so that objects that only get access
-		 * to a Controllable/AutomationControl can do more fine-grained
-		 * operations with respect to solo. Obviously, they would need
-		 * to dynamic_cast<Route::SoloControllable> first.
-		 *
-		 * Solo state is not representable by a single scalar value,
-		 * so this AutomationControl maps set_value() and get_value()
-		 * to r->set_self_solo() and r->soloed() respectively. This
-		 * means that the Controllable is technically asymmetric. It is
-		 * possible to call ::set_value (0.0) to disable (self)solo,
-		 * and then call ::get_value() and get a return of 1.0 because
-		 * the Route owner is soloed by upstream/downstream.
-		 */
-
-		void set_self_solo (bool yn) {
-			boost::shared_ptr<Route> r(_route.lock()); if (r) r->set_self_solo (yn);
-		}
-		void mod_solo_by_others_upstream (int32_t delta) {
-			boost::shared_ptr<Route> r(_route.lock()); if (r) r->mod_solo_by_others_upstream (delta);
-		}
-		void mod_solo_by_others_downstream (int32_t delta) {
-			boost::shared_ptr<Route> r(_route.lock()); if (r) r->mod_solo_by_others_downstream (delta);
-		}
-		bool soloed_by_others () const {
-			boost::shared_ptr<Route> r(_route.lock()); if (r) return r->soloed_by_others(); else return false;
-		}
-		bool soloed_by_others_upstream () const {
-			boost::shared_ptr<Route> r(_route.lock()); if (r) return r->soloed_by_others_upstream(); else return false;
-		}
-		bool soloed_by_others_downstream () const {
-			boost::shared_ptr<Route> r(_route.lock()); if (r) return r->soloed_by_others_downstream(); else return false;
-		}
-		bool self_soloed () const {
-			boost::shared_ptr<Route> r(_route.lock()); if (r) return r->self_soloed(); else return false;
-		}
-
-	    protected:
-		void master_changed (bool, PBD::Controllable::GroupControlDisposition);
-
-	    private:
-		void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
-	};
-
-	struct MuteControllable : public BooleanRouteAutomationControl {
-	    public:
-		MuteControllable (std::string name, boost::shared_ptr<Route>);
-		void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
-		void set_value_unchecked (double);
-		double get_value () const;
-
-		/* Pretend to change value, but do not affect actual route mute. */
-		void set_superficial_value(bool muted);
-	    protected:
-		void master_changed (bool, PBD::Controllable::GroupControlDisposition);
-
-	    private:
-		boost::weak_ptr<Route> _route;
-		void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
-	};
-
-	class LIBARDOUR_API PhaseControllable : public BooleanRouteAutomationControl {
-	public:
-		PhaseControllable (std::string name, boost::shared_ptr<Route>);
-		void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
-		/* currently no automation, so no need for set_value_unchecked() */
-		void set_channel (uint32_t);
-		double get_value () const;
-		uint32_t channel() const;
-	private:
-		uint32_t _current_phase;
-		void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
-	};
-
-	class LIBARDOUR_API SoloIsolateControllable : public BooleanRouteAutomationControl {
-	public:
-		SoloIsolateControllable (std::string name, boost::shared_ptr<Route>);
-		void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
-		/* currently no automation, so no need for set_value_unchecked() */
-		double get_value () const;
-	private:
-		void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
-	};
-
-	class LIBARDOUR_API SoloSafeControllable : public BooleanRouteAutomationControl {
-	public:
-		SoloSafeControllable (std::string name, boost::shared_ptr<Route>);
-		void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
-		/* currently no automation, so no need for set_value_unchecked() */
-		double get_value () const;
-	private:
-		void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
-	};
-
-	void set_control (AutomationType, double val, PBD::Controllable::GroupControlDisposition group_override);
-
-	boost::shared_ptr<AutomationControl> solo_control() const {
+	boost::shared_ptr<SoloControl> solo_control() const {
 		return _solo_control;
 	}
 
-	boost::shared_ptr<AutomationControl> mute_control() const {
+	boost::shared_ptr<MuteControl> mute_control() const {
 		return _mute_control;
 	}
 
-	boost::shared_ptr<MuteMaster> mute_master() const {
-		return _mute_master;
-	}
+	bool can_be_muted_by_others () const { return !is_master(); }
+	bool muted () const { return _mute_control->muted(); }
+	bool muted_by_others_soloing () const;
+	bool muted_by_others () const;
 
-	boost::shared_ptr<AutomationControl> solo_isolate_control() const {
+	boost::shared_ptr<SoloIsolateControl> solo_isolate_control() const {
 		return _solo_isolate_control;
 	}
 
-	boost::shared_ptr<AutomationControl> solo_safe_control() const {
+	boost::shared_ptr<SoloSafeControl> solo_safe_control() const {
 		return _solo_safe_control;
 	}
 
-	boost::shared_ptr<AutomationControl> monitoring_control() const {
+	boost::shared_ptr<MonitorControl> monitoring_control() const {
 		/* tracks override this to provide actual monitoring control;
 		   busses have no possible choices except input monitoring.
 		*/
-		return boost::shared_ptr<AutomationControl> ();
+		return boost::shared_ptr<MonitorControl> ();
 	}
 
 	/* Route doesn't own these items, but sub-objects that it does own have them
@@ -647,8 +488,8 @@ public:
 	boost::shared_ptr<Pannable> pannable() const;
 
 	boost::shared_ptr<GainControl> gain_control() const;
-	boost::shared_ptr<AutomationControl> trim_control() const;
-	boost::shared_ptr<AutomationControl> phase_control() const;
+	boost::shared_ptr<GainControl> trim_control() const;
+	boost::shared_ptr<PhaseControl> phase_control() const;
 
 	/**
 	   Return the first processor that accepts has at least one MIDI input
@@ -766,8 +607,8 @@ public:
         friend class Session;
 
 	void catch_up_on_solo_mute_override ();
-	void mod_solo_by_others_upstream (int32_t);
-	void mod_solo_by_others_downstream (int32_t);
+	void set_listen (bool);
+
 	void curve_reallocate ();
 	virtual void set_block_size (pframes_t nframes);
 
@@ -829,14 +670,6 @@ protected:
 	MeterPoint     _meter_point;
 	MeterPoint     _pending_meter_point;
 	MeterType      _meter_type;
-	boost::dynamic_bitset<> _phase_invert;
-	bool           _self_solo;
-	uint32_t       _soloed_by_others_upstream;
-	uint32_t       _soloed_by_others_downstream;
-	bool           _solo_isolated;
-	uint32_t       _solo_isolated_by_upstream;
-
-	void mod_solo_isolated_by_upstream (bool);
 
 	bool           _denormal_protection;
 
@@ -844,18 +677,14 @@ protected:
 	bool _silent : 1;
 	bool _declickable : 1;
 
-	boost::shared_ptr<SoloControllable> _solo_control;
-	boost::shared_ptr<MuteControllable> _mute_control;
-	boost::shared_ptr<MuteMaster> _mute_master;
-	boost::shared_ptr<PhaseControllable> _phase_control;
-	boost::shared_ptr<SoloIsolateControllable> _solo_isolate_control;
-	boost::shared_ptr<SoloSafeControllable> _solo_safe_control;
-
-	virtual void act_on_mute () {}
+	boost::shared_ptr<SoloControl> _solo_control;
+	boost::shared_ptr<MuteControl> _mute_control;
+	boost::shared_ptr<PhaseControl> _phase_control;
+	boost::shared_ptr<SoloIsolateControl> _solo_isolate_control;
+	boost::shared_ptr<SoloSafeControl> _solo_safe_control;
 
 	std::string    _comment;
 	bool           _have_internal_generator;
-	bool           _solo_safe;
 	DataType       _default_type;
 	FedBy          _fed_by;
 
@@ -882,9 +711,9 @@ protected:
 
 	virtual void maybe_declick (BufferSet&, framecnt_t, int);
 
-	boost::shared_ptr<GainControllable> _gain_control;
+	boost::shared_ptr<GainControl> _gain_control;
 	boost::shared_ptr<Amp>       _amp;
-	boost::shared_ptr<GainControllable> _trim_control;
+	boost::shared_ptr<GainControl> _trim_control;
 	boost::shared_ptr<Amp>       _trim;
 	boost::shared_ptr<PeakMeter> _meter;
 	boost::shared_ptr<DelayLine> _delayline;
@@ -928,7 +757,6 @@ private:
 	void placement_range (Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end);
 
 	void set_self_solo (bool yn);
-	void set_mute_master_solo ();
 
 	void set_processor_positions ();
 	framecnt_t update_port_latencies (PortSet& ports, PortSet& feeders, bool playback, framecnt_t) const;
@@ -985,6 +813,7 @@ private:
 	void reset_instrument_info ();
 
 	void set_remote_control_id_internal (uint32_t id, bool notify_class_listeners = true);
+        void solo_control_changed (bool self, PBD::Controllable::GroupControlDisposition);
 };
 
 } // namespace ARDOUR
diff --git a/libs/ardour/ardour/route_group.h b/libs/ardour/ardour/route_group.h
index 95affaeaf5..feeac6a467 100644
--- a/libs/ardour/ardour/route_group.h
+++ b/libs/ardour/ardour/route_group.h
@@ -29,10 +29,12 @@
 #include "pbd/signals.h"
 #include "pbd/stateful.h"
 
-#include "ardour/libardour_visibility.h"
+#include "ardour/control_group.h"
 #include "ardour/types.h"
 #include "ardour/session_object.h"
 
+#include "ardour/libardour_visibility.h"
+
 namespace ARDOUR {
 
 namespace Properties {
@@ -157,8 +159,17 @@ class LIBARDOUR_API RouteGroup : public SessionObject
 	PBD::Property<bool> _color;
 	PBD::Property<bool> _monitoring;
 
+	boost::shared_ptr<ControlGroup> _solo_group;
+	boost::shared_ptr<ControlGroup> _mute_group;
+	boost::shared_ptr<ControlGroup> _rec_enable_group;
+	boost::shared_ptr<ControlGroup> _gain_group;
+	boost::shared_ptr<ControlGroup> _monitoring_group;
+
 	void remove_when_going_away (boost::weak_ptr<Route>);
 	int set_state_2X (const XMLNode&, int);
+
+	void post_set (PBD::PropertyChange const &);
+	void push_to_groups ();
 };
 
 } /* namespace */
diff --git a/libs/ardour/ardour/session.h b/libs/ardour/ardour/session.h
index 18507ee5d9..786751dea5 100644
--- a/libs/ardour/ardour/session.h
+++ b/libs/ardour/ardour/session.h
@@ -791,16 +791,13 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 
 	static const SessionEvent::RTeventCallback rt_cleanup;
 
-	void set_solo (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
-	void set_implicit_solo (boost::shared_ptr<RouteList>, int delta, bool up_or_downstream, SessionEvent::RTeventCallback after = rt_cleanup, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
 	void clear_all_solo_state (boost::shared_ptr<RouteList>);
-	void set_just_one_solo (boost::shared_ptr<Route>, bool, SessionEvent::RTeventCallback after = rt_cleanup);
-	void set_mute (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
-	void set_listen (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
-	void set_record_enabled (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
-	void set_record_safe (boost::shared_ptr<RouteList>, bool yn, SessionEvent::RTeventCallback after = rt_cleanup, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
-	void set_solo_isolated (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
-	void set_monitoring (boost::shared_ptr<RouteList>, MonitorChoice, SessionEvent::RTeventCallback after = rt_cleanup, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
+
+	/* Control-based methods */
+
+	void set_controls (boost::shared_ptr<ControlList>, double val, PBD::Controllable::GroupControlDisposition);
+	void set_control (boost::shared_ptr<AutomationControl>, double val, PBD::Controllable::GroupControlDisposition);
+
 	void set_exclusive_input_active (boost::shared_ptr<RouteList> rt, bool onoff, bool flip_others = false);
 
 	PBD::Signal1<void,bool> SoloActive;
@@ -1936,16 +1933,18 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 		return ev;
 	}
 
-	void rt_set_solo (boost::shared_ptr<RouteList>, bool yn, PBD::Controllable::GroupControlDisposition group_override);
-	void rt_set_implicit_solo (boost::shared_ptr<RouteList>, int delta, bool up_or_downstream, PBD::Controllable::GroupControlDisposition);
+	/* specialized version realtime "apply to set of controls" operations */
+	SessionEvent* get_rt_event (boost::shared_ptr<ControlList> cl, double arg, PBD::Controllable::GroupControlDisposition group_override) {
+		SessionEvent* ev = new SessionEvent (SessionEvent::RealTimeOperation, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
+		ev->rt_slot = boost::bind (&Session::rt_set_controls, this, cl, arg, group_override);
+		ev->rt_return = Session::rt_cleanup;
+		ev->event_loop = PBD::EventLoop::get_event_loop_for_thread ();
+
+		return ev;
+	}
+
+	void rt_set_controls (boost::shared_ptr<ControlList>, double val, PBD::Controllable::GroupControlDisposition group_override);
 	void rt_clear_all_solo_state (boost::shared_ptr<RouteList>, bool yn, PBD::Controllable::GroupControlDisposition group_override);
-	void rt_set_just_one_solo (boost::shared_ptr<RouteList>, bool yn, PBD::Controllable::GroupControlDisposition  /* ignored*/ );
-	void rt_set_mute (boost::shared_ptr<RouteList>, bool yn, PBD::Controllable::GroupControlDisposition group_override);
-	void rt_set_listen (boost::shared_ptr<RouteList>, bool yn, PBD::Controllable::GroupControlDisposition group_override);
-	void rt_set_solo_isolated (boost::shared_ptr<RouteList>, bool yn, PBD::Controllable::GroupControlDisposition group_override);
-	void rt_set_record_enabled (boost::shared_ptr<RouteList>, bool yn, PBD::Controllable::GroupControlDisposition group_override);
-	void rt_set_record_safe (boost::shared_ptr<RouteList>, bool yn, PBD::Controllable::GroupControlDisposition group_override);
-	void rt_set_monitoring (boost::shared_ptr<RouteList>, MonitorChoice, PBD::Controllable::GroupControlDisposition group_override);
 
 	/** temporary list of Diskstreams used only during load of 2.X sessions */
 	std::list<boost::shared_ptr<Diskstream> > _diskstreams_2X;
diff --git a/libs/ardour/ardour/session_event.h b/libs/ardour/ardour/session_event.h
index cca7f1274e..8bb160b90e 100644
--- a/libs/ardour/ardour/session_event.h
+++ b/libs/ardour/ardour/session_event.h
@@ -84,26 +84,28 @@ public:
 	union {
 		void*        ptr;
 		bool         yes_or_no;
-		framepos_t  target2_frame;
+		framepos_t   target2_frame;
 		Slave*       slave;
 		Route*       route;
 	};
 
 	union {
 		bool second_yes_or_no;
+		double control_value;
 	};
 
 	union {
 		bool third_yes_or_no;
 	};
 
-	/* 4 members to handle a multi-group event handled in RT context */
+	/* 5 members to handle a multi-group event handled in RT context */
 
 	typedef boost::function<void (SessionEvent*)> RTeventCallback;
 
-	boost::shared_ptr<RouteList> routes;    /* apply to */
-	boost::function<void (void)> rt_slot;   /* what to call in RT context */
-	RTeventCallback              rt_return; /* called after rt_slot, with this event as an argument */
+	boost::shared_ptr<ControlList> controls; /* apply to */
+	boost::shared_ptr<RouteList> routes;     /* apply to */
+	boost::function<void (void)> rt_slot;    /* what to call in RT context */
+	RTeventCallback              rt_return;  /* called after rt_slot, with this event as an argument */
 	PBD::EventLoop*              event_loop;
 
 	std::list<AudioRange> audio_range;
diff --git a/libs/ardour/ardour/stripable.h b/libs/ardour/ardour/stripable.h
index e97fe79103..f68cb07b91 100644
--- a/libs/ardour/ardour/stripable.h
+++ b/libs/ardour/ardour/stripable.h
@@ -26,13 +26,19 @@
 #include <boost/utility.hpp>
 #include <boost/shared_ptr.hpp>
 
-#include "ardour/gain_control.h"
 #include "ardour/session_object.h"
 
 namespace ARDOUR {
 
 class AutomationControl;
+class GainControl;
 class PeakMeter;
+class SoloControl;
+class MuteControl;
+class PhaseControl;
+class SoloIsolateControl;
+class SoloSafeControl;
+class MonitorControl;
 
 /* This is a virtual base class for any object that needs to be potentially
  * represented by a control-centric user interface using the general model of a
@@ -58,12 +64,13 @@ class Stripable : public SessionObject {
 
 	virtual boost::shared_ptr<GainControl> gain_control() const = 0;
 
-	virtual boost::shared_ptr<AutomationControl> solo_control() const = 0;
-	virtual boost::shared_ptr<AutomationControl> mute_control() const = 0;
-	virtual boost::shared_ptr<AutomationControl> phase_control() const = 0;
-	virtual boost::shared_ptr<AutomationControl> trim_control() const = 0;
+	virtual boost::shared_ptr<SoloControl> solo_control() const = 0;
+	virtual boost::shared_ptr<MuteControl> mute_control() const = 0;
 
-	virtual boost::shared_ptr<AutomationControl> monitoring_control() const = 0;
+	virtual boost::shared_ptr<PhaseControl> phase_control() const = 0;
+	virtual boost::shared_ptr<GainControl> trim_control() const = 0;
+
+	virtual boost::shared_ptr<MonitorControl> monitoring_control() const = 0;
 	virtual boost::shared_ptr<AutomationControl> recenable_control() const { return boost::shared_ptr<AutomationControl>(); }
 
 	/* "well-known" controls for panning. Any or all of these may return
@@ -131,6 +138,9 @@ class Stripable : public SessionObject {
          * the route.
          */
 	virtual boost::shared_ptr<AutomationControl> master_send_enable_controllable () const = 0;
+
+	virtual bool muted_by_others_soloing () const = 0;
+	virtual bool muted_by_others () const = 0;
 };
 
 
diff --git a/libs/ardour/ardour/track.h b/libs/ardour/ardour/track.h
index b378021bce..bb955265c8 100644
--- a/libs/ardour/ardour/track.h
+++ b/libs/ardour/ardour/track.h
@@ -22,6 +22,7 @@
 #include <boost/shared_ptr.hpp>
 
 #include "ardour/interthread_info.h"
+#include "ardour/recordable.h"
 #include "ardour/route.h"
 #include "ardour/public_diskstream.h"
 
@@ -34,13 +35,14 @@ class Source;
 class Region;
 class Diskstream;
 class IO;
+class MonitorControl;
 
 /** A track is an route (bus) with a recordable diskstream and
  * related objects relevant to tracking, playback and editing.
  *
  * Specifically a track has regions and playlist objects.
  */
-class LIBARDOUR_API Track : public Route, public PublicDiskstream
+class LIBARDOUR_API Track : public Route, public Recordable, public PublicDiskstream
 {
   public:
 	Track (Session&, std::string name, Route::Flag f = Route::Flag (0), TrackMode m = Normal, DataType default_type = DataType::AUDIO);
@@ -56,23 +58,9 @@ class LIBARDOUR_API Track : public Route, public PublicDiskstream
 	virtual bool can_use_mode (TrackMode /*m*/, bool& /*bounce_required*/) { return false; }
 	PBD::Signal0<void> TrackModeChanged;
 
-	class LIBARDOUR_API MonitoringControllable : public RouteAutomationControl {
-	public:
-		MonitoringControllable (std::string name, boost::shared_ptr<Track>);
-		void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
-		/* currently no automation, so no need for set_value_unchecked() */
-		double get_value () const;
-	private:
-		void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
-	};
-
-	void set_monitoring (MonitorChoice, PBD::Controllable::GroupControlDisposition group_override);
-	MonitorChoice monitoring_choice() const { return _monitoring; }
-        MonitorState monitoring_state () const;
-	PBD::Signal0<void> MonitoringChanged;
-
-	boost::shared_ptr<AutomationControl> monitoring_control() const { return _monitoring_control; }
+	boost::shared_ptr<MonitorControl> monitoring_control() const { return _monitoring_control; }
 
+	MonitorState monitoring_state () const;
 	MeterState metering_state () const;
 
 	virtual int no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
@@ -142,13 +130,12 @@ class LIBARDOUR_API Track : public Route, public PublicDiskstream
 	virtual int set_state (const XMLNode&, int version);
 	static void zero_diskstream_id_in_xml (XMLNode&);
 
-	boost::shared_ptr<AutomationControl> rec_enable_control() { return _rec_enable_control; }
+	boost::shared_ptr<AutomationControl> rec_enable_control() const { return _record_enable_control; }
+	boost::shared_ptr<AutomationControl> rec_safe_control() const { return _record_safe_control; }
 
-	bool record_enabled() const;
-	bool record_safe () const;
-	void set_record_enabled (bool yn, PBD::Controllable::GroupControlDisposition);
-	void set_record_safe (bool yn, PBD::Controllable::GroupControlDisposition);
-	void prep_record_enabled (bool yn, PBD::Controllable::GroupControlDisposition);
+	int prep_record_enabled (bool);
+	bool can_be_record_enabled ();
+	bool can_be_record_safe ();
 
 	bool using_diskstream_id (PBD::ID) const;
 
@@ -204,8 +191,6 @@ class LIBARDOUR_API Track : public Route, public PublicDiskstream
 	PBD::Signal0<void> FreezeChange;
 	/* Emitted when our diskstream is set to use a different playlist */
 	PBD::Signal0<void> PlaylistChanged;
-	PBD::Signal0<void> RecordEnableChanged;
-	PBD::Signal0<void> RecordSafeChanged;
 	PBD::Signal0<void> SpeedChanged;
 	PBD::Signal0<void> AlignmentStyleChanged;
 
@@ -216,8 +201,7 @@ class LIBARDOUR_API Track : public Route, public PublicDiskstream
 	MeterPoint    _saved_meter_point;
 	TrackMode     _mode;
 	bool          _needs_butler;
-	MonitorChoice _monitoring;
-	boost::shared_ptr<MonitoringControllable> _monitoring_control;
+	boost::shared_ptr<MonitorControl> _monitoring_control;
 
 	//private: (FIXME)
 	struct FreezeRecordProcessorInfo {
@@ -242,20 +226,6 @@ class LIBARDOUR_API Track : public Route, public PublicDiskstream
 		FreezeState                        state;
 	};
 
-	class RecEnableControl : public AutomationControl {
-	public:
-		RecEnableControl (boost::shared_ptr<Track> t);
-
-		void set_value (double, PBD::Controllable::GroupControlDisposition);
-		void set_value_unchecked (double);
-		double get_value (void) const;
-
-		boost::weak_ptr<Track> track;
-
-	private:
-		void _set_value (double, PBD::Controllable::GroupControlDisposition);
-	};
-
 	virtual void set_state_part_two () = 0;
 
 	FreezeRecord          _freeze_record;
@@ -264,17 +234,20 @@ class LIBARDOUR_API Track : public Route, public PublicDiskstream
 
 	void maybe_declick (BufferSet&, framecnt_t, int);
 
-	boost::shared_ptr<RecEnableControl> _rec_enable_control;
+	boost::shared_ptr<AutomationControl> _record_enable_control;
+	boost::shared_ptr<AutomationControl> _record_safe_control;
+
+	virtual void record_enable_changed (bool, PBD::Controllable::GroupControlDisposition);
+	virtual void record_safe_changed (bool, PBD::Controllable::GroupControlDisposition);
 
 	framecnt_t check_initial_delay (framecnt_t nframes, framepos_t&);
+	virtual void monitoring_changed (bool, PBD::Controllable::GroupControlDisposition);
 
 private:
 
 	virtual boost::shared_ptr<Diskstream> diskstream_factory (XMLNode const &) = 0;
 
 	void diskstream_playlist_changed ();
-	void diskstream_record_enable_changed ();
-	void diskstream_record_safe_changed ();
 	void diskstream_speed_changed ();
 	void diskstream_alignment_style_changed ();
 	void parameter_changed (std::string const & p);
diff --git a/libs/ardour/ardour/types.h b/libs/ardour/ardour/types.h
index 626109557f..bd866141d5 100644
--- a/libs/ardour/ardour/types.h
+++ b/libs/ardour/ardour/types.h
@@ -53,6 +53,7 @@ namespace ARDOUR {
 	class Route;
 	class Region;
 	class VCA;
+	class AutomationControl;
 
 	typedef float    Sample;
 	typedef float    pan_t;
@@ -149,6 +150,7 @@ namespace ARDOUR {
 		FadeOutAutomation,
 		EnvelopeAutomation,
 		RecEnableAutomation,
+		RecSafeAutomation,
 		TrimAutomation,
 		PhaseAutomation,
 		MonitoringAutomation,
@@ -565,6 +567,7 @@ namespace ARDOUR {
 
 	typedef std::list<boost::shared_ptr<Route> > RouteList;
 	typedef std::list<boost::weak_ptr  <Route> > WeakRouteList;
+	typedef std::list<boost::shared_ptr<AutomationControl> > ControlList;
 
 	typedef std::list<boost::shared_ptr<VCA> > VCAList;
 
diff --git a/libs/ardour/ardour/utils.h b/libs/ardour/ardour/utils.h
index f3767d471a..1dc7c2baf4 100644
--- a/libs/ardour/ardour/utils.h
+++ b/libs/ardour/ardour/utils.h
@@ -28,19 +28,26 @@
 #include <string>
 #include <cmath>
 
+#include "boost/shared_ptr.hpp"
+
 #if __APPLE__
 #include <CoreFoundation/CoreFoundation.h>
 #endif /* __APPLE__ */
 
-#include "ardour/libardour_visibility.h"
 #include "ardour/ardour.h"
 #include "ardour/data_type.h"
 #include "ardour/dB.h"
+#include "ardour/types.h"
+
+#include "ardour/libardour_visibility.h"
 
 class XMLNode;
 
 namespace ARDOUR {
 
+class Route;
+class Track;
+
 LIBARDOUR_API std::string legalize_for_path (const std::string& str);
 LIBARDOUR_API std::string legalize_for_universal_path (const std::string& str);
 LIBARDOUR_API std::string legalize_for_uri (const std::string& str);
@@ -169,6 +176,29 @@ LIBARDOUR_API bool matching_unsuffixed_filename_exists_in (const std::string& di
 
 LIBARDOUR_API uint32_t how_many_dsp_threads ();
 
+template<typename T> boost::shared_ptr<ControlList> route_list_to_control_list (boost::shared_ptr<RouteList> rl, boost::shared_ptr<T> (Route::*get_control)() const) {
+	boost::shared_ptr<ControlList> cl (new ControlList);
+	for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
+		boost::shared_ptr<AutomationControl> ac = ((*r).get()->*get_control)();
+		if (ac) {
+			cl->push_back (ac);
+		}
+	}
+	return cl;
+}
+
+template<typename T> boost::shared_ptr<ControlList> route_list_to_control_list (boost::shared_ptr<RouteList> rl, boost::shared_ptr<T> (Track::*get_control)() const) {
+	boost::shared_ptr<ControlList> cl (new ControlList);
+	for (RouteList::const_iterator r = rl->begin(); r != rl->end(); ++r) {
+		boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*r);
+		boost::shared_ptr<AutomationControl> ac = (t.get()->*get_control)();
+		if (ac) {
+			cl->push_back (ac);
+		}
+	}
+	return cl;
+}
+
 #if __APPLE__
 LIBARDOUR_API std::string CFStringRefToStdString(CFStringRef stringRef);
 #endif // __APPLE__
@@ -176,4 +206,3 @@ LIBARDOUR_API std::string CFStringRefToStdString(CFStringRef stringRef);
 } //namespave
 
 #endif /* __ardour_utils_h__ */
-
diff --git a/libs/ardour/ardour/vca.h b/libs/ardour/ardour/vca.h
index dc48ffa480..1c247c0e92 100644
--- a/libs/ardour/ardour/vca.h
+++ b/libs/ardour/ardour/vca.h
@@ -27,14 +27,19 @@
 #include "pbd/statefuldestructible.h"
 
 #include "ardour/automatable.h"
+#include "ardour/muteable.h"
+#include "ardour/soloable.h"
 #include "ardour/stripable.h"
 
 namespace ARDOUR {
 
-class GainControl;
 class Route;
+class GainControl;
+class SoloControl;
+class MuteControl;
+class MonitorControl;
 
-class LIBARDOUR_API VCA : public Stripable, public Automatable, public boost::enable_shared_from_this<VCA> {
+class LIBARDOUR_API VCA : public Stripable, public Soloable, public Muteable, public Automatable, public boost::enable_shared_from_this<VCA> {
   public:
 	VCA (Session& session,  uint32_t num, const std::string& name);
 	~VCA();
@@ -47,7 +52,15 @@ class LIBARDOUR_API VCA : public Stripable, public Automatable, public boost::en
 	int set_state (XMLNode const&, int version);
 
 	bool soloed () const;
+	void push_solo_upstream (int32_t) {}
+	void push_solo_isolate_upstream (int32_t) {}
+	bool can_solo() const { return true; }
+	bool is_safe () const { return false; }
+
 	bool muted () const;
+	bool can_be_muted_by_others () const { return true; }
+	bool muted_by_others_soloing() const { return false; }
+	bool muted_by_others() const { return false; }
 
 	static std::string default_name_template ();
 	static int next_vca_number ();
@@ -58,16 +71,16 @@ class LIBARDOUR_API VCA : public Stripable, public Automatable, public boost::en
 	static void set_next_vca_number (uint32_t);
 
 	virtual boost::shared_ptr<GainControl> gain_control() const { return _gain_control; }
-	virtual boost::shared_ptr<AutomationControl> solo_control() const { return _solo_control; }
-	virtual boost::shared_ptr<AutomationControl> mute_control() const { return _mute_control; }
+	virtual boost::shared_ptr<SoloControl> solo_control() const { return _solo_control; }
+	virtual boost::shared_ptr<MuteControl> mute_control() const { return _mute_control; }
 
 	/* null Stripable API, because VCAs don't have any of this */
 
-	virtual boost::shared_ptr<PeakMeter>       peak_meter() { return boost::shared_ptr<PeakMeter>(); }
-	virtual boost::shared_ptr<const PeakMeter> peak_meter() const { return boost::shared_ptr<PeakMeter>(); }
-	virtual boost::shared_ptr<AutomationControl> phase_control() const { return boost::shared_ptr<AutomationControl>(); }
-	virtual boost::shared_ptr<AutomationControl> trim_control() const { return boost::shared_ptr<AutomationControl>(); }
-	virtual boost::shared_ptr<AutomationControl> monitoring_control() const { return boost::shared_ptr<AutomationControl>(); }
+	virtual boost::shared_ptr<PeakMeter>         peak_meter() { return boost::shared_ptr<PeakMeter>(); }
+	virtual boost::shared_ptr<const PeakMeter>   peak_meter() const { return boost::shared_ptr<PeakMeter>(); }
+	virtual boost::shared_ptr<PhaseControl>      phase_control() const { return boost::shared_ptr<PhaseControl>(); }
+	virtual boost::shared_ptr<GainControl>       trim_control() const { return boost::shared_ptr<GainControl>(); }
+	virtual boost::shared_ptr<MonitorControl>    monitoring_control() const { return boost::shared_ptr<MonitorControl>(); }
 	virtual boost::shared_ptr<AutomationControl> recenable_control() const { return boost::shared_ptr<AutomationControl>(); }
 	virtual boost::shared_ptr<AutomationControl> pan_azimuth_control() const { return boost::shared_ptr<AutomationControl>(); }
 	virtual boost::shared_ptr<AutomationControl> pan_elevation_control() const { return boost::shared_ptr<AutomationControl>(); }
@@ -96,36 +109,12 @@ class LIBARDOUR_API VCA : public Stripable, public Automatable, public boost::en
 	virtual boost::shared_ptr<AutomationControl> master_send_enable_controllable () const { return boost::shared_ptr<AutomationControl>(); }
 
   private:
-	class VCASoloControllable : public AutomationControl {
-          public:
-		VCASoloControllable (std::string const & name, boost::shared_ptr<VCA> vca);
-		void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
-		void set_value_unchecked (double);
-		double get_value () const;
-	  private:
-		void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
-		boost::weak_ptr<VCA> _vca;
-	};
-
-	class VCAMuteControllable : public AutomationControl {
-          public:
-		VCAMuteControllable (std::string const & name, boost::shared_ptr<VCA> vca);
-		void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
-		void set_value_unchecked (double);
-		double get_value () const;
-	  private:
-		void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
-		boost::weak_ptr<VCA> _vca;
-	};
-
-	friend class VCASoloControllable;
-	friend class VCAMuteControllable;
-
 	uint32_t    _number;
 
 	boost::shared_ptr<GainControl> _gain_control;
-	boost::shared_ptr<VCASoloControllable> _solo_control;
-	boost::shared_ptr<VCAMuteControllable> _mute_control;
+	boost::shared_ptr<SoloControl> _solo_control;
+	boost::shared_ptr<MuteControl> _mute_control;
+
 	bool _solo_requested;
 	bool _mute_requested;