handle sidechain input changes

[ardour.git] / libs / ardour / track.cc

diff --git a/libs/ardour/track.cc b/libs/ardour/track.cc
index e99d07f0475f139f46828899bf09b3108f78869f..f279eae3069cbab3dfcedad52c45868b2357c238 100644 (file)
--- a/libs/ardour/track.cc
+++ b/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
@@ -190,14 +191,30 @@ Track::RecEnableControl::RecEnableControl (boost::shared_ptr<Track> t)
 }
 
 void
-Track::RecEnableControl::set_value (double val)
+Track::RecEnableControl::set_value (double val, Controllable::GroupControlDisposition group_override)
+{
+       if (writable()) {
+               _set_value (val, group_override);
+       }
+}
+
+void
+Track::RecEnableControl::set_value_unchecked (double val)
+{
+       if (writable()) {
+               _set_value (val, Controllable::NoGroup);
+       }
+}
+
+void
+Track::RecEnableControl::_set_value (double val, Controllable::GroupControlDisposition group_override)
 {
        boost::shared_ptr<Track> t = track.lock ();
        if (!t) {
                return;
        }
 
-       t->set_record_enabled (val >= 0.5 ? true : false, this);
+       t->set_record_enabled (val >= 0.5 ? true : false, group_override);
 }
 
 double
@@ -230,7 +247,7 @@ Track::can_record()
 }
 
 void
-Track::prep_record_enabled (bool yn, void *src)
+Track::prep_record_enabled (bool yn, Controllable::GroupControlDisposition group_override)
 {
        if (yn && record_safe ()) {
            return;
@@ -244,8 +261,8 @@ Track::prep_record_enabled (bool yn, void *src)
                return;
        }
 
-       if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_recenable()) {
-               _route_group->apply (&Track::prep_record_enabled, yn, _route_group);
+       if (use_group (group_override, &RouteGroup::is_recenable)) {
+               _route_group->apply (&Track::prep_record_enabled, yn, Controllable::NoGroup);
                return;
        }
 
@@ -274,7 +291,7 @@ Track::prep_record_enabled (bool yn, void *src)
 }
 
 void
-Track::set_record_enabled (bool yn, void *src)
+Track::set_record_enabled (bool yn, Controllable::GroupControlDisposition group_override)
 {
        if (_diskstream->record_safe ()) {
            return;
@@ -288,8 +305,8 @@ Track::set_record_enabled (bool yn, void *src)
                return;
        }
 
-       if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_recenable()) {
-               _route_group->apply (&Track::set_record_enabled, yn, _route_group);
+       if (use_group (group_override, &RouteGroup::is_recenable)) {
+               _route_group->apply (&Track::set_record_enabled, yn, Controllable::NoGroup);
                return;
        }
 
@@ -305,18 +322,18 @@ Track::record_safe () const
 }
 
 void
-Track::set_record_safe (bool yn, void *src)
+Track::set_record_safe (bool yn, Controllable::GroupControlDisposition group_override)
 {
-       if (!_session.writable()) { /* REQUIRES REVIEW */
+       if (!_session.writable()) {
                return;
        }
 
-       if (_freeze_record.state == Frozen) { /* REQUIRES REVIEW */
+       if (_freeze_record.state == Frozen) {
                return;
        }
 
-       if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_recenable()) {
-               _route_group->apply (&Track::set_record_safe, yn, _route_group);
+       if (use_group (group_override, &RouteGroup::is_recenable)) {
+               _route_group->apply (&Track::set_record_safe, yn, Controllable::NoGroup);
                return;
        }
 
@@ -1115,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;
 
@@ -1125,6 +1147,7 @@ Track::set_monitoring (MonitorChoice mc)
                }
 
                MonitoringChanged (); /* EMIT SIGNAL */
+               _monitoring_control->Changed (); /* EMIT SIGNAL */
        }
 }
 
@@ -1142,3 +1165,56 @@ Track::metering_state () const
        return rv ? MeteringInput : MeteringRoute;
 }
 
+Track::MonitoringControllable::MonitoringControllable (std::string name, boost::shared_ptr<Track> r)
+       : RouteAutomationControl (name, MonitoringAutomation, 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();
+}