move vca assignment up to the Route level (from GainControl)

diff --git a/libs/ardour/ardour/vca.h b/libs/ardour/ardour/vca.h
index 069eb98564892f23658b409189992633286cc8e5..82e0e7acd244234c9cb6542761715dedc87030fa 100644 (file)
--- a/libs/ardour/ardour/vca.h
+++ b/libs/ardour/ardour/vca.h
@@ -46,8 +46,10 @@ class LIBARDOUR_API VCA : public Stripable, public Automatable, public boost::en
        XMLNode& get_state();
        int set_state (XMLNode const&, int version);
 
-       void add_solo_mute_target (boost::shared_ptr<Route>);
-       void remove_solo_mute_target (boost::shared_ptr<Route>);
+       void add_solo_target (boost::shared_ptr<Route>);
+       void remove_solo_target (boost::shared_ptr<Route>);
+       void add_mute_target (boost::shared_ptr<Route>);
+       void remove_mute_target (boost::shared_ptr<Route>);
 
        bool soloed () const;
        bool muted () const;
@@ -125,9 +127,15 @@ class LIBARDOUR_API VCA : public Stripable, public Automatable, public boost::en
        friend class VCAMuteControllable;
 
        uint32_t    _number;
-       RouteList solo_mute_targets;
-       PBD::ScopedConnectionList solo_mute_connections;
-       mutable Glib::Threads::RWLock solo_mute_lock;
+
+       RouteList solo_targets;
+       PBD::ScopedConnectionList solo_connections;
+       mutable Glib::Threads::RWLock solo_lock;
+
+       RouteList mute_targets;
+       PBD::ScopedConnectionList mute_connections;
+       mutable Glib::Threads::RWLock mute_lock;
+
        boost::shared_ptr<GainControl> _gain_control;
        boost::shared_ptr<VCASoloControllable> _solo_control;
        boost::shared_ptr<VCAMuteControllable> _mute_control;
@@ -136,7 +144,8 @@ class LIBARDOUR_API VCA : public Stripable, public Automatable, public boost::en
 
        static gint next_number;
 
-       void solo_mute_target_going_away (boost::weak_ptr<Route>);
+       void solo_target_going_away (boost::weak_ptr<Route>);
+       void mute_target_going_away (boost::weak_ptr<Route>);
        bool soloed_locked () const;
        bool muted_locked () const;
 

diff --git a/libs/ardour/route.cc b/libs/ardour/route.cc
index edffc3f3cec7cb03a662bf0370a7eeaacae23575..5332a7003608ff020e6cb269e77d4edb5c8ed69e 100644 (file)
--- a/libs/ardour/route.cc
+++ b/libs/ardour/route.cc
@@ -5899,7 +5899,8 @@ void
 Route::vca_assign (boost::shared_ptr<VCA> vca)
 {
        _gain_control->add_master (vca);
-       vca->add_solo_mute_target (shared_from_this());
+       vca->add_solo_target (shared_from_this());
+       vca->add_mute_target (shared_from_this());
 }
 
 void
@@ -5911,6 +5912,7 @@ Route::vca_unassign (boost::shared_ptr<VCA> vca)
                /* XXXX need to remove from solo/mute target lists */
        } else {
                _gain_control->remove_master (vca);
-               vca->remove_solo_mute_target (shared_from_this());
+               vca->remove_solo_target (shared_from_this());
+               vca->remove_mute_target (shared_from_this());
        }
 }

diff --git a/libs/ardour/vca.cc b/libs/ardour/vca.cc
index 2616549e1722b2880f16995670564b8cb6fcb7e2..8c4fe260ecc289342578442a6fc4602671cc6556 100644 (file)
--- a/libs/ardour/vca.cc
+++ b/libs/ardour/vca.cc
@@ -137,47 +137,45 @@ VCA::set_state (XMLNode const& node, int version)
 }
 
 void
-VCA::add_solo_mute_target (boost::shared_ptr<Route> r)
+VCA::add_solo_target (boost::shared_ptr<Route> r)
 {
-       Glib::Threads::RWLock::WriterLock lm (solo_mute_lock);
-       solo_mute_targets.push_back (r);
-       r->DropReferences.connect_same_thread (solo_mute_connections, boost::bind (&VCA::solo_mute_target_going_away, this, boost::weak_ptr<Route> (r)));
+       Glib::Threads::RWLock::WriterLock lm (solo_lock);
+       solo_targets.push_back (r);
+       r->DropReferences.connect_same_thread (solo_connections, boost::bind (&VCA::solo_target_going_away, this, boost::weak_ptr<Route> (r)));
 }
 
 void
-VCA::remove_solo_mute_target (boost::shared_ptr<Route> r)
+VCA::remove_solo_target (boost::shared_ptr<Route> r)
 {
-       Glib::Threads::RWLock::WriterLock lm (solo_mute_lock);
-       solo_mute_targets.remove (r);
+       Glib::Threads::RWLock::WriterLock lm (solo_lock);
+       solo_targets.remove (r);
 }
 
 void
-VCA::solo_mute_target_going_away (boost::weak_ptr<Route> wr)
+VCA::solo_target_going_away (boost::weak_ptr<Route> wr)
 {
        boost::shared_ptr<Route> r (wr.lock());
        if (!r) {
                return;
        }
-
-       Glib::Threads::RWLock::WriterLock lm (solo_mute_lock);
-       solo_mute_targets.remove (r);
+       remove_solo_target (r);
 }
 
 void
 VCA::set_solo (bool yn)
 {
        {
-               Glib::Threads::RWLock::ReaderLock lm (solo_mute_lock);
+               Glib::Threads::RWLock::ReaderLock lm (solo_lock);
 
                if (yn == _solo_requested) {
                        return;
                }
 
-               if (solo_mute_targets.empty()) {
+               if (solo_targets.empty()) {
                        return;
                }
 
-               boost::shared_ptr<RouteList> rl (new RouteList (solo_mute_targets));
+               boost::shared_ptr<RouteList> rl (new RouteList (solo_targets));
 
                if (Config->get_solo_control_is_listen_control()) {
                        _session.set_listen (rl, yn, Session::rt_cleanup, Controllable::NoGroup);
@@ -189,16 +187,41 @@ VCA::set_solo (bool yn)
        _solo_requested = yn;
 }
 
+void
+VCA::add_mute_target (boost::shared_ptr<Route> r)
+{
+       Glib::Threads::RWLock::WriterLock lm (mute_lock);
+       mute_targets.push_back (r);
+       r->DropReferences.connect_same_thread (mute_connections, boost::bind (&VCA::mute_target_going_away, this, boost::weak_ptr<Route> (r)));
+}
+
+void
+VCA::remove_mute_target (boost::shared_ptr<Route> r)
+{
+       Glib::Threads::RWLock::WriterLock lm (mute_lock);
+       mute_targets.remove (r);
+}
+
+void
+VCA::mute_target_going_away (boost::weak_ptr<Route> wr)
+{
+       boost::shared_ptr<Route> r (wr.lock());
+       if (!r) {
+               return;
+       }
+       remove_mute_target (r);
+}
+
 void
 VCA::set_mute (bool yn)
 {
        {
-               Glib::Threads::RWLock::ReaderLock lm (solo_mute_lock);
+               Glib::Threads::RWLock::ReaderLock lm (mute_lock);
                if (yn == _mute_requested) {
                        return;
                }
 
-               boost::shared_ptr<RouteList> rl (new RouteList (solo_mute_targets));
+               boost::shared_ptr<RouteList> rl (new RouteList (mute_targets));
                _session.set_mute (rl, yn, Session::rt_cleanup, Controllable::NoGroup);
        }