make sure that rec-enable changes get to do their non-RT stuff before being queued...

[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 c634e3474a7b437740e53341789f4de98c054eaf..e15abbec46ce58f0594b526d696b9b557c169b2c 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,
@@ -81,8 +89,22 @@ public:
        void start_touch(double when);
        void stop_touch(bool mark, double when);
 
-       void set_value (double);
+       /* inherited from PBD::Controllable.
+        */
        double get_value () const;
+       /* inherited from PBD::Controllable.
+        * Derived classes MUST call ::writable() to verify
+        * that writing to the parameter is legal at that time.
+        */
+       void set_value (double value, PBD::Controllable::GroupControlDisposition group_override);
+       /* 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.
+        */
+       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; }
@@ -95,13 +117,36 @@ public:
        const ParameterDescriptor& desc() const { return _desc; }
 
        const ARDOUR::Session& session() const { return _session; }
-       void commit_transaction ();
-
-protected:
+       void commit_transaction (bool did_write);
 
+  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);
+
+       /* Session needs to call this method before it queues up the real
+          change for execution in a realtime context. C++ access control sucks.
+       */
+       friend class Session;
+       virtual void do_pre_realtime_queue_stuff (double new_value) {}
+
+  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>);
 };