correctly handle touch/write automation data merging when it occurs before the start or after the end of existing data

git-svn-id: svn://localhost/ardour2/branches/2.0-ongoing@6944 d708f5d6-7413-0410-9779-e7cbd77b26cf

1 files changed, 52 insertions, 20 deletions

diff --git a/libs/ardour/automation_event.cc b/libs/ardour/automation_event.cc
index cd381565f1..6013122357 100644
--- a/libs/ardour/automation_event.cc
+++ b/libs/ardour/automation_event.cc
@@ -317,45 +317,77 @@ AutomationList::merge_nascent ()
                         return;
                 }
                 
-                cerr << "Merging " << nascent_events.size() << " nascent events\n";
-                
                 iterator i;
+                iterator range_begin = events.end();
+                iterator range_end = events.end();
                 bool inserted = false;
+
                 double lower = nascent_events.front()->when;
                 double upper = nascent_events.back()->when;
-                
-                double clamp_time = upper+1;
-                double clamp_value = unlocked_eval (upper+1);
+                bool preexisting = !events.empty();
+                double clamp_time;
+                double clamp_value;
 
-                cerr << "nascent range = " << lower << " .. " << upper << " will add clamp at " 
-                     << clamp_time << " = " << clamp_value << endl;
-
-                for (i = events.begin(); i != events.end(); ) {
+                if (preexisting) {
+                        clamp_time = upper + 1; // XXX FIX ME
+                        clamp_value = unlocked_eval (clamp_time);
+                }
+                
+                for (i = events.begin(); i != events.end(); ++i) {
                         
-                        /* remove all events within the range defined by nascent events,
+                        /* find the range that overaps with nascent events,
                            and insert the contents of nascent events.
                         */
 
                         if ((*i)->when >= lower) {
 
-                                if (!inserted) {
-                                        events.insert (i, nascent_events.begin(), nascent_events.end());
-                                        cerr << "did insert, events how has " << events.size() << endl;
-                                        events.insert (i, point_factory (clamp_time, clamp_value));
-                                        inserted = true;
+                                if (range_begin == events.end()) {
+                                        range_begin = i;
                                 }
 
-                                if ((*i)->when > upper) {
+                                if ((*i)->when > clamp_time) {
+                                        range_end = i;
                                         break;
                                 }
+                        }
+                }
+
+                if (range_begin == events.end()) {
+
+                        if (range_end == events.end()) {
+
+                                /* nascent events are all after any events in the existing list. insert
+                                   at the back of the list. no clamp point is required.
+                                */
+                                
+                                events.insert (events.end(), nascent_events.begin(), nascent_events.end());
 
-                                i = events.erase (i);
                         } else {
-                                cerr << "skip event at " << (*i)->when << endl;
-                                ++i;
+
+                                /* nascent events are all before any events in the existing list. insert
+                                   at the front of the list, with the clamp value to pull us back to
+                                   any existing points.
+                                */
+                                
+                                events.insert (events.begin(), nascent_events.begin(), nascent_events.end());
+                                if (preexisting) {
+                                        events.insert (events.begin(), point_factory (clamp_time, clamp_value));
+                                }
                         }
+
+                } else {
+                        /* nascent events begin somewhere within in the existing list. insert them,
+                           along with the clamp point if necessary. then delete the existing events
+                           that correspond to the range of nascent events.
+                        */
+
+                        events.insert (range_end, nascent_events.begin(), nascent_events.end());
+                        if (preexisting) {
+                                events.insert (range_end, point_factory (clamp_time, clamp_value));
+                        }
+                        events.erase (range_begin, range_end);
                 }
-                
+
                 nascent_events.clear ();
         }