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

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

diff --git a/libs/ardour/vca.cc b/libs/ardour/vca.cc
index 6873a29df96bf6729583958d3e0627871fa56e4e..8c4fe260ecc289342578442a6fc4602671cc6556 100644 (file)
--- a/libs/ardour/vca.cc
+++ b/libs/ardour/vca.cc
@@ -31,7 +31,7 @@ using namespace ARDOUR;
 using namespace PBD;
 using std::string;
 
-gint VCA::next_number = 0;
+gint VCA::next_number = 1;
 string VCA::xml_node_name (X_("VCA"));
 
 string
@@ -43,8 +43,22 @@ VCA::default_name_template ()
 int
 VCA::next_vca_number ()
 {
-       /* recall that atomic_int_add() returns the value before the add */
-       return g_atomic_int_add (&next_number, 1) + 1;
+       /* recall that atomic_int_add() returns the value before the add. We
+        * start at one, then next one will be two etc.
+        */
+       return g_atomic_int_add (&next_number, 1);
+}
+
+void
+VCA::set_next_vca_number (uint32_t n)
+{
+       g_atomic_int_set (&next_number, n);
+}
+
+uint32_t
+VCA::get_next_vca_number ()
+{
+       return g_atomic_int_get (&next_number);
 }
 
 VCA::VCA (Session& s,  uint32_t num, const string& name)
@@ -123,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);
@@ -175,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);
        }