X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fplaylist.cc;h=3301fe9f9ece1a7305f1a6bebd7f5d84af8b4825;hb=17ace643e4edbec1e5bd7b446d039f8c94beef75;hp=47462a3575be3b19274698290d9dbf861f68a3d8;hpb=c0e6f8e4c324c3f44613949b59acd9e864ab263d;p=ardour.git

diff --git a/libs/ardour/playlist.cc b/libs/ardour/playlist.cc
index 47462a3575..3301fe9f9e 100644
--- a/libs/ardour/playlist.cc
+++ b/libs/ardour/playlist.cc
@@ -141,7 +141,7 @@ Playlist::Playlist (Session& sess, const XMLNode& node, DataType type, bool hide
 	, _type(type)
 {
 #ifndef NDEBUG
-	const XMLProperty* prop = node.property("type");
+	XMLProperty const * prop = node.property("type");
 	assert(!prop || DataType(prop->value()) == _type);
 #endif
 
@@ -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));
@@ -550,6 +557,7 @@ Playlist::notify_region_added (boost::shared_ptr<Region> r)
 		pending_contents_change = false;
 		RegionAdded (boost::weak_ptr<Region> (r)); /* EMIT SIGNAL */
 		ContentsChanged (); /* EMIT SIGNAL */
+
 	}
 }
 
@@ -595,7 +603,7 @@ Playlist::flush_notifications (bool from_undo)
 		remove_dependents (*s);
 		RegionRemoved (boost::weak_ptr<Region> (*s)); /* EMIT SIGNAL */
 	}
-	
+
 	for (s = pending_adds.begin(); s != pending_adds.end(); ++s) {
 		crossfade_ranges.push_back ((*s)->range ());
 		/* don't emit RegionAdded signal until relayering is done,
@@ -604,37 +612,41 @@ Playlist::flush_notifications (bool from_undo)
 		*/
 	}
 
-	if (((regions_changed || pending_contents_change) && !in_set_state) || pending_layering) {
-		relayer ();
+	/* notify about contents/region changes first so that layering changes
+	 * in a UI will take place on the new contents.
+	 */
+
+	if (regions_changed || pending_contents_change) {
+		pending_layering = true;
+		ContentsChanged (); /* EMIT SIGNAL */
 	}
 
-	 if (regions_changed || pending_contents_change) {
-		 pending_contents_change = false;
-		 ContentsChanged (); /* EMIT SIGNAL */
-	 }
+	for (s = pending_adds.begin(); s != pending_adds.end(); ++s) {
+		(*s)->clear_changes ();
+		RegionAdded (boost::weak_ptr<Region> (*s)); /* EMIT SIGNAL */
+	}
 
-	 for (s = pending_adds.begin(); s != pending_adds.end(); ++s) {
-		 (*s)->clear_changes ();
-		 RegionAdded (boost::weak_ptr<Region> (*s)); /* EMIT SIGNAL */
-	 }
+	if ((regions_changed && !in_set_state) || pending_layering) {
+		relayer ();
+	}
 
-	 coalesce_and_check_crossfades (crossfade_ranges);
+	coalesce_and_check_crossfades (crossfade_ranges);
 
-	 if (!pending_range_moves.empty ()) {
-		 /* We don't need to check crossfades for these as pending_bounds has
-		    already covered it.
-		 */
-		 RangesMoved (pending_range_moves, from_undo);
-	 }
+	if (!pending_range_moves.empty ()) {
+		/* We don't need to check crossfades for these as pending_bounds has
+		   already covered it.
+		*/
+		RangesMoved (pending_range_moves, from_undo);
+	}
 
-	 if (!pending_region_extensions.empty ()) {
-		 RegionsExtended (pending_region_extensions);
-	 }
+	if (!pending_region_extensions.empty ()) {
+		RegionsExtended (pending_region_extensions);
+	}
 
-	 clear_pending ();
+	clear_pending ();
 
-	 in_flush = false;
- }
+	in_flush = false;
+}
 
  void
  Playlist::clear_pending ()
@@ -706,7 +718,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 +1114,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 +1202,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);
  }
 
@@ -1208,11 +1225,11 @@ Playlist::flush_notifications (bool from_undo)
 			 while (itimes--) {
 				 for (RegionList::iterator i = other->regions.begin(); i != other->regions.end(); ++i) {
 					 boost::shared_ptr<Region> copy_of_region = RegionFactory::create (*i, true);
-					 
+
 					 /* put these new regions on top of all existing ones, but preserve
 					    the ordering they had in the original playlist.
 					 */
-					 
+
 					 add_region_internal (copy_of_region, (*i)->position() + pos);
 					 set_layer (copy_of_region, copy_of_region->layer() + top);
 				 }
@@ -1227,18 +1244,24 @@ Playlist::flush_notifications (bool from_undo)
 
  void
  Playlist::duplicate (boost::shared_ptr<Region> region, framepos_t position, float times)
+ {
+	 duplicate(region, position, region->length(), times);
+ }
+
+/** @param gap from the beginning of the region to the next beginning */
+ void
+ Playlist::duplicate (boost::shared_ptr<Region> region, framepos_t position, framecnt_t gap, float times)
  {
 	 times = fabs (times);
 
 	 RegionWriteLock rl (this);
 	 int itimes = (int) floor (times);
-	 framepos_t pos = position + 1;
 
 	 while (itimes--) {
 		 boost::shared_ptr<Region> copy = RegionFactory::create (region, true);
-		 add_region_internal (copy, pos);
+		 add_region_internal (copy, position);
 		 set_layer (copy, DBL_MAX);
-		 pos += region->length();
+		 position += gap;
 	 }
 
 	 if (floor (times) != times) {
@@ -1254,12 +1277,78 @@ Playlist::flush_notifications (bool from_undo)
 			 plist.add (Properties::name, name);
 
 			 boost::shared_ptr<Region> sub = RegionFactory::create (region, plist);
-			 add_region_internal (sub, pos);
+			 add_region_internal (sub, position);
 			 set_layer (sub, DBL_MAX);
 		 }
 	 }
  }
 
+/** @param gap from the beginning of the region to the next beginning */
+/** @param end the first frame that does _not_ contain a duplicated frame */
+void
+Playlist::duplicate_until (boost::shared_ptr<Region> region, framepos_t position, framecnt_t gap, framepos_t end)
+{
+	 RegionWriteLock rl (this);
+
+	 while (position + region->length() - 1 < end) {
+		 boost::shared_ptr<Region> copy = RegionFactory::create (region, true);
+		 add_region_internal (copy, position);
+		 set_layer (copy, DBL_MAX);
+		 position += gap;
+	 }
+
+	 if (position < end) {
+		 framecnt_t length = min (region->length(), end - position);
+		 string name;
+		 RegionFactory::region_name (name, region->name(), false);
+
+		 {
+			 PropertyList plist;
+
+			 plist.add (Properties::start, region->start());
+			 plist.add (Properties::length, length);
+			 plist.add (Properties::name, name);
+
+			 boost::shared_ptr<Region> sub = RegionFactory::create (region, plist);
+			 add_region_internal (sub, position);
+			 set_layer (sub, DBL_MAX);
+		 }
+	 }
+}
+
+void
+Playlist::duplicate_range (AudioRange& range, float times)
+{
+	boost::shared_ptr<Playlist> pl = copy (range.start, range.length(), true);
+	framecnt_t offset = range.end - range.start;
+	paste (pl, range.start + offset, times);
+}
+
+void
+Playlist::duplicate_ranges (std::list<AudioRange>& ranges, float /* times */)
+{
+	if (ranges.empty()) {
+		return;
+	}
+
+	framepos_t min_pos = max_framepos;
+	framepos_t max_pos = 0;
+
+	for (std::list<AudioRange>::const_iterator i = ranges.begin();
+	     i != ranges.end();
+	     ++i) {
+		min_pos = min (min_pos, (*i).start);
+		max_pos = max (max_pos, (*i).end);
+	}
+
+	framecnt_t offset = max_pos - min_pos;
+
+	for (list<AudioRange>::iterator i = ranges.begin(); i != ranges.end(); ++i) {
+		boost::shared_ptr<Playlist> pl = copy ((*i).start, (*i).length(), true);
+		paste (pl, (*i).start + offset, 1.0f); // times ??
+	}
+}
+
  void
  Playlist::shift (framepos_t at, frameoffset_t distance, bool move_intersected, bool ignore_music_glue)
  {
@@ -1352,7 +1441,6 @@ Playlist::flush_notifications (bool from_undo)
 	 {
 		 PropertyList plist;
 
-		 plist.add (Properties::position, region->position ());
 		 plist.add (Properties::length, before);
 		 plist.add (Properties::name, before_name);
 		 plist.add (Properties::left_of_split, true);
@@ -1371,7 +1459,6 @@ Playlist::flush_notifications (bool from_undo)
 	 {
 		 PropertyList plist;
 
-		 plist.add (Properties::position, region->position() + before);
 		 plist.add (Properties::length, after);
 		 plist.add (Properties::name, after_name);
 		 plist.add (Properties::right_of_split, true);
@@ -1456,12 +1543,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;
 	 }
 
@@ -1574,6 +1712,8 @@ Playlist::flush_notifications (bool from_undo)
 		 save = true;
 	 }
 
+	 mark_session_dirty ();
+
 	 return save;
  }
 
@@ -1629,7 +1769,7 @@ Playlist::flush_notifications (bool from_undo)
 
  }
 
- /***********************************************************************
+ /* *********************************************************************
   FINDING THINGS
   **********************************************************************/
 
@@ -1706,15 +1846,15 @@ boost::shared_ptr<RegionList>
 Playlist::find_regions_at (framepos_t frame)
 {
 	/* Caller must hold lock */
-	
+
 	boost::shared_ptr<RegionList> rlist (new RegionList);
-	
+
 	for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
 		if ((*i)->covers (frame)) {
 			rlist->push_back (*i);
 		}
 	}
-	
+
 	return rlist;
 }
 
@@ -1763,13 +1903,13 @@ boost::shared_ptr<RegionList>
 Playlist::regions_touched_locked (framepos_t start, framepos_t end)
 {
 	boost::shared_ptr<RegionList> rlist (new RegionList);
-	
+
 	for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
 		if ((*i)->coverage (start, end) != Evoral::OverlapNone) {
 			rlist->push_back (*i);
 		}
 	}
-	
+
 	return rlist;
 }
 
@@ -1779,7 +1919,7 @@ Playlist::find_next_transient (framepos_t from, int dir)
 	RegionReadLock rlock (this);
 	AnalysisFeatureList points;
 	AnalysisFeatureList these_points;
-	
+
 	for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
 		if (dir > 0) {
 			if ((*i)->last_frame() < from) {
@@ -1790,30 +1930,30 @@ Playlist::find_next_transient (framepos_t from, int dir)
 				continue;
 			}
 		}
-		
+
 		(*i)->get_transients (these_points);
-		
+
 		/* add first frame, just, err, because */
-		
+
 		these_points.push_back ((*i)->first_frame());
-		
+
 		points.insert (points.end(), these_points.begin(), these_points.end());
 		these_points.clear ();
 	}
-	
+
 	if (points.empty()) {
 		return -1;
 	}
-	
+
 	TransientDetector::cleanup_transients (points, _session.frame_rate(), 3.0);
 	bool reached = false;
-	
+
 	if (dir > 0) {
-		for (AnalysisFeatureList::iterator x = points.begin(); x != points.end(); ++x) {
+		for (AnalysisFeatureList::const_iterator x = points.begin(); x != points.end(); ++x) {
 			if ((*x) >= from) {
 				reached = true;
 			}
-			
+
 			if (reached && (*x) > from) {
 				return *x;
 			}
@@ -1823,13 +1963,13 @@ Playlist::find_next_transient (framepos_t from, int dir)
 			if ((*x) <= from) {
 				reached = true;
 			}
-			
+
 			if (reached && (*x) < from) {
 				return *x;
 			}
 		}
 	}
-	
+
 	return -1;
 }
 
@@ -1839,17 +1979,17 @@ Playlist::find_next_region (framepos_t frame, RegionPoint point, int dir)
 	RegionReadLock rlock (this);
 	boost::shared_ptr<Region> ret;
 	framepos_t closest = max_framepos;
-	
+
 	bool end_iter = false;
-	
+
 	for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
-		
+
 		if(end_iter) break;
-		
+
 		frameoffset_t distance;
 		boost::shared_ptr<Region> r = (*i);
 		framepos_t pos = 0;
-		
+
 		switch (point) {
 		case Start:
 			pos = r->first_frame ();
@@ -1861,10 +2001,10 @@ Playlist::find_next_region (framepos_t frame, RegionPoint point, int dir)
 			pos = r->sync_position ();
 			break;
 		}
-		
+
 		switch (dir) {
 		case 1: /* forwards */
-			
+
 			if (pos > frame) {
 				if ((distance = pos - frame) < closest) {
 					closest = distance;
@@ -1872,11 +2012,11 @@ Playlist::find_next_region (framepos_t frame, RegionPoint point, int dir)
 					end_iter = true;
 				}
 			}
-			
+
 			break;
-			
+
 		default: /* backwards */
-			
+
 			if (pos < frame) {
 				if ((distance = frame - pos) < closest) {
 					closest = distance;
@@ -1885,11 +2025,11 @@ Playlist::find_next_region (framepos_t frame, RegionPoint point, int dir)
 			} else {
 				end_iter = true;
 			}
-			
+
 			break;
 		}
 	}
-	
+
 	return ret;
 }
 
@@ -2016,7 +2156,7 @@ Playlist::find_next_region (framepos_t frame, RegionPoint point, int dir)
 	 XMLNodeConstIterator niter;
 	 XMLPropertyList plist;
 	 XMLPropertyConstIterator piter;
-	 XMLProperty *prop;
+	 XMLProperty const * prop;
 	 boost::shared_ptr<Region> region;
 	 string region_name;
 	 bool seen_region_nodes = false;
@@ -2093,7 +2233,7 @@ Playlist::find_next_region (framepos_t frame, RegionPoint point, int dir)
 				 RegionWriteLock rlock (this);
 				 add_region_internal (region, region->position());
 			 }
-			
+
 			region->resume_property_changes ();
 
 		}
@@ -2102,7 +2242,7 @@ Playlist::find_next_region (framepos_t frame, RegionPoint point, int dir)
 	if (seen_region_nodes && regions.empty()) {
 		ret = -1;
 	}
-		
+
 	thaw ();
 	notify_contents_changed ();
 
@@ -2189,6 +2329,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
 {
@@ -2257,7 +2405,10 @@ struct RelayerSort {
 void
 Playlist::set_layer (boost::shared_ptr<Region> region, double new_layer)
 {
-	/* Remove the layer we are setting from our region list, and sort it */
+	/* Remove the layer we are setting from our region list, and sort it
+	*  using the layer indeces.
+	*/
+
 	RegionList copy = regions.rlist();
 	copy.remove (region);
 	copy.sort (RelayerSort ());
@@ -2270,7 +2421,7 @@ Playlist::set_layer (boost::shared_ptr<Region> region, double new_layer)
 		}
 		++i;
 	}
-	
+
 	copy.insert (i, region);
 
 	setup_layering_indices (copy);
@@ -2280,13 +2431,18 @@ void
 Playlist::setup_layering_indices (RegionList const & regions)
 {
 	uint64_t j = 0;
-	list<Evoral::Range<framepos_t> > xf;
 
 	for (RegionList::const_iterator k = regions.begin(); k != regions.end(); ++k) {
 		(*k)->set_layering_index (j++);
 	}
 }
 
+struct LaterHigherSort {
+	bool operator () (boost::shared_ptr<Region> a, boost::shared_ptr<Region> b) {
+		return a->position() < b->position();
+	}
+};
+
 /** Take the layering indices of each of our regions, compute the layers
  *  that they should be on, and write the layers back to the regions.
  */
@@ -2321,9 +2477,16 @@ Playlist::relayer ()
 	vector<vector<RegionList> > layers;
 	layers.push_back (vector<RegionList> (divisions));
 
-	/* Sort our regions into layering index order */
+	/* Sort our regions into layering index order (for manual layering) or position order (for later is higher)*/
 	RegionList copy = regions.rlist();
-	copy.sort (RelayerSort ());
+	switch (Config->get_layer_model()) {
+		case LaterHigher:
+			copy.sort (LaterHigherSort ());
+			break;
+		case Manual:
+			copy.sort (RelayerSort ());
+			break;
+	}
 
 	DEBUG_TRACE (DEBUG::Layering, "relayer() using:\n");
 	for (RegionList::iterator i = copy.begin(); i != copy.end(); ++i) {
@@ -2525,6 +2688,29 @@ Playlist::region_use_count (boost::shared_ptr<Region> r) const
 		}
 	}
 
+	RegionFactory::CompoundAssociations& cassocs (RegionFactory::compound_associations());
+	for (RegionFactory::CompoundAssociations::iterator it = cassocs.begin(); it != cassocs.end(); ++it) {
+		/* check if region is used in a compound */
+		if (it->second == r) {
+			/* region is referenced as 'original' of a compound */
+			++cnt;
+			break;
+		}
+		if (r->whole_file() && r->max_source_level() > 0) {
+			/* region itself ia a compound.
+			 * the compound regions are not referenced -> check regions inside compound
+			 */
+			const SourceList& sl = r->sources();
+			for (SourceList::const_iterator s = sl.begin(); s != sl.end(); ++s) {
+				boost::shared_ptr<PlaylistSource> ps = boost::dynamic_pointer_cast<PlaylistSource>(*s);
+				if (!ps) continue;
+				if (ps->playlist()->region_use_count(it->first)) {
+					// break out of both loops
+					return ++cnt;
+				}
+			}
+		}
+	}
 	return cnt;
 }
 
@@ -2694,6 +2880,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 ()
 {
@@ -2712,7 +2904,7 @@ Playlist::update_after_tempo_map_change ()
 void
 Playlist::foreach_region (boost::function<void(boost::shared_ptr<Region>)> s)
 {
-	RegionWriteLock rl (this, false);
+	RegionReadLock rl (this);
 	for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
 		s (*i);
 	}
@@ -2809,7 +3001,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 +3153,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()) {
@@ -2973,7 +3173,7 @@ Playlist::uncombine (boost::shared_ptr<Region> target)
 		}
 
 		/* check to see how the original region (in the
-		 * playlist before compounding occured) overlaps
+		 * playlist before compounding occurred) overlaps
 		 * with the new state of the compound region.
 		 */
 
@@ -3050,12 +3250,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
 {
@@ -3095,6 +3309,7 @@ restart:
 				continue;
 			}
 
+			// XXX i->from can be > i->to - is this right? coverage() will return OverlapNone in this case
 			if (Evoral::coverage (i->from, i->to, j->from, j->to) != Evoral::OverlapNone) {
 				i->from = min (i->from, j->from);
 				i->to = max (i->to, j->to);