make Track::set_monitoring() use a GroupControlDisposition; expose an AutomationControl for track monitoring choice

libs/ardour/ardour/midi_track.h

@@ -133,7 +133,7 @@ public:
 	PBD::Signal1<void, boost::weak_ptr<MidiSource> > DataRecorded;
 	boost::shared_ptr<MidiBuffer> get_gui_feed_buffer () const;
 
-	void set_monitoring (MonitorChoice);
+	void set_monitoring (MonitorChoice, PBD::Controllable::GroupControlDisposition);
 	MonitorState monitoring_state () const;
 
 	void set_input_active (bool);

libs/ardour/ardour/track.h

@@ -51,11 +51,24 @@ class LIBARDOUR_API Track : public Route, public PublicDiskstream
 	virtual bool can_use_mode (TrackMode /*m*/, bool& /*bounce_required*/) { return false; }
 	PBD::Signal0<void> TrackModeChanged;
 
-	virtual void set_monitoring (MonitorChoice);
+	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);
+		static ParameterDescriptor get_descriptor();
+	};
+
+	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; }
+
 	MeterState metering_state () const;
 
 	virtual int no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
@@ -179,6 +192,7 @@ class LIBARDOUR_API Track : public Route, public PublicDiskstream
 	TrackMode     _mode;
 	bool          _needs_butler;
 	MonitorChoice _monitoring;
+	boost::shared_ptr<MonitoringControllable> _monitoring_control;
 
 	//private: (FIXME)
 	struct FreezeRecordProcessorInfo {

libs/ardour/midi_track.cc

@@ -48,6 +48,7 @@
 #include "ardour/port.h"
 #include "ardour/processor.h"
 #include "ardour/profile.h"
+#include "ardour/route_group_specialized.h"
 #include "ardour/session.h"
 #include "ardour/session_playlists.h"
 #include "ardour/utils.h"
@@ -957,11 +958,16 @@ MidiTrack::act_on_mute ()
 }
 
 void
-MidiTrack::set_monitoring (MonitorChoice mc)
+MidiTrack::set_monitoring (MonitorChoice mc, Controllable::GroupControlDisposition gcd)
 {
+	if (use_group (gcd, &RouteGroup::is_monitoring)) {
+		_route_group->apply (&Track::set_monitoring, mc, Controllable::NoGroup);
+		return;
+	}
+
 	if (mc != _monitoring) {
 
-		Track::set_monitoring (mc);
+		Track::set_monitoring (mc, gcd);
 
 		/* monitoring state changed, so flush out any on notes at the
 		 * port level.

libs/ardour/track.cc

@@ -64,6 +64,7 @@ Track::init ()
 	boost::shared_ptr<Track> rt = boost::dynamic_pointer_cast<Track> (rp);
 	_rec_enable_control = boost::shared_ptr<RecEnableControl> (new RecEnableControl(rt));
 	_rec_enable_control->set_flags (Controllable::Toggle);
+        _monitoring_control.reset (new MonitoringControllable (X_("monitoring"), rt));
 
 	/* don't add rec_enable_control to controls because we don't want it to
 	 * appear as an automatable parameter
@@ -1131,8 +1132,13 @@ Track::check_initial_delay (framecnt_t nframes, framepos_t& transport_frame)
 }
 
 void
-Track::set_monitoring (MonitorChoice mc)
+Track::set_monitoring (MonitorChoice mc, Controllable::GroupControlDisposition gcd)
 {
+	if (use_group (gcd, &RouteGroup::is_monitoring)) {
+		_route_group->apply (&Track::set_monitoring, mc, Controllable::NoGroup);
+		return;
+	}
+
 	if (mc !=  _monitoring) {
 		_monitoring = mc;
 
@@ -1141,6 +1147,7 @@ Track::set_monitoring (MonitorChoice mc)
 		}
 
 		MonitoringChanged (); /* EMIT SIGNAL */
+		_monitoring_control->Changed (); /* EMIT SIGNAL */
 	}
 }
 
@@ -1157,3 +1164,69 @@ Track::metering_state () const
 	}
 	return rv ? MeteringInput : MeteringRoute;
 }
+
+Track::MonitoringControllable::MonitoringControllable (std::string name, boost::shared_ptr<Track> r)
+	: RouteAutomationControl (name, MonitoringAutomation, get_descriptor(), boost::shared_ptr<AutomationList>(), r)
+{
+	boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MonitoringAutomation)));
+	gl->set_interpolation(Evoral::ControlList::Discrete);
+	set_list (gl);
+}
+
+void
+Track::MonitoringControllable::set_value (double val, Controllable::GroupControlDisposition gcd)
+{
+	_set_value (val, gcd);
+}
+
+void
+Track::MonitoringControllable::_set_value (double val, Controllable::GroupControlDisposition gcd)
+{
+	boost::shared_ptr<Route> r = _route.lock();
+	if (!r) {
+		return;
+	}
+
+	boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (r);
+	if (!t) {
+		return;
+	}
+
+	int mc = (int) val;
+
+	if (mc < MonitorAuto || mc > MonitorDisk) {
+		return;
+	}
+
+	/* no group effect at present */
+
+	t->set_monitoring ((MonitorChoice) mc, gcd);
+}
+
+double
+Track::MonitoringControllable::get_value () const
+{
+	boost::shared_ptr<Route> r = _route.lock();
+	if (!r) {
+		return 0.0;
+	}
+
+	boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (r);
+	if (!t) {
+		return 0.0;
+	}
+
+	return t->monitoring_choice();
+}
+
+ParameterDescriptor
+Track::MonitoringControllable::get_descriptor()
+{
+	ParameterDescriptor desc;
+	desc.type = MonitoringAutomation;
+	desc.enumeration = true;
+	desc.integer_step = true;
+	desc.lower = MonitorAuto;
+	desc.upper = MonitorDisk; /* XXX bump when we add MonitorCue */
+	return desc;
+}