Factor out copy-paste code.

[ardour.git] / libs / evoral / evoral / ControlList.hpp

diff --git a/libs/evoral/evoral/ControlList.hpp b/libs/evoral/evoral/ControlList.hpp
index 0774cc528afdfbd2f8b690f50ed57edcfaa06ed6..6353813097c18355b6c0015129a8f3a8f597b1b7 100644 (file)
--- a/libs/evoral/evoral/ControlList.hpp
+++ b/libs/evoral/evoral/ControlList.hpp
@@ -21,19 +21,25 @@
 
 #include <cassert>
 #include <list>
+#include <stdint.h>
+
 #include <boost/pool/pool.hpp>
 #include <boost/pool/pool_alloc.hpp>
+
 #include <glibmm/threads.h>
+
 #include "pbd/signals.h"
 
 #include "evoral/visibility.h"
 #include "evoral/types.hpp"
 #include "evoral/Range.hpp"
 #include "evoral/Parameter.hpp"
+#include "evoral/ParameterDescriptor.hpp"
 
 namespace Evoral {
 
 class Curve;
+class TypeMap;
 
 /** A single event (time-stamped value) for a control
  */
@@ -78,12 +84,12 @@ public:
        typedef EventList::const_iterator const_iterator;
        typedef EventList::const_reverse_iterator const_reverse_iterator;
 
-       ControlList (const Parameter& id);
+       ControlList (const Parameter& id, const ParameterDescriptor& desc);
        ControlList (const ControlList&);
        ControlList (const ControlList&, double start, double end);
        virtual ~ControlList();
 
-       virtual boost::shared_ptr<ControlList> create(Parameter id);
+       virtual boost::shared_ptr<ControlList> create(const Parameter& id, const ParameterDescriptor& desc);
 
         void dump (std::ostream&);
 
@@ -98,6 +104,9 @@ public:
        const Parameter& parameter() const                 { return _parameter; }
        void             set_parameter(const Parameter& p) { _parameter = p; }
 
+       const ParameterDescriptor& descriptor() const                           { return _desc; }
+       void                       set_descriptor(const ParameterDescriptor& d) { _desc = d; }
+
        EventList::size_type size() const { return _events.size(); }
         double length() const {                
                Glib::Threads::Mutex::Lock lm (_lock);
@@ -115,9 +124,9 @@ public:
        void slide (iterator before, double distance);
        void shift (double before, double distance);
 
-       virtual bool clamp_value (double& /*when*/, double& /*value*/) const { return true; }
-
-        virtual void add (double when, double value, bool with_guards=true);
+       virtual void add (double when, double value, bool with_guards=true, bool with_default=true);
+       virtual void editor_add (double when, double value);
+       
        void fast_simple_add (double when, double value);
 
        void erase_range (double start, double end);
@@ -127,13 +136,26 @@ public:
        bool move_ranges (std::list< RangeMove<double> > const &);
        void modify (iterator, double, double);
 
-        void thin ();
+       /** Thin the number of events in this list.
+        *
+        * The thinning factor has no units but corresponds to the area of a
+        * triangle computed between three points in the list.  If the area is
+        * large, it indicates significant non-linearity between the points.
+        *
+        * During automation recording we thin the recorded points using this
+        * value.  If a point is sufficiently co-linear with its neighbours (as
+        * defined by the area of the triangle formed by three of them), we will
+        * not include it in the list.  The larger the value, the more points are
+        * excluded, so this effectively measures the amount of thinning to be
+        * done.
+        */
+       void thin (double thinning_factor);
 
        boost::shared_ptr<ControlList> cut (double, double);
        boost::shared_ptr<ControlList> copy (double, double);
        void clear (double, double);
 
-       bool paste (ControlList&, double position, float times);
+       bool paste (const ControlList&, double position, float times);
 
        void set_yrange (double min, double max) {
                _min_yval = min;
@@ -201,7 +223,7 @@ public:
        };
 
        const EventList& events() const { return _events; }
-       double default_value() const { return _parameter.normal(); }
+       double default_value() const { return _default_value; }
 
        // FIXME: const violations for Curve
        Glib::Threads::Mutex& lock()         const { return _lock; }
@@ -241,7 +263,7 @@ public:
        virtual bool writing() const { return false; }
        virtual bool touch_enabled() const { return false; }
         void start_write_pass (double time);
-       void write_pass_finished (double when);
+        void write_pass_finished (double when, double thinning_factor=0.0);
         void set_in_write_pass (bool, bool add_point = false, double when = 0.0);
         bool in_write_pass () const;
 
@@ -250,9 +272,6 @@ public:
        /** Emitted when our interpolation style changes */
        PBD::Signal1<void, InterpolationStyle> InterpolationChanged;
 
-        static void set_thinning_factor (double d);
-        static double thinning_factor() { return _thinning_factor; }
-
        bool operator!= (ControlList const &) const;
 
         void invalidate_insert_iterator ();
@@ -267,6 +286,10 @@ protected:
        boost::shared_ptr<ControlList> cut_copy_clear (double, double, int op);
        bool erase_range_internal (double start, double end, EventList &);
 
+       void     maybe_add_insert_guard (double when);
+       iterator erase_from_iterator_to (iterator iter, double when);
+       bool     maybe_insert_straight_line (double when, double value);
+
        virtual void maybe_signal_changed ();
 
        void _x_scale (double factor);
@@ -274,10 +297,12 @@ protected:
        mutable LookupCache   _lookup_cache;
        mutable SearchCache   _search_cache;
 
+       mutable Glib::Threads::Mutex _lock;
+
        Parameter             _parameter;
+       ParameterDescriptor   _desc;
        InterpolationStyle    _interpolation;
        EventList             _events;
-       mutable Glib::Threads::Mutex   _lock;
        int8_t                _frozen;
        bool                  _changed_when_thawed;
        double                _min_yval;
@@ -287,8 +312,6 @@ protected:
 
        Curve* _curve;
 
-        static double _thinning_factor;
-
   private:
     iterator   most_recent_insert_iterator;
     double     insert_position;