X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Fautomation_control.h;h=e15abbec46ce58f0594b526d696b9b557c169b2c;hb=fef79d46bb54c0e9179e54a0977eeb602e4b2db3;hp=78f4553d873deb764318913733ac60b42e5b2477;hpb=6f8cd634501efd70711b148b4ac0e0ce2aa5cc95;p=ardour.git

diff --git a/libs/ardour/ardour/automation_control.h b/libs/ardour/ardour/automation_control.h
index 78f4553d87..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,57 +21,132 @@
 #ifndef __ardour_automation_control_h__
 #define __ardour_automation_control_h__
 
+#include <map>
+
+#include <glibmm/threads.h>
+
 #include <boost/shared_ptr.hpp>
-#include <pbd/controllable.h>
-#include <ardour/parameter.h>
-#include <evoral/Control.hpp>
-#include <ardour/automation_list.h>
+#include <boost/enable_shared_from_this.hpp>
+
+#include "pbd/controllable.h"
+
+#include "evoral/types.hpp"
+#include "evoral/Control.hpp"
+
+#include "ardour/automation_list.h"
+#include "ardour/control_group_member.h"
+#include "ardour/parameter_descriptor.h"
+
+#include "ardour/libardour_visibility.h"
 
 namespace ARDOUR {
 
-class AutomationList;
 class Session;
 class Automatable;
+class ControlGroup;
 
-
-/** A PBD:Controllable with associated automation data (AutomationList)
+/** A PBD::Controllable with associated automation data (AutomationList)
  */
-class AutomationControl : public PBD::Controllable, public Evoral::Control
+class LIBARDOUR_API AutomationControl
+	: public PBD::Controllable
+	, public Evoral::Control
+	, public boost::enable_shared_from_this<AutomationControl>
+	, public ControlGroupMember
 {
-public:
+    public:
 	AutomationControl(ARDOUR::Session&,
-			boost::shared_ptr<ARDOUR::AutomationList>,
-			std::string name="unnamed controllable");
-	
-	boost::shared_ptr<AutomationList> alist() const { return boost::dynamic_pointer_cast<AutomationList>(_list); }
+	                  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>);
+	void set_list (boost::shared_ptr<Evoral::ControlList>);
 
 	inline bool automation_playback() const {
-		return ((ARDOUR::AutomationList*)_list.get())->automation_playback();
+		return alist() ? alist()->automation_playback() : false;
 	}
-	
+
 	inline bool automation_write() const {
-		return ((ARDOUR::AutomationList*)_list.get())->automation_write();
+		return alist() ? alist()->automation_write() : false;
 	}
-	
+
 	inline AutoState automation_state() const {
-		return ((ARDOUR::AutomationList*)_list.get())->automation_state();
+		return alist() ? alist()->automation_state() : Off;
 	}
-	
-	inline void start_touch() {
-		return ((ARDOUR::AutomationList*)_list.get())->start_touch();
+
+	inline AutoStyle automation_style() const {
+		return alist() ? alist()->automation_style() : Absolute;
 	}
-	
-	inline void stop_touch() {
-		return ((ARDOUR::AutomationList*)_list.get())->stop_touch();
+
+	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);
 	}
 
-	void set_value(float val);
-	float get_value() const;
+	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;
 
-protected:
+	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>);
 };