fix logic for removing an AutomationControl from a ControlGroup

[ardour.git] / libs / ardour / ardour / automation_control.h

diff --git a/libs/ardour/ardour/automation_control.h b/libs/ardour/ardour/automation_control.h
index 0d065686e20791818b212eaa5019affd0c1857cb..a2eff17d9aea5aaa8dc048b851c917dbd71589d3 100644 (file)
--- a/libs/ardour/ardour/automation_control.h
+++ b/libs/ardour/ardour/automation_control.h
@@ -21,22 +21,29 @@
 #ifndef __ardour_automation_control_h__
 #define __ardour_automation_control_h__
 
+#include <map>
+
+#include <glibmm/threads.h>
+
 #include <boost/shared_ptr.hpp>
 #include <boost/enable_shared_from_this.hpp>
 
-#include "evoral/types.hpp"
 #include "pbd/controllable.h"
+
+#include "evoral/types.hpp"
 #include "evoral/Control.hpp"
 
-#include "ardour/libardour_visibility.h"
 #include "ardour/automation_list.h"
+#include "ardour/control_group_member.h"
 #include "ardour/parameter_descriptor.h"
 
+#include "ardour/libardour_visibility.h"
+
 namespace ARDOUR {
 
 class Session;
 class Automatable;
-
+class ControlGroup;
 
 /** A PBD::Controllable with associated automation data (AutomationList)
  */
@@ -44,8 +51,9 @@ class LIBARDOUR_API AutomationControl
        : public PBD::Controllable
        , public Evoral::Control
        , public boost::enable_shared_from_this<AutomationControl>
+       , public ControlGroupMember
 {
-public:
+    public:
        AutomationControl(ARDOUR::Session&,
                          const Evoral::Parameter&                  parameter,
                          const ParameterDescriptor&                desc,
@@ -82,8 +90,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.
@@ -94,10 +100,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; }
@@ -112,10 +119,83 @@ public:
        const ARDOUR::Session& session() const { return _session; }
        void commit_transaction (bool did_write);
 
-protected:
+  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);
+
+  private:
+       /* I am unclear on why we have to make ControlGroup a friend in order
+          to get access to the ::set_group() method when it is already
+          declared to be a friend in ControlGroupMember. Oh well.
+       */
+       friend class ControlGroup;
+       void set_group (boost::shared_ptr<ControlGroup>);
+};
+
+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 ();
+       bool slaved_to (boost::shared_ptr<AutomationControl>) const;
+       bool slaved () const;
+       std::vector<PBD::ID> masters () const;
+
+       PBD::Signal0<void> MasterStatusChange;
+
+    protected:
+
+       class MasterRecord {
+          public:
+               MasterRecord (boost::shared_ptr<AutomationControl> gc, double r)
+                       : _master (gc)
+                       , _ratio (r)
+               {}
+
+               boost::shared_ptr<AutomationControl> master() const { return _master; }
+               double ratio () const { return _ratio; }
+               void reset_ratio (double r) { _ratio = r; }
+
+               PBD::ScopedConnection connection;
+
+         private:
+               boost::shared_ptr<AutomationControl> _master;
+               double _ratio;
+
+       };
+
+       mutable Glib::Threads::RWLock master_lock;
+       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;
+
 };