X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fplaylist.cc;h=19c02051c04b0582d5682e835846eca4a39c3423;hb=66163305317e8acf20c4a16b9709fc809d6a0ff9;hp=47462a3575be3b19274698290d9dbf861f68a3d8;hpb=0da34e65e3470b1c2298ddf571df6356d0d42bd8;p=ardour.git

diff --git a/libs/ardour/playlist.cc b/libs/ardour/playlist.cc
index 47462a3575..19c02051c0 100644
--- a/libs/ardour/playlist.cc
+++ b/libs/ardour/playlist.cc
@@ -26,6 +26,7 @@
 
 #include "pbd/convert.h"
 #include "pbd/stateful_diff_command.h"
+#include "pbd/strsplit.h"
 #include "pbd/xml++.h"
 
 #include "ardour/debug.h"
@@ -40,7 +41,7 @@
 #include "ardour/session_playlists.h"
 #include "ardour/source_factory.h"
 
-#include "i18n.h"
+#include "pbd/i18n.h"
 
 using namespace std;
 using namespace ARDOUR;
@@ -141,7 +142,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
 
@@ -157,6 +158,7 @@ Playlist::Playlist (boost::shared_ptr<const Playlist> other, string namestr, boo
 	, regions (*this)
 	, _type(other->_type)
 	, _orig_track_id (other->_orig_track_id)
+	, _shared_with_ids (other->_shared_with_ids)
 {
 	init (hide);
 
@@ -172,6 +174,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;
 
@@ -188,6 +191,7 @@ Playlist::Playlist (boost::shared_ptr<const Playlist> other, framepos_t start, f
 	, regions (*this)
 	, _type(other->_type)
 	, _orig_track_id (other->_orig_track_id)
+	, _shared_with_ids (other->_shared_with_ids)
 {
 	RegionReadLock rlock2 (const_cast<Playlist*> (other.get()));
 
@@ -255,6 +259,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 +310,7 @@ Playlist::init (bool hide)
 	_refcnt = 0;
 	_hidden = hide;
 	_splicing = false;
+	_rippling = false;
 	_shuffling = false;
 	_nudging = false;
 	in_set_state = 0;
@@ -313,6 +322,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 +560,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 +606,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,645 +615,709 @@ 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 ()
- {
-	 pending_adds.clear ();
-	 pending_removes.clear ();
-	 pending_bounds.clear ();
-	 pending_range_moves.clear ();
-	 pending_region_extensions.clear ();
-	 pending_contents_change = false;
- }
+void
+Playlist::clear_pending ()
+{
+	pending_adds.clear ();
+	pending_removes.clear ();
+	pending_bounds.clear ();
+	pending_range_moves.clear ();
+	pending_region_extensions.clear ();
+	pending_contents_change = false;
+	pending_layering = false;
+}
 
- /*************************************************************
+/*************************************************************
    PLAYLIST OPERATIONS
-  *************************************************************/
+*************************************************************/
 
 /** Note: this calls set_layer (..., DBL_MAX) so it will reset the layering index of region */
- void
- Playlist::add_region (boost::shared_ptr<Region> region, framepos_t position, float times, bool auto_partition)
- {
-	 RegionWriteLock rlock (this);
-	 times = fabs (times);
-
-	 int itimes = (int) floor (times);
-
-	 framepos_t pos = position;
+void
+Playlist::add_region (boost::shared_ptr<Region> region, framepos_t position, float times, bool auto_partition, int32_t sub_num, double quarter_note, bool for_music)
+{
+	RegionWriteLock rlock (this);
+	times = fabs (times);
 
-	 if (times == 1 && auto_partition){
-		 partition(pos - 1, (pos + region->length()), true);
-	 }
+	int itimes = (int) floor (times);
 
-	 if (itimes >= 1) {
-		 add_region_internal (region, pos);
-		 set_layer (region, DBL_MAX);
-		 pos += region->length();
-		 --itimes;
-	 }
+	framepos_t pos = position;
 
+	if (times == 1 && auto_partition){
+		RegionList thawlist;
+		partition_internal (pos - 1, (pos + region->length()), true, thawlist);
+		for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) {
+			(*i)->resume_property_changes ();
+			_session.add_command (new StatefulDiffCommand (*i));
+		}
+	}
 
-	 /* note that itimes can be zero if we being asked to just
-	    insert a single fraction of the region.
-	 */
+	if (itimes >= 1) {
+		add_region_internal (region, pos, sub_num, quarter_note, for_music);
+		set_layer (region, DBL_MAX);
+		pos += region->length();
+		--itimes;
+	}
 
-	 for (int i = 0; i < itimes; ++i) {
-		 boost::shared_ptr<Region> copy = RegionFactory::create (region, true);
-		 add_region_internal (copy, pos);
-		 set_layer (copy, DBL_MAX);
-		 pos += region->length();
-	 }
+	/* note that itimes can be zero if we being asked to just
+	   insert a single fraction of the region.
+	*/
 
-	 framecnt_t length = 0;
+	for (int i = 0; i < itimes; ++i) {
+		boost::shared_ptr<Region> copy = RegionFactory::create (region, true);
+		add_region_internal (copy, pos, sub_num);
+		set_layer (copy, DBL_MAX);
+		pos += region->length();
+	}
 
-	 if (floor (times) != times) {
-		 length = (framecnt_t) floor (region->length() * (times - floor (times)));
-		 string name;
-		 RegionFactory::region_name (name, region->name(), false);
+	framecnt_t length = 0;
 
-		 {
-			 PropertyList plist;
+	if (floor (times) != times) {
+		length = (framecnt_t) floor (region->length() * (times - floor (times)));
+		string name;
+		RegionFactory::region_name (name, region->name(), false);
 
-			 plist.add (Properties::start, region->start());
-			 plist.add (Properties::length, length);
-			 plist.add (Properties::name, name);
-			 plist.add (Properties::layer, region->layer());
+		{
+			PropertyList plist;
 
-			 boost::shared_ptr<Region> sub = RegionFactory::create (region, plist);
-			 add_region_internal (sub, pos);
-			 set_layer (sub, DBL_MAX);
-		 }
-	 }
+			plist.add (Properties::start, region->start());
+			plist.add (Properties::length, length);
+			plist.add (Properties::name, name);
+			plist.add (Properties::layer, region->layer());
 
-	 possibly_splice_unlocked (position, (pos + length) - position, boost::shared_ptr<Region>());
- }
-
- void
- Playlist::set_region_ownership ()
- {
-	 RegionWriteLock rl (this);
-	 RegionList::iterator i;
-	 boost::weak_ptr<Playlist> pl (shared_from_this());
+			boost::shared_ptr<Region> sub = RegionFactory::create (region, plist);
+			add_region_internal (sub, pos, sub_num);
+			set_layer (sub, DBL_MAX);
+		}
+	}
 
-	 for (i = regions.begin(); i != regions.end(); ++i) {
-		 (*i)->set_playlist (pl);
-	 }
- }
+	possibly_splice_unlocked (position, (pos + length) - position, region);
+}
 
- bool
- Playlist::add_region_internal (boost::shared_ptr<Region> region, framepos_t position)
- {
-	 if (region->data_type() != _type) {
-		 return false;
-	 }
+void
+Playlist::set_region_ownership ()
+{
+	RegionWriteLock rl (this);
+	RegionList::iterator i;
+	boost::weak_ptr<Playlist> pl (shared_from_this());
 
-	 RegionSortByPosition cmp;
+	for (i = regions.begin(); i != regions.end(); ++i) {
+		(*i)->set_playlist (pl);
+	}
+}
 
-	 if (!first_set_state) {
-		 boost::shared_ptr<Playlist> foo (shared_from_this());
-		 region->set_playlist (boost::weak_ptr<Playlist>(foo));
-	 }
+bool
+Playlist::add_region_internal (boost::shared_ptr<Region> region, framepos_t position, int32_t sub_num, double quarter_note, bool for_music)
+{
+	if (region->data_type() != _type) {
+		return false;
+	}
 
-	 region->set_position (position);
+	RegionSortByPosition cmp;
 
-	 regions.insert (upper_bound (regions.begin(), regions.end(), region, cmp), region);
-	 all_regions.insert (region);
+	if (!first_set_state) {
+		boost::shared_ptr<Playlist> foo (shared_from_this());
+		region->set_playlist (boost::weak_ptr<Playlist>(foo));
+	}
+	if (for_music) {
+		region->set_position_music (quarter_note);
+	} else {
+		region->set_position (position, sub_num);
+	}
 
-	 possibly_splice_unlocked (position, region->length(), region);
+	regions.insert (upper_bound (regions.begin(), regions.end(), region, cmp), region);
+	all_regions.insert (region);
 
-	 if (!holding_state ()) {
-		 /* layers get assigned from XML state, and are not reset during undo/redo */
-		 relayer ();
-	 }
+	possibly_splice_unlocked (position, region->length(), region);
 
-	 /* we need to notify the existence of new region before checking dependents. Ick. */
+	if (!holding_state ()) {
+		/* layers get assigned from XML state, and are not reset during undo/redo */
+		relayer ();
+	}
 
-	 notify_region_added (region);
+	/* we need to notify the existence of new region before checking dependents. Ick. */
 
-	 region->PropertyChanged.connect_same_thread (region_state_changed_connections, boost::bind (&Playlist::region_changed_proxy, this, _1, boost::weak_ptr<Region> (region)));
+	notify_region_added (region);
 
-	 return true;
- }
+	region->PropertyChanged.connect_same_thread (region_state_changed_connections, boost::bind (&Playlist::region_changed_proxy, this, _1, boost::weak_ptr<Region> (region)));
+	region->DropReferences.connect_same_thread (region_drop_references_connections, boost::bind (&Playlist::region_going_away, this, boost::weak_ptr<Region> (region)));
 
- void
- Playlist::replace_region (boost::shared_ptr<Region> old, boost::shared_ptr<Region> newr, framepos_t pos)
- {
-	 RegionWriteLock rlock (this);
+	return true;
+}
 
-	 bool old_sp = _splicing;
-	 _splicing = true;
+void
+Playlist::replace_region (boost::shared_ptr<Region> old, boost::shared_ptr<Region> newr, framepos_t pos)
+{
+	RegionWriteLock rlock (this);
 
-	 remove_region_internal (old);
-	 add_region_internal (newr, pos);
-	 set_layer (newr, old->layer ());
+	bool old_sp = _splicing;
+	_splicing = true;
 
-	 _splicing = old_sp;
+	remove_region_internal (old);
+	add_region_internal (newr, pos);
+	set_layer (newr, old->layer ());
 
-	 possibly_splice_unlocked (pos, old->length() - newr->length());
- }
+	_splicing = old_sp;
 
- void
- Playlist::remove_region (boost::shared_ptr<Region> region)
- {
-	 RegionWriteLock rlock (this);
-	 remove_region_internal (region);
- }
+	possibly_splice_unlocked (pos, old->length() - newr->length());
+}
 
- int
- Playlist::remove_region_internal (boost::shared_ptr<Region> region)
- {
-	 RegionList::iterator i;
+void
+Playlist::remove_region (boost::shared_ptr<Region> region)
+{
+	RegionWriteLock rlock (this);
+	remove_region_internal (region);
+}
 
-	 if (!in_set_state) {
-		 /* unset playlist */
-		 region->set_playlist (boost::weak_ptr<Playlist>());
-	 }
+int
+Playlist::remove_region_internal (boost::shared_ptr<Region> region)
+{
+	RegionList::iterator i;
 
-	 /* XXX should probably freeze here .... */
+	if (!in_set_state) {
+		/* unset playlist */
+		region->set_playlist (boost::weak_ptr<Playlist>());
+	}
 
-	 for (i = regions.begin(); i != regions.end(); ++i) {
-		 if (*i == region) {
+	/* XXX should probably freeze here .... */
 
-			 framepos_t pos = (*i)->position();
-			 framecnt_t distance = (*i)->length();
+	for (i = regions.begin(); i != regions.end(); ++i) {
+		if (*i == region) {
 
-			 regions.erase (i);
+			framepos_t pos = (*i)->position();
+			framecnt_t distance = (*i)->length();
 
-			 possibly_splice_unlocked (pos, -distance);
+			regions.erase (i);
 
-			 if (!holding_state ()) {
-				 relayer ();
-				 remove_dependents (region);
-			 }
+			possibly_splice_unlocked (pos, -distance);
 
-			 notify_region_removed (region);
-			 break;
-		 }
-	 }
+			if (!holding_state ()) {
+				relayer ();
+				remove_dependents (region);
+			}
 
-	 return -1;
- }
+			notify_region_removed (region);
+			break;
+		}
+	}
 
- void
- Playlist::get_equivalent_regions (boost::shared_ptr<Region> other, vector<boost::shared_ptr<Region> >& results)
- {
-	 if (Config->get_use_overlap_equivalency()) {
-		 for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
-			 if ((*i)->overlap_equivalent (other)) {
-				 results.push_back (*i);
-			 }
-		 }
-	 } else {
-		 for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
-			 if ((*i)->equivalent (other)) {
-				 results.push_back (*i);
-			 }
-		 }
-	 }
- }
+	return -1;
+}
 
- void
- Playlist::get_region_list_equivalent_regions (boost::shared_ptr<Region> other, vector<boost::shared_ptr<Region> >& results)
- {
-	 for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+void
+Playlist::get_equivalent_regions (boost::shared_ptr<Region> other, vector<boost::shared_ptr<Region> >& results)
+{
+	if (Config->get_use_overlap_equivalency()) {
+		for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+			if ((*i)->overlap_equivalent (other)) {
+				results.push_back (*i);
+			}
+		}
+	} else {
+		for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+			if ((*i)->equivalent (other)) {
+				results.push_back (*i);
+			}
+		}
+	}
+}
 
-		 if ((*i) && (*i)->region_list_equivalent (other)) {
-			 results.push_back (*i);
-		 }
-	 }
- }
+void
+Playlist::get_region_list_equivalent_regions (boost::shared_ptr<Region> other, vector<boost::shared_ptr<Region> >& results)
+{
+	for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
 
- void
- Playlist::get_source_equivalent_regions (boost::shared_ptr<Region> other, vector<boost::shared_ptr<Region> >& results)
- {
-	 for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+		if ((*i) && (*i)->region_list_equivalent (other)) {
+			results.push_back (*i);
+		}
+	}
+}
 
-		 if ((*i) && (*i)->any_source_equivalent (other)) {
-			 results.push_back (*i);
-		 }
-	 }
- }
+void
+Playlist::get_source_equivalent_regions (boost::shared_ptr<Region> other, vector<boost::shared_ptr<Region> >& results)
+{
+	for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
 
- void
- Playlist::partition (framepos_t start, framepos_t end, bool cut)
- {
-	 RegionList thawlist;
+		if ((*i) && (*i)->any_source_equivalent (other)) {
+			results.push_back (*i);
+		}
+	}
+}
 
-	 partition_internal (start, end, cut, thawlist);
+void
+Playlist::partition (framepos_t start, framepos_t end, bool cut)
+{
+	RegionList thawlist;
+	{
+		RegionWriteLock lock(this);
+		partition_internal (start, end, cut, thawlist);
+	}
 
-	 for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) {
-		 (*i)->resume_property_changes ();
-	 }
- }
+	for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) {
+		(*i)->resume_property_changes ();
+	}
+}
 
 /** Go through each region on the playlist and cut them at start and end, removing the section between
  *  start and end if cutting == true.  Regions that lie entirely within start and end are always
  *  removed.
  */
 
- void
- Playlist::partition_internal (framepos_t start, framepos_t end, bool cutting, RegionList& thawlist)
- {
-	 RegionList new_regions;
+void
+Playlist::partition_internal (framepos_t start, framepos_t end, bool cutting, RegionList& thawlist)
+{
+	RegionList new_regions;
 
-	 {
-		 RegionWriteLock rlock (this);
+	{
 
-		 boost::shared_ptr<Region> region;
-		 boost::shared_ptr<Region> current;
-		 string new_name;
-		 RegionList::iterator tmp;
-		 Evoral::OverlapType overlap;
-		 framepos_t pos1, pos2, pos3, pos4;
+		boost::shared_ptr<Region> region;
+		boost::shared_ptr<Region> current;
+		string new_name;
+		RegionList::iterator tmp;
+		Evoral::OverlapType overlap;
+		framepos_t pos1, pos2, pos3, pos4;
 
-		 in_partition = true;
+		in_partition = true;
 
-		 /* need to work from a copy, because otherwise the regions we add during the process
-		    get operated on as well.
-		 */
+		/* need to work from a copy, because otherwise the regions we add during the process
+		   get operated on as well.
+		*/
 
-		 RegionList copy = regions.rlist();
+		RegionList copy = regions.rlist();
 
-		 for (RegionList::iterator i = copy.begin(); i != copy.end(); i = tmp) {
+		for (RegionList::iterator i = copy.begin(); i != copy.end(); i = tmp) {
 
-			 tmp = i;
-			 ++tmp;
+			tmp = i;
+			++tmp;
 
-			 current = *i;
+			current = *i;
 
-			 if (current->first_frame() >= start && current->last_frame() < end) {
+			if (current->first_frame() >= start && current->last_frame() < end) {
 
-				 if (cutting) {
-					 remove_region_internal (current);
-				 }
+				if (cutting) {
+					remove_region_internal (current);
+				}
 
-				 continue;
-			 }
+				continue;
+			}
 
-			 /* coverage will return OverlapStart if the start coincides
-			    with the end point. we do not partition such a region,
-			    so catch this special case.
-			 */
+			/* coverage will return OverlapStart if the start coincides
+			   with the end point. we do not partition such a region,
+			   so catch this special case.
+			*/
 
-			 if (current->first_frame() >= end) {
-				 continue;
-			 }
+			if (current->first_frame() >= end) {
+				continue;
+			}
 
-			 if ((overlap = current->coverage (start, end)) == Evoral::OverlapNone) {
-				 continue;
-			 }
+			if ((overlap = current->coverage (start, end)) == Evoral::OverlapNone) {
+				continue;
+			}
 
-			 pos1 = current->position();
-			 pos2 = start;
-			 pos3 = end;
-			 pos4 = current->last_frame();
-
-			 if (overlap == Evoral::OverlapInternal) {
-				 /* split: we need 3 new regions, the front, middle and end.
-				    cut:   we need 2 regions, the front and end.
-				 */
-
-				 /*
-					  start                 end
-			   ---------------*************************------------
-					  P1  P2              P3  P4
-			   SPLIT:
-			   ---------------*****++++++++++++++++====------------
-			   CUT
-			   ---------------*****----------------====------------
-
-				 */
-
-				 if (!cutting) {
-					 /* "middle" ++++++ */
-
-					 RegionFactory::region_name (new_name, current->name(), false);
-
-					 PropertyList plist;
-
-					 plist.add (Properties::start, current->start() + (pos2 - pos1));
-					 plist.add (Properties::length, pos3 - pos2);
-					 plist.add (Properties::name, new_name);
-					 plist.add (Properties::layer, current->layer ());
-					 plist.add (Properties::layering_index, current->layering_index ());
-					 plist.add (Properties::automatic, true);
-					 plist.add (Properties::left_of_split, true);
-					 plist.add (Properties::right_of_split, true);
-
-					 region = RegionFactory::create (current, plist);
-					 add_region_internal (region, start);
-					 new_regions.push_back (region);
-				 }
+			pos1 = current->position();
+			pos2 = start;
+			pos3 = end;
+			pos4 = current->last_frame();
+
+			if (overlap == Evoral::OverlapInternal) {
+				/* split: we need 3 new regions, the front, middle and end.
+				   cut:   we need 2 regions, the front and end.
+				*/
+
+				/*
+				  start                 end
+				  ---------------*************************------------
+				  P1  P2              P3  P4
+				  SPLIT:
+				  ---------------*****++++++++++++++++====------------
+				  CUT
+				  ---------------*****----------------====------------
+
+				*/
+
+				if (!cutting) {
+					/* "middle" ++++++ */
+
+					RegionFactory::region_name (new_name, current->name(), false);
+
+					PropertyList plist;
+
+					plist.add (Properties::start, current->start() + (pos2 - pos1));
+					plist.add (Properties::length, pos3 - pos2);
+					plist.add (Properties::name, new_name);
+					plist.add (Properties::layer, current->layer ());
+					plist.add (Properties::layering_index, current->layering_index ());
+					plist.add (Properties::automatic, true);
+					plist.add (Properties::left_of_split, true);
+					plist.add (Properties::right_of_split, true);
+
+					region = RegionFactory::create (current, plist);
+					add_region_internal (region, start);
+					new_regions.push_back (region);
+				}
 
-				 /* "end" ====== */
+				/* "end" ====== */
 
-				 RegionFactory::region_name (new_name, current->name(), false);
+				RegionFactory::region_name (new_name, current->name(), false);
 
-				 PropertyList plist;
+				PropertyList plist;
 
-				 plist.add (Properties::start, current->start() + (pos3 - pos1));
-				 plist.add (Properties::length, pos4 - pos3);
-				 plist.add (Properties::name, new_name);
-				 plist.add (Properties::layer, current->layer ());
-				 plist.add (Properties::layering_index, current->layering_index ());
-				 plist.add (Properties::automatic, true);
-				 plist.add (Properties::right_of_split, true);
+				plist.add (Properties::start, current->start() + (pos3 - pos1));
+				plist.add (Properties::length, pos4 - pos3);
+				plist.add (Properties::name, new_name);
+				plist.add (Properties::layer, current->layer ());
+				plist.add (Properties::layering_index, current->layering_index ());
+				plist.add (Properties::automatic, true);
+				plist.add (Properties::right_of_split, true);
 
-				 region = RegionFactory::create (current, plist);
+				region = RegionFactory::create (current, plist);
 
-				 add_region_internal (region, end);
-				 new_regions.push_back (region);
+				add_region_internal (region, end);
+				new_regions.push_back (region);
 
-				 /* "front" ***** */
+				/* "front" ***** */
 
-				 current->suspend_property_changes ();
-				 thawlist.push_back (current);
-				 current->cut_end (pos2 - 1);
+				current->clear_changes ();
+				current->suspend_property_changes ();
+				thawlist.push_back (current);
+				current->cut_end (pos2 - 1);
 
-			 } else if (overlap == Evoral::OverlapEnd) {
+			} else if (overlap == Evoral::OverlapEnd) {
 
-				 /*
-							       start           end
-				     ---------------*************************------------
-						    P1           P2         P4   P3
-				     SPLIT:
-				     ---------------**************+++++++++++------------
-				     CUT:
-				     ---------------**************-----------------------
-				 */
+				/*
+				  start           end
+				  ---------------*************************------------
+				  P1           P2         P4   P3
+				  SPLIT:
+				  ---------------**************+++++++++++------------
+				  CUT:
+				  ---------------**************-----------------------
+				*/
 
-				 if (!cutting) {
+				if (!cutting) {
 
-					 /* end +++++ */
+					/* end +++++ */
 
-					 RegionFactory::region_name (new_name, current->name(), false);
+					RegionFactory::region_name (new_name, current->name(), false);
 
-					 PropertyList plist;
+					PropertyList plist;
 
-					 plist.add (Properties::start, current->start() + (pos2 - pos1));
-					 plist.add (Properties::length, pos4 - pos2);
-					 plist.add (Properties::name, new_name);
-					 plist.add (Properties::layer, current->layer ());
-					 plist.add (Properties::layering_index, current->layering_index ());
-					 plist.add (Properties::automatic, true);
-					 plist.add (Properties::left_of_split, true);
+					plist.add (Properties::start, current->start() + (pos2 - pos1));
+					plist.add (Properties::length, pos4 - pos2);
+					plist.add (Properties::name, new_name);
+					plist.add (Properties::layer, current->layer ());
+					plist.add (Properties::layering_index, current->layering_index ());
+					plist.add (Properties::automatic, true);
+					plist.add (Properties::left_of_split, true);
 
-					 region = RegionFactory::create (current, plist);
+					region = RegionFactory::create (current, plist);
 
-					 add_region_internal (region, start);
-					 new_regions.push_back (region);
-				 }
+					add_region_internal (region, start);
+					new_regions.push_back (region);
+				}
 
-				 /* front ****** */
+				/* front ****** */
 
-				 current->suspend_property_changes ();
-				 thawlist.push_back (current);
-				 current->cut_end (pos2 - 1);
+				current->clear_changes ();
+				current->suspend_property_changes ();
+				thawlist.push_back (current);
+				current->cut_end (pos2 - 1);
 
-			 } else if (overlap == Evoral::OverlapStart) {
+			} else if (overlap == Evoral::OverlapStart) {
 
-				 /* split: we need 2 regions: the front and the end.
-				    cut: just trim current to skip the cut area
-				 */
+				/* split: we need 2 regions: the front and the end.
+				   cut: just trim current to skip the cut area
+				*/
 
-				 /*
-							 start           end
-				     ---------------*************************------------
-					P2          P1 P3                   P4
+				/*
+				  start           end
+				  ---------------*************************------------
+				  P2          P1 P3                   P4
 
-				     SPLIT:
-				     ---------------****+++++++++++++++++++++------------
-				     CUT:
-				     -------------------*********************------------
+				  SPLIT:
+				  ---------------****+++++++++++++++++++++------------
+				  CUT:
+				  -------------------*********************------------
 
-				 */
+				*/
 
-				 if (!cutting) {
-					 /* front **** */
-					 RegionFactory::region_name (new_name, current->name(), false);
+				if (!cutting) {
+					/* front **** */
+					RegionFactory::region_name (new_name, current->name(), false);
 
-					 PropertyList plist;
+					PropertyList plist;
 
-					 plist.add (Properties::start, current->start());
-					 plist.add (Properties::length, pos3 - pos1);
-					 plist.add (Properties::name, new_name);
-					 plist.add (Properties::layer, current->layer ());
-					 plist.add (Properties::layering_index, current->layering_index ());
-					 plist.add (Properties::automatic, true);
-					 plist.add (Properties::right_of_split, true);
+					plist.add (Properties::start, current->start());
+					plist.add (Properties::length, pos3 - pos1);
+					plist.add (Properties::name, new_name);
+					plist.add (Properties::layer, current->layer ());
+					plist.add (Properties::layering_index, current->layering_index ());
+					plist.add (Properties::automatic, true);
+					plist.add (Properties::right_of_split, true);
 
-					 region = RegionFactory::create (current, plist);
+					region = RegionFactory::create (current, plist);
 
-					 add_region_internal (region, pos1);
-					 new_regions.push_back (region);
-				 }
+					add_region_internal (region, pos1);
+					new_regions.push_back (region);
+				}
 
-				 /* end */
+				/* end */
 
-				 current->suspend_property_changes ();
-				 thawlist.push_back (current);
-				 current->trim_front (pos3);
-			 } else if (overlap == Evoral::OverlapExternal) {
+				current->clear_changes ();
+				current->suspend_property_changes ();
+				thawlist.push_back (current);
+				current->trim_front (pos3);
+			} else if (overlap == Evoral::OverlapExternal) {
 
-				 /* split: no split required.
-				    cut: remove the region.
-				 */
+				/* split: no split required.
+				   cut: remove the region.
+				*/
 
-				 /*
-					start                                      end
-				     ---------------*************************------------
-					P2          P1 P3                   P4
+				/*
+				  start                                      end
+				  ---------------*************************------------
+				  P2          P1 P3                   P4
 
-				     SPLIT:
-				     ---------------*************************------------
-				     CUT:
-				     ----------------------------------------------------
+				  SPLIT:
+				  ---------------*************************------------
+				  CUT:
+				  ----------------------------------------------------
 
-				 */
+				*/
 
-				 if (cutting) {
-					 remove_region_internal (current);
-				 }
+				if (cutting) {
+					remove_region_internal (current);
+				}
 
-				 new_regions.push_back (current);
-			 }
-		 }
+				new_regions.push_back (current);
+			}
+		}
 
-		 in_partition = false;
-	 }
- }
+		in_partition = false;
+	}
 
- boost::shared_ptr<Playlist>
- Playlist::cut_copy (boost::shared_ptr<Playlist> (Playlist::*pmf)(framepos_t, framecnt_t,bool), list<AudioRange>& ranges, bool result_is_hidden)
- {
-	 boost::shared_ptr<Playlist> ret;
-	 boost::shared_ptr<Playlist> pl;
-	 framepos_t start;
+	//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;
+}
 
-	 if (ranges.empty()) {
-		 return boost::shared_ptr<Playlist>();
-	 }
+boost::shared_ptr<Playlist>
+Playlist::cut_copy (boost::shared_ptr<Playlist> (Playlist::*pmf)(framepos_t, framecnt_t,bool), list<AudioRange>& ranges, bool result_is_hidden)
+{
+	boost::shared_ptr<Playlist> ret;
+	boost::shared_ptr<Playlist> pl;
+	framepos_t start;
 
-	 start = ranges.front().start;
+	if (ranges.empty()) {
+		return boost::shared_ptr<Playlist>();
+	}
 
-	 for (list<AudioRange>::iterator i = ranges.begin(); i != ranges.end(); ++i) {
+	start = ranges.front().start;
 
-		 pl = (this->*pmf)((*i).start, (*i).length(), result_is_hidden);
+	for (list<AudioRange>::iterator i = ranges.begin(); i != ranges.end(); ++i) {
 
-		 if (i == ranges.begin()) {
-			 ret = pl;
-		 } else {
+		pl = (this->*pmf)((*i).start, (*i).length(), result_is_hidden);
 
-			 /* paste the next section into the nascent playlist,
-			    offset to reflect the start of the first range we
-			    chopped.
-			 */
+		if (i == ranges.begin()) {
+			ret = pl;
+		} else {
 
-			 ret->paste (pl, (*i).start - start, 1.0f);
-		 }
-	 }
+			/* paste the next section into the nascent playlist,
+			   offset to reflect the start of the first range we
+			   chopped.
+			*/
 
-	 return ret;
- }
+			ret->paste (pl, (*i).start - start, 1.0f, 0);
+		}
+	}
 
- boost::shared_ptr<Playlist>
- Playlist::cut (list<AudioRange>& ranges, bool result_is_hidden)
- {
-	 boost::shared_ptr<Playlist> (Playlist::*pmf)(framepos_t,framecnt_t,bool) = &Playlist::cut;
-	 return cut_copy (pmf, ranges, result_is_hidden);
- }
+	return ret;
+}
 
- boost::shared_ptr<Playlist>
- Playlist::copy (list<AudioRange>& ranges, bool result_is_hidden)
- {
-	 boost::shared_ptr<Playlist> (Playlist::*pmf)(framepos_t,framecnt_t,bool) = &Playlist::copy;
-	 return cut_copy (pmf, ranges, result_is_hidden);
- }
+boost::shared_ptr<Playlist>
+Playlist::cut (list<AudioRange>& ranges, bool result_is_hidden)
+{
+	boost::shared_ptr<Playlist> (Playlist::*pmf)(framepos_t,framecnt_t,bool) = &Playlist::cut;
+	return cut_copy (pmf, ranges, result_is_hidden);
+}
 
- boost::shared_ptr<Playlist>
- Playlist::cut (framepos_t start, framecnt_t cnt, bool result_is_hidden)
- {
-	 boost::shared_ptr<Playlist> the_copy;
-	 RegionList thawlist;
-	 char buf[32];
+boost::shared_ptr<Playlist>
+Playlist::copy (list<AudioRange>& ranges, bool result_is_hidden)
+{
+	boost::shared_ptr<Playlist> (Playlist::*pmf)(framepos_t,framecnt_t,bool) = &Playlist::copy;
+	return cut_copy (pmf, ranges, result_is_hidden);
+}
 
-	 snprintf (buf, sizeof (buf), "%" PRIu32, ++subcnt);
-	 string new_name = _name;
-	 new_name += '.';
-	 new_name += buf;
+boost::shared_ptr<Playlist>
+Playlist::cut (framepos_t start, framecnt_t cnt, bool result_is_hidden)
+{
+	boost::shared_ptr<Playlist> the_copy;
+	RegionList thawlist;
+	char buf[32];
 
-	 if ((the_copy = PlaylistFactory::create (shared_from_this(), start, cnt, new_name, result_is_hidden)) == 0) {
-		 return boost::shared_ptr<Playlist>();
-	 }
+	snprintf (buf, sizeof (buf), "%" PRIu32, ++subcnt);
+	string new_name = _name;
+	new_name += '.';
+	new_name += buf;
 
-	 partition_internal (start, start+cnt-1, true, thawlist);
+	if ((the_copy = PlaylistFactory::create (shared_from_this(), start, cnt, new_name, result_is_hidden)) == 0) {
+		return boost::shared_ptr<Playlist>();
+	}
 
-	 for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) {
-		 (*i)->resume_property_changes();
-	 }
+	{
+		RegionWriteLock rlock (this);
+		partition_internal (start, start+cnt-1, true, thawlist);
+	}
 
-	 return the_copy;
- }
+	for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) {
+		(*i)->resume_property_changes();
+	}
 
- boost::shared_ptr<Playlist>
- Playlist::copy (framepos_t start, framecnt_t cnt, bool result_is_hidden)
- {
-	 char buf[32];
+	return the_copy;
+}
 
-	 snprintf (buf, sizeof (buf), "%" PRIu32, ++subcnt);
-	 string new_name = _name;
-	 new_name += '.';
-	 new_name += buf;
+boost::shared_ptr<Playlist>
+Playlist::copy (framepos_t start, framecnt_t cnt, bool result_is_hidden)
+{
+	char buf[32];
 
-	 cnt = min (_get_extent().second - start, cnt);
-	 return PlaylistFactory::create (shared_from_this(), start, cnt, new_name, result_is_hidden);
- }
+	snprintf (buf, sizeof (buf), "%" PRIu32, ++subcnt);
+	string new_name = _name;
+	new_name += '.';
+	new_name += buf;
 
- int
- Playlist::paste (boost::shared_ptr<Playlist> other, framepos_t position, float times)
- {
-	 times = fabs (times);
+	// 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... )
 
-	 {
-		 RegionReadLock rl2 (other.get());
+	return PlaylistFactory::create (shared_from_this(), start, cnt, new_name, result_is_hidden);
+}
 
-		 int itimes = (int) floor (times);
-		 framepos_t pos = position;
-		 framecnt_t const shift = other->_get_extent().second;
-		 layer_t top = top_layer ();
+int
+Playlist::paste (boost::shared_ptr<Playlist> other, framepos_t position, float times, const int32_t sub_num)
+{
+	times = fabs (times);
 
-		 {
-			 RegionWriteLock rl1 (this);
-			 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);
-				 }
-				 pos += shift;
-			 }
-		 }
-	 }
+	{
+		RegionReadLock rl2 (other.get());
 
-	 return 0;
- }
+		int itimes = (int) floor (times);
+		framepos_t pos = position;
+		framecnt_t const shift = other->_get_extent().second;
+		layer_t top = top_layer ();
 
+		{
+			RegionWriteLock rl1 (this);
+			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);
 
- void
- Playlist::duplicate (boost::shared_ptr<Region> region, framepos_t position, float times)
- {
-	 times = fabs (times);
+					/* 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, sub_num);
+					set_layer (copy_of_region, copy_of_region->layer() + top);
+				}
+				pos += shift;
+			}
+		}
+	}
+
+	return 0;
+}
+
+
+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);
+
+	while (itimes--) {
+		boost::shared_ptr<Region> copy = RegionFactory::create (region, true);
+		add_region_internal (copy, position);
+		set_layer (copy, DBL_MAX);
+		position += gap;
+	}
+
+	if (floor (times) != times) {
+		framecnt_t length = (framecnt_t) floor (region->length() * (times - floor (times)));
+		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);
+		}
+	}
+}
+
+/** @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);
-	 int itimes = (int) floor (times);
-	 framepos_t pos = position + 1;
 
-	 while (itimes--) {
+	 while (position + region->length() - 1 < end) {
 		 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) {
-		 framecnt_t length = (framecnt_t) floor (region->length() * (times - floor (times)));
+	 if (position < end) {
+		 framecnt_t length = min (region->length(), end - position);
 		 string name;
 		 RegionFactory::region_name (name, region->name(), false);
 
@@ -1254,11 +1329,49 @@ 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);
 		 }
 	 }
- }
+}
+
+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, 0);
+}
+
+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;
+
+	int count = 1;
+	int itimes = (int) floor (times);
+	while (itimes--) {
+		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 * count), 1.0f, 0);
+		}
+		++count;
+	}
+}
 
  void
  Playlist::shift (framepos_t at, frameoffset_t distance, bool move_intersected, bool ignore_music_glue)
@@ -1295,12 +1408,12 @@ Playlist::flush_notifications (bool from_undo)
 
 	 /* XXX: may not be necessary; Region::post_set should do this, I think */
 	 for (RegionList::iterator r = fixup.begin(); r != fixup.end(); ++r) {
-		 (*r)->recompute_position_from_lock_style ();
+		 (*r)->recompute_position_from_lock_style (0);
 	 }
  }
 
  void
- Playlist::split (framepos_t at)
+ Playlist::split (const MusicFrame& at)
  {
 	 RegionWriteLock rlock (this);
 	 RegionList copy (regions.rlist());
@@ -1314,28 +1427,29 @@ Playlist::flush_notifications (bool from_undo)
  }
 
  void
- Playlist::split_region (boost::shared_ptr<Region> region, framepos_t playlist_position)
+ Playlist::split_region (boost::shared_ptr<Region> region, const MusicFrame& playlist_position)
  {
 	 RegionWriteLock rl (this);
 	 _split_region (region, playlist_position);
  }
 
  void
- Playlist::_split_region (boost::shared_ptr<Region> region, framepos_t playlist_position)
+ Playlist::_split_region (boost::shared_ptr<Region> region, const MusicFrame& playlist_position)
  {
-	 if (!region->covers (playlist_position)) {
+	 if (!region->covers (playlist_position.frame)) {
 		 return;
 	 }
 
-	 if (region->position() == playlist_position ||
-	     region->last_frame() == playlist_position) {
+	 if (region->position() == playlist_position.frame ||
+	     region->last_frame() == playlist_position.frame) {
 		 return;
 	 }
 
 	 boost::shared_ptr<Region> left;
 	 boost::shared_ptr<Region> right;
-	 frameoffset_t before;
-	 frameoffset_t after;
+
+	 MusicFrame before (playlist_position.frame - region->position(), playlist_position.division);
+	 MusicFrame after (region->length() - before.frame, 0);
 	 string before_name;
 	 string after_name;
 
@@ -1344,16 +1458,12 @@ Playlist::flush_notifications (bool from_undo)
 	 bool old_sp = _splicing;
 	 _splicing = true;
 
-	 before = playlist_position - region->position();
-	 after = region->length() - before;
-
 	 RegionFactory::region_name (before_name, region->name(), false);
 
 	 {
 		 PropertyList plist;
 
-		 plist.add (Properties::position, region->position ());
-		 plist.add (Properties::length, before);
+		 plist.add (Properties::length, before.frame);
 		 plist.add (Properties::name, before_name);
 		 plist.add (Properties::left_of_split, true);
 		 plist.add (Properties::layering_index, region->layering_index ());
@@ -1363,7 +1473,7 @@ Playlist::flush_notifications (bool from_undo)
 		    since it supplies that offset to the Region constructor, which
 		    is necessary to get audio region gain envelopes right.
 		 */
-		 left = RegionFactory::create (region, 0, plist);
+		 left = RegionFactory::create (region, MusicFrame (0, 0), plist, true);
 	 }
 
 	 RegionFactory::region_name (after_name, region->name(), false);
@@ -1371,19 +1481,19 @@ Playlist::flush_notifications (bool from_undo)
 	 {
 		 PropertyList plist;
 
-		 plist.add (Properties::position, region->position() + before);
-		 plist.add (Properties::length, after);
+		 plist.add (Properties::length, after.frame);
 		 plist.add (Properties::name, after_name);
 		 plist.add (Properties::right_of_split, true);
 		 plist.add (Properties::layering_index, region->layering_index ());
 		 plist.add (Properties::layer, region->layer ());
 
 		 /* same note as above */
-		 right = RegionFactory::create (region, before, plist);
+		 right = RegionFactory::create (region, before, plist, true);
 	 }
 
-	 add_region_internal (left, region->position());
-	 add_region_internal (right, region->position() + before);
+	 add_region_internal (left, region->position(), 0);
+	 add_region_internal (right, region->position() + before.frame, before.division);
+
 	 remove_region_internal (region);
 
 	 _splicing = old_sp;
@@ -1456,12 +1566,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 +1735,8 @@ Playlist::flush_notifications (bool from_undo)
 		 save = true;
 	 }
 
+	 mark_session_dirty ();
+
 	 return save;
  }
 
@@ -1604,6 +1767,7 @@ Playlist::flush_notifications (bool from_undo)
 		 RegionWriteLock rl (this);
 
 		 region_state_changed_connections.drop_connections ();
+		 region_drop_references_connections.drop_connections ();
 
 		 for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
 			 pending_removes.insert (*i);
@@ -1629,10 +1793,28 @@ Playlist::flush_notifications (bool from_undo)
 
  }
 
- /***********************************************************************
+ /* *********************************************************************
   FINDING THINGS
   **********************************************************************/
 
+boost::shared_ptr<RegionList>
+Playlist::region_list()
+{
+	RegionReadLock rlock (this);
+	boost::shared_ptr<RegionList> rlist (new RegionList (regions.rlist ()));
+	return rlist;
+}
+
+void
+Playlist::deep_sources (std::set<boost::shared_ptr<Source> >& sources) const
+{
+	RegionReadLock rlock (const_cast<Playlist*>(this));
+
+	for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
+		(*i)->deep_sources (sources);
+	}
+}
+
 boost::shared_ptr<RegionList>
 Playlist::regions_at (framepos_t frame)
 {
@@ -1682,6 +1864,7 @@ Playlist::regions_at (framepos_t frame)
 	 for (RegionList::iterator i = rlist->begin(); i != rlist->end(); ) {
 
 		 RegionList::iterator tmp = i;
+
 		 ++tmp;
 
 		 if ((*i)->muted()) {
@@ -1706,15 +1889,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 +1946,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 +1962,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 +1973,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 +2006,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 +2022,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 +2044,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 +2055,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 +2068,11 @@ Playlist::find_next_region (framepos_t frame, RegionPoint point, int dir)
 			} else {
 				end_iter = true;
 			}
-			
+
 			break;
 		}
 	}
-	
+
 	return ret;
 }
 
@@ -1907,23 +2090,25 @@ Playlist::find_next_region (framepos_t frame, RegionPoint point, int dir)
 
 			 boost::shared_ptr<Region> r = (*i);
 			 frameoffset_t distance;
+			 const framepos_t first_frame = r->first_frame();
+			 const framepos_t last_frame = r->last_frame();
 
-			 if (r->first_frame() > frame) {
+			 if (first_frame > frame) {
 
-				 distance = r->first_frame() - frame;
+				 distance = first_frame - frame;
 
 				 if (distance < closest) {
-					 ret = r->first_frame();
+					 ret = first_frame;
 					 closest = distance;
 				 }
 			 }
 
-			 if (r->last_frame () > frame) {
+			 if (last_frame > frame) {
 
-				 distance = r->last_frame () - frame;
+				 distance = last_frame - frame;
 
 				 if (distance < closest) {
-					 ret = r->last_frame ();
+					 ret = last_frame;
 					 closest = distance;
 				 }
 			 }
@@ -1935,23 +2120,25 @@ Playlist::find_next_region (framepos_t frame, RegionPoint point, int dir)
 
 			 boost::shared_ptr<Region> r = (*i);
 			 frameoffset_t distance;
+			 const framepos_t first_frame = r->first_frame();
+			 const framepos_t last_frame = r->last_frame();
 
-			 if (r->last_frame() < frame) {
+			 if (last_frame < frame) {
 
-				 distance = frame - r->last_frame();
+				 distance = frame - last_frame;
 
 				 if (distance < closest) {
-					 ret = r->last_frame();
+					 ret = last_frame;
 					 closest = distance;
 				 }
 			 }
 
-			 if (r->first_frame() < frame) {
+			 if (first_frame < frame) {
 
-				 distance = frame - r->first_frame();
+				 distance = frame - first_frame;
 
 				 if (distance < closest) {
-					 ret = r->first_frame();
+					 ret = first_frame;
 					 closest = distance;
 				 }
 			 }
@@ -2016,7 +2203,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;
@@ -2051,6 +2238,16 @@ Playlist::find_next_region (framepos_t frame, RegionPoint point, int dir)
 			 _frozen = string_is_affirmative (prop->value());
 		 } else if (prop->name() == X_("combine-ops")) {
 			 _combine_ops = atoi (prop->value());
+		 } else if (prop->name() == X_("shared-with-ids")) {
+			 string shared_ids = prop->value ();
+			 if (!shared_ids.empty()) {
+				vector<string> result;
+				::split (shared_ids, result, ',');
+				vector<string>::iterator it = result.begin();
+				for (; it != result.end(); ++it) {
+					_shared_with_ids.push_back (PBD::ID(*it));
+				}
+			 }
 		 }
 	 }
 
@@ -2093,7 +2290,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 +2299,7 @@ Playlist::find_next_region (framepos_t frame, RegionPoint point, int dir)
 	if (seen_region_nodes && regions.empty()) {
 		ret = -1;
 	}
-		
+
 	thaw ();
 	notify_contents_changed ();
 
@@ -2138,6 +2335,17 @@ Playlist::state (bool full_state)
 
 	_orig_track_id.print (buf, sizeof (buf));
 	node->add_property (X_("orig-track-id"), buf);
+
+	string shared_ids;
+	list<PBD::ID>::const_iterator it = _shared_with_ids.begin();
+	for (; it != _shared_with_ids.end(); ++it) {
+		shared_ids += "," + (*it).to_s();
+	}
+	if (!shared_ids.empty()) {
+		shared_ids.erase(0,1);
+	}
+
+	node->add_property (X_("shared-with-ids"), shared_ids);
 	node->add_property (X_("frozen"), _frozen ? "yes" : "no");
 
 	if (full_state) {
@@ -2189,6 +2397,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 +2473,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 +2489,7 @@ Playlist::set_layer (boost::shared_ptr<Region> region, double new_layer)
 		}
 		++i;
 	}
-	
+
 	copy.insert (i, region);
 
 	setup_layering_indices (copy);
@@ -2280,13 +2499,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 +2545,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) {
@@ -2484,12 +2715,18 @@ Playlist::nudge_after (framepos_t start, framecnt_t distance, bool forwards)
 }
 
 bool
-Playlist::uses_source (boost::shared_ptr<const Source> src) const
+Playlist::uses_source (boost::shared_ptr<const Source> src, bool shallow) const
 {
 	RegionReadLock rlock (const_cast<Playlist*> (this));
 
 	for (set<boost::shared_ptr<Region> >::const_iterator r = all_regions.begin(); r != all_regions.end(); ++r) {
-		if ((*r)->uses_source (src)) {
+		/* Note: passing the second argument as false can cause at best
+		   incredibly deep and time-consuming recursion, and at worst
+		   cycles if the user has managed to create cycles of reference
+		   between compound regions. We generally only this during
+		   cleanup, and @param shallow is passed as true.
+		*/
+		if ((*r)->uses_source (src, shallow)) {
 			return true;
 		}
 	}
@@ -2497,6 +2734,7 @@ Playlist::uses_source (boost::shared_ptr<const Source> src) const
 	return false;
 }
 
+
 boost::shared_ptr<Region>
 Playlist::find_region (const ID& id) const
 {
@@ -2525,6 +2763,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 +2955,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 ()
 {
@@ -2705,14 +2972,14 @@ Playlist::update_after_tempo_map_change ()
 	for (RegionList::iterator i = copy.begin(); i != copy.end(); ++i) {
 		(*i)->update_after_tempo_map_change ();
 	}
-
+	/* possibly causes a contents changed notification (flush_notifications()) */
 	thaw ();
 }
 
 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);
 	}
@@ -2731,25 +2998,6 @@ Playlist::has_region_at (framepos_t const p) const
 	return (i != regions.end());
 }
 
-/** Remove any region that uses a given source */
-void
-Playlist::remove_region_by_source (boost::shared_ptr<Source> s)
-{
-	RegionWriteLock rl (this);
-
-	RegionList::iterator i = regions.begin();
-	while (i != regions.end()) {
-		RegionList::iterator j = i;
-		++j;
-
-		if ((*i)->uses_source (s)) {
-			remove_region_internal (*i);
-		}
-
-		i = j;
-	}
-}
-
 /** Look from a session frame time and find the start time of the next region
  *  which is on the top layer of this playlist.
  *  @param t Time to look from.
@@ -2809,7 +3057,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 */
 
@@ -2927,7 +3182,7 @@ Playlist::uncombine (boost::shared_ptr<Region> target)
 
 	// (2) get all the original regions
 
-	const RegionList& rl (pl->region_list().rlist());
+	const RegionList& rl (pl->region_list_property().rlist());
 	RegionFactory::CompoundAssociations& cassocs (RegionFactory::compound_associations());
 	frameoffset_t move_offset = 0;
 
@@ -2954,6 +3209,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 +3229,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 +3306,33 @@ 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)
+{
+	RegionReadLock rlock (this);
+	for (list<AudioRange>::iterator r = ranges.begin(); r != ranges.end(); ) {
+		list<AudioRange>::iterator tmpr = r;
+		++tmpr;
+		for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ) {
+			RegionList::const_iterator tmpi = i;
+			++tmpi;
+			(*i)->fade_range ((*r).start, (*r).end);
+			i = tmpi;
+		}
+		r = tmpr;
+	}
+}
+
 uint32_t
 Playlist::max_source_level () const
 {
@@ -3072,9 +3349,56 @@ Playlist::max_source_level () const
 void
 Playlist::set_orig_track_id (const PBD::ID& id)
 {
+	if (shared_with(id)) {
+		// Swap 'shared_id' / origin_track_id
+		unshare_with (id);
+		share_with (_orig_track_id);
+	}
 	_orig_track_id = id;
 }
 
+void
+Playlist::share_with (const PBD::ID& id)
+{
+	if (!shared_with(id)) {
+		_shared_with_ids.push_back (id);
+	}
+}
+
+void
+Playlist::unshare_with (const PBD::ID& id)
+{
+	list<PBD::ID>::iterator it = _shared_with_ids.begin ();
+	while (it != _shared_with_ids.end()) {
+		if (*it == id) {
+			_shared_with_ids.erase (it);
+			break;
+		}
+		++it;
+	}
+}
+
+bool
+Playlist::shared_with (const PBD::ID& id) const
+{
+	bool shared = false;
+	list<PBD::ID>::const_iterator it = _shared_with_ids.begin ();
+	while (it != _shared_with_ids.end() && !shared) {
+		if (*it == id) {
+			shared = true;
+		}
+		++it;
+	}
+
+	return shared;
+}
+
+void
+Playlist::reset_shares ()
+{
+	_shared_with_ids.clear();
+}
+
 /** Take a list of ranges, coalesce any that can be coalesced, then call
  *  check_crossfades for each one.
  */
@@ -3095,6 +3419,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);