re-reference regions during uncombine - #5979

[ardour.git] / libs / ardour / playlist.cc

diff --git a/libs/ardour/playlist.cc b/libs/ardour/playlist.cc
index 47462a3575be3b19274698290d9dbf861f68a3d8..c8cca64b782d69bdb899dfbe6782b88924ad59fb 100644 (file)
--- a/libs/ardour/playlist.cc
+++ b/libs/ardour/playlist.cc
@@ -172,6 +172,7 @@ Playlist::Playlist (boost::shared_ptr<const Playlist> other, string namestr, boo
        in_set_state--;
 
        _splicing  = other->_splicing;
+       _rippling  = other->_rippling;
        _nudging   = other->_nudging;
        _edit_mode = other->_edit_mode;
 
@@ -255,6 +256,10 @@ Playlist::Playlist (boost::shared_ptr<const Playlist> other, framepos_t start, f
                add_region_internal (new_region, position);
        }
 
+       //keep track of any dead space at end (for pasting into Ripple or Splice mode)
+       //at the end of construction, any length of cnt beyond the extents of the regions is end_space
+       _end_space = cnt - (get_extent().second - get_extent().first);
+
        in_set_state--;
        first_set_state = false;
 }
@@ -302,6 +307,7 @@ Playlist::init (bool hide)
        _refcnt = 0;
        _hidden = hide;
        _splicing = false;
+       _rippling = false;
        _shuffling = false;
        _nudging = false;
        in_set_state = 0;
@@ -313,6 +319,7 @@ Playlist::init (bool hide)
        _frozen = false;
        _capture_insertion_underway = false;
        _combine_ops = 0;
+       _end_space = 0;
 
        _session.history().BeginUndoRedo.connect_same_thread (*this, boost::bind (&Playlist::begin_undo, this));
        _session.history().EndUndoRedo.connect_same_thread (*this, boost::bind (&Playlist::end_undo, this));
@@ -706,7 +713,7 @@ Playlist::flush_notifications (bool from_undo)
                 }
         }
 
-        possibly_splice_unlocked (position, (pos + length) - position, boost::shared_ptr<Region>());
+        possibly_splice_unlocked (position, (pos + length) - position, region);
  }
 
  void
@@ -1102,6 +1109,10 @@ Playlist::flush_notifications (bool from_undo)
 
                 in_partition = false;
         }
+
+       //keep track of any dead space at end (for pasting into Ripple or Splice mode)
+       framepos_t wanted_length = end-start;
+       _end_space = wanted_length - get_extent().second-get_extent().first;
  }
 
  boost::shared_ptr<Playlist>
@@ -1186,7 +1197,8 @@ Playlist::flush_notifications (bool from_undo)
         new_name += '.';
         new_name += buf;
 
-        cnt = min (_get_extent().second - start, cnt);
+       // cnt = min (_get_extent().second - start, cnt);  (We need the full range length when copy/pasting in Ripple.  Why was this limit here?  It's not in CUT... )
+
         return PlaylistFactory::create (shared_from_this(), start, cnt, new_name, result_is_hidden);
  }
 
@@ -1399,7 +1411,7 @@ Playlist::flush_notifications (bool from_undo)
 
         if (_edit_mode == Splice) {
                 splice_locked (at, distance, exclude);
-        }
+        } 
  }
 
  void
@@ -1456,12 +1468,63 @@ Playlist::flush_notifications (bool from_undo)
         _splicing = false;
 
         notify_contents_changed ();
- }
+}
 
- void
- Playlist::region_bounds_changed (const PropertyChange& what_changed, boost::shared_ptr<Region> region)
- {
-        if (in_set_state || _splicing || _nudging || _shuffling) {
+void
+Playlist::ripple_locked (framepos_t at, framecnt_t distance, RegionList *exclude)
+{
+       {
+               RegionWriteLock rl (this);
+               core_ripple (at, distance, exclude);
+       }
+}
+
+void
+Playlist::ripple_unlocked (framepos_t at, framecnt_t distance, RegionList *exclude)
+{
+       core_ripple (at, distance, exclude);
+}
+
+void
+Playlist::core_ripple (framepos_t at, framecnt_t distance, RegionList *exclude)
+{
+       if (distance == 0) {
+               return;
+       }
+
+       _rippling = true;
+       RegionListProperty copy = regions;
+       for (RegionList::iterator i = copy.begin(); i != copy.end(); ++i) {
+               assert (i != copy.end());
+
+               if (exclude) {
+                       if (std::find(exclude->begin(), exclude->end(), (*i)) != exclude->end()) {
+                               continue;
+                       }
+               }
+
+               if ((*i)->position() >= at) {
+                       framepos_t new_pos = (*i)->position() + distance;
+                       framepos_t limit = max_framepos - (*i)->length();
+                       if (new_pos < 0) {
+                               new_pos = 0;
+                       } else if (new_pos >= limit ) {
+                               new_pos = limit;
+                       } 
+                               
+                       (*i)->set_position (new_pos);
+               }
+       }
+
+       _rippling = false;
+       notify_contents_changed ();
+}
+
+
+void
+Playlist::region_bounds_changed (const PropertyChange& what_changed, boost::shared_ptr<Region> region)
+{
+        if (in_set_state || _splicing || _rippling || _nudging || _shuffling) {
                 return;
         }
 
@@ -2189,6 +2252,14 @@ Playlist::get_extent () const
        return _get_extent ();
 }
 
+pair<framepos_t, framepos_t>
+Playlist::get_extent_with_endspace () const
+{
+       pair<framepos_t, framepos_t> l = get_extent();
+       l.second += _end_space;
+       return l;
+}
+
 pair<framepos_t, framepos_t>
 Playlist::_get_extent () const
 {
@@ -2694,6 +2765,12 @@ Playlist::region_is_shuffle_constrained (boost::shared_ptr<Region>)
        return false;
 }
 
+void
+Playlist::ripple (framepos_t at, framecnt_t distance, RegionList *exclude)
+{
+       ripple_locked (at, distance, exclude);
+}
+
 void
 Playlist::update_after_tempo_map_change ()
 {
@@ -2809,7 +2886,14 @@ Playlist::combine (const RegionList& r)
 
        pl->in_partition = true;
 
-       for (RegionList::const_iterator i = r.begin(); i != r.end(); ++i) {
+       /* sort by position then layer.
+        * route_time_axis passes 'selected_regions' - which is not sorted.
+        * here we need the top-most first, then every layer's region sorted by position.
+        */
+       RegionList sorted(r);
+       sorted.sort(RegionSortByLayerAndPosition());
+
+       for (RegionList::const_iterator i = sorted.begin(); i != sorted.end(); ++i) {
 
                /* copy the region */
 
@@ -2954,6 +3038,7 @@ Playlist::uncombine (boost::shared_ptr<Region> target)
                }
 
                boost::shared_ptr<Region> original (ca->second);
+               cassocs.erase(ca);
                bool modified_region;
 
                if (i == rl.begin()) {
@@ -3050,12 +3135,26 @@ Playlist::uncombine (boost::shared_ptr<Region> target)
 
        for (vector<boost::shared_ptr<Region> >::iterator i = originals.begin(); i != originals.end(); ++i) {
                add_region ((*i), (*i)->position());
+               set_layer((*i), (*i)->layer());
+               if (!RegionFactory::region_by_id((*i)->id())) {
+                       RegionFactory::map_add(*i);
+               }
        }
 
        in_partition = false;
        thaw ();
 }
 
+void
+Playlist::fade_range (list<AudioRange>& ranges)
+{
+        for (list<AudioRange>::iterator r = ranges.begin(); r != ranges.end(); ++r) {
+                for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
+                        (*i)->fade_range ((*r).start, (*r).end);
+                }
+        }
+}
+
 uint32_t
 Playlist::max_source_level () const
 {