X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Fautomation_control.h;h=e15abbec46ce58f0594b526d696b9b557c169b2c;hb=2e3c25eca709b734297edc3f4487264cbf6c1a58;hp=5810ced9f91ad35e692e8aa05f90d8a1cb4a8790;hpb=eb296b2c957f574334fae2aefd8b863cf7631769;p=ardour.git

diff --git a/libs/ardour/ardour/automation_control.h b/libs/ardour/ardour/automation_control.h
index 5810ced9f9..e15abbec46 100644
--- a/libs/ardour/ardour/automation_control.h
+++ b/libs/ardour/ardour/automation_control.h
@@ -1,6 +1,6 @@
 /*
     Copyright (C) 2007 Paul Davis
-    Author: Dave Robillard
+    Author: David Robillard
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -21,36 +21,132 @@
 #ifndef __ardour_automation_control_h__
 #define __ardour_automation_control_h__
 
-#include <boost/shared_ptr.hpp>
-#include <pbd/controllable.h>
+#include <map>
 
-namespace ARDOUR {
+#include <glibmm/threads.h>
 
-class AutomationList;
-class Session;
+#include <boost/shared_ptr.hpp>
+#include <boost/enable_shared_from_this.hpp>
 
+#include "pbd/controllable.h"
 
-/** A PBD:Controllable with associated automation data (AutomationList)
- */
-class AutomationControl : public PBD::Controllable
-{
-public:
-	AutomationControl(ARDOUR::Session&, boost::shared_ptr<ARDOUR::AutomationList>,
-			std::string name="unnamed controllable");
+#include "evoral/types.hpp"
+#include "evoral/Control.hpp"
 
-	void set_value(float val);
-	float get_value() const;
-	float user_value() const;
+#include "ardour/automation_list.h"
+#include "ardour/control_group_member.h"
+#include "ardour/parameter_descriptor.h"
 
-	void set_list(boost::shared_ptr<ARDOUR::AutomationList>);
+#include "ardour/libardour_visibility.h"
 
-	boost::shared_ptr<ARDOUR::AutomationList>       list()       { return _list; }
-	boost::shared_ptr<const ARDOUR::AutomationList> list() const { return _list; }
+namespace ARDOUR {
+
+class Session;
+class Automatable;
+class ControlGroup;
 
-protected:
-	ARDOUR::Session&                          _session;
-	boost::shared_ptr<ARDOUR::AutomationList> _list;
-	float                                     _user_value;
+/** A PBD::Controllable with associated automation data (AutomationList)
+ */
+class LIBARDOUR_API AutomationControl
+	: public PBD::Controllable
+	, public Evoral::Control
+	, public boost::enable_shared_from_this<AutomationControl>
+	, public ControlGroupMember
+{
+    public:
+	AutomationControl(ARDOUR::Session&,
+	                  const Evoral::Parameter&                  parameter,
+	                  const ParameterDescriptor&                desc,
+	                  boost::shared_ptr<ARDOUR::AutomationList> l=boost::shared_ptr<ARDOUR::AutomationList>(),
+	                  const std::string&                        name="");
+
+	~AutomationControl ();
+
+	boost::shared_ptr<AutomationList> alist() const {
+		return boost::dynamic_pointer_cast<AutomationList>(_list);
+	}
+
+	void set_list (boost::shared_ptr<Evoral::ControlList>);
+
+	inline bool automation_playback() const {
+		return alist() ? alist()->automation_playback() : false;
+	}
+
+	inline bool automation_write() const {
+		return alist() ? alist()->automation_write() : false;
+	}
+
+	inline AutoState automation_state() const {
+		return alist() ? alist()->automation_state() : Off;
+	}
+
+	inline AutoStyle automation_style() const {
+		return alist() ? alist()->automation_style() : Absolute;
+	}
+
+	void set_automation_state(AutoState as);
+	void set_automation_style(AutoStyle as);
+	void start_touch(double when);
+	void stop_touch(bool mark, double when);
+
+	/* 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; }
+	double normal()  const { return _desc.normal; }
+	bool   toggled() const { return _desc.toggled; }
+
+	double internal_to_interface (double i) const;
+	double interface_to_internal (double i) const;
+
+	const ParameterDescriptor& desc() const { return _desc; }
+
+	const ARDOUR::Session& session() const { return _session; }
+	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>);
 };