X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fplaylist.cc;h=8d20d8539d75417cb5bc6313f6629f76b6a9738b;hb=7bddf6208f763272c5aef181b66e4f47706970bb;hp=b8a7a44f58557cbac4836f494c60a637b825e66c;hpb=ce234f363e95c38fc92728e520bf5ba240a89aa7;p=ardour.git

diff --git a/libs/ardour/playlist.cc b/libs/ardour/playlist.cc
index b8a7a44f58..8d20d8539d 100644
--- a/libs/ardour/playlist.cc
+++ b/libs/ardour/playlist.cc
@@ -15,7 +15,6 @@
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
-    $Id$
 */
 
 #include <set>
@@ -36,6 +35,7 @@
 #include <ardour/session.h>
 #include <ardour/region.h>
 #include <ardour/region_factory.h>
+#include <ardour/playlist_factory.h>
 
 #include "i18n.h"
 
@@ -43,14 +43,12 @@ using namespace std;
 using namespace ARDOUR;
 using namespace PBD;
 
-sigc::signal<void,Playlist*> Playlist::PlaylistCreated;
-
 struct ShowMeTheList {
-    ShowMeTheList (Playlist *pl, const string& n) : playlist (pl), name (n) {}
+    ShowMeTheList (boost::shared_ptr<Playlist> pl, const string& n) : playlist (pl), name (n) {}
     ~ShowMeTheList () { 
 	    cerr << ">>>>" << name << endl; playlist->dump(); cerr << "<<<<" << name << endl << endl; 
     };
-    Playlist *playlist;
+    boost::shared_ptr<Playlist> playlist;
     string name;
 };
 
@@ -72,74 +70,80 @@ struct RegionSortByLastLayerOp {
     }
 };
 
-Playlist::Playlist (Session& sess, string nom, bool hide)
-	: _session (sess)
+
+Playlist::Playlist (Session& sess, string nom, DataType type, bool hide)
+	: SessionObject(sess, nom)
+	, _type(type)
 {
 	init (hide);
+	first_set_state = false;
 	_name = nom;
 	
 }
 
-Playlist::Playlist (Session& sess, const XMLNode& node, bool hide)
-	: _session (sess)
+Playlist::Playlist (Session& sess, const XMLNode& node, DataType type, bool hide)
+	: SessionObject(sess, "unnamed playlist")
+	, _type(type)
 {
+	const XMLProperty* prop = node.property("type");
+	assert(!prop || DataType(prop->value()) == _type);
+
 	init (hide);
 	_name = "unnamed"; /* reset by set_state */
-	
-	if (set_state (node)) {
-		throw failed_constructor();
-	}
+
+	/* set state called by derived class */
 }
 
-Playlist::Playlist (const Playlist& other, string namestr, bool hide)
-	: _name (namestr), _session (other._session), _orig_diskstream_id(other._orig_diskstream_id)
+Playlist::Playlist (boost::shared_ptr<const Playlist> other, string namestr, bool hide)
+	: SessionObject(other->_session, namestr), _type(other->_type), _orig_diskstream_id(other->_orig_diskstream_id)
 {
 	init (hide);
 
 	RegionList tmp;
-	other.copy_regions (tmp);
+	other->copy_regions (tmp);
 	
-	in_set_state = true;
+	in_set_state++;
 
 	for (list<boost::shared_ptr<Region> >::iterator x = tmp.begin(); x != tmp.end(); ++x) {
-		add_region_internal( (*x), (*x)->position() );
+		add_region_internal( (*x), (*x)->position());
 	}
 
-	in_set_state = false;
+	in_set_state--;
 
-	_splicing  = other._splicing;
-	_nudging   = other._nudging;
-	_edit_mode = other._edit_mode;
+	_splicing  = other->_splicing;
+	_nudging   = other->_nudging;
+	_edit_mode = other->_edit_mode;
 
-	in_set_state = false;
+	in_set_state = 0;
+	first_set_state = false;
 	in_flush = false;
 	in_partition = false;
 	subcnt = 0;
 	_read_data_count = 0;
-	_frozen = other._frozen;
-	save_on_thaw = false;
-	
-	layer_op_counter = other.layer_op_counter;
-	freeze_length = other.freeze_length;
+	_frozen = other->_frozen;
 	
+	layer_op_counter = other->layer_op_counter;
+	freeze_length = other->freeze_length;
 }
 
-Playlist::Playlist (const Playlist& other, jack_nframes_t start, jack_nframes_t cnt, string str, bool hide)
-	: _name (str), _session (other._session), _orig_diskstream_id(other._orig_diskstream_id)
+Playlist::Playlist (boost::shared_ptr<const Playlist> other, nframes_t start, nframes_t cnt, string str, bool hide)
+	: SessionObject(other->_session, str), _type(other->_type), _orig_diskstream_id(other->_orig_diskstream_id)
 {
-	RegionLock rlock2 (&((Playlist&)other));
-	
-	jack_nframes_t end = start + cnt - 1;
+	RegionLock rlock2 (const_cast<Playlist*> (other.get()));
+
+	nframes_t end = start + cnt - 1;
 
 	init (hide);
 
-	for (RegionList::const_iterator i = other.regions.begin(); i != other.regions.end(); i++) {
+	in_set_state++;
+
+	for (RegionList::const_iterator i = other->regions.begin(); i != other->regions.end(); i++) {
 
 		boost::shared_ptr<Region> region;
 		boost::shared_ptr<Region> new_region;
-		jack_nframes_t offset = 0;
-		jack_nframes_t position = 0;
-		jack_nframes_t len = 0;
+		nframes_t offset = 0;
+		nframes_t position = 0;
+		nframes_t len = 0;
 		string    new_name;
 		OverlapType overlap;
 
@@ -180,36 +184,34 @@ Playlist::Playlist (const Playlist& other, jack_nframes_t start, jack_nframes_t
 
 		new_region = RegionFactory::RegionFactory::create (region, offset, len, new_name, region->layer(), region->flags());
 
-		add_region_internal (new_region, position, true);
+		add_region_internal (new_region, position);
 	}
 	
+	in_set_state--;
+	first_set_state = false;
+
 	/* this constructor does NOT notify others (session) */
 }
 
 void
-Playlist::ref ()
+Playlist::use ()
 {
 	++_refcnt;
-	InUse (this, true); /* EMIT SIGNAL */
+	InUse (true); /* EMIT SIGNAL */
 }
 
 void
-Playlist::unref ()
+Playlist::release ()
 {
 	if (_refcnt > 0) {
 		_refcnt--; 
 	}
+
 	if (_refcnt == 0) {
-		InUse (this, false); /* EMIT SIGNAL */
-		
-		if (_hidden) {
-			/* nobody knows we exist */
-			delete this;
-		}
+		InUse (false); /* EMIT SIGNAL */
 	}
 }
 
-
 void
 Playlist::copy_regions (RegionList& newlist) const
 {
@@ -227,18 +229,18 @@ Playlist::init (bool hide)
 	g_atomic_int_set (&ignore_state_changes, 0);
 	pending_modified = false;
 	pending_length = false;
+	first_set_state = true;
 	_refcnt = 0;
 	_hidden = hide;
 	_splicing = false;
 	_nudging = false;
-	in_set_state = false;
-	_edit_mode = _session.get_edit_mode();
+	in_set_state = 0;
+	_edit_mode = Config->get_edit_mode();
 	in_flush = false;
 	in_partition = false;
 	subcnt = 0;
 	_read_data_count = 0;
 	_frozen = false;
-	save_on_thaw = false;
 	layer_op_counter = 0;
 	freeze_length = 0;
 
@@ -246,23 +248,33 @@ Playlist::init (bool hide)
 }
 
 Playlist::Playlist (const Playlist& pl)
-	: _session (pl._session)
+	: SessionObject(pl._session, pl._name)
+	, _type(pl.data_type())
 {
 	fatal << _("playlist const copy constructor called") << endmsg;
 }
 
 Playlist::Playlist (Playlist& pl)
-	: _session (pl._session)
+	: SessionObject(pl._session, pl._name)
+	, _type(pl.data_type())
 {
 	fatal << _("playlist non-const copy constructor called") << endmsg;
 }
 
 Playlist::~Playlist ()
 {
+	{ 
+		RegionLock rl (this);
+
+		for (set<boost::shared_ptr<Region> >::iterator i = all_regions.begin(); i != all_regions.end(); ++i) {
+			(*i)->set_playlist (boost::shared_ptr<Playlist>());
+		}
+	}
+
 	/* GoingAway must be emitted by derived classes */
 }
 
-void
+bool
 Playlist::set_name (const string& str)
 {
 	/* in a typical situation, a playlist is being used
@@ -272,11 +284,10 @@ Playlist::set_name (const string& str)
 	*/
 
 	if (_refcnt > 2) {
-		return;
+		return false;
+	} else {
+		return SessionObject::set_name(str);
 	}
-
-	_name = str; 
-	NameChanged(); /* EMIT SIGNAL */
 }
 
 /***********************************************************************
@@ -333,13 +344,16 @@ void
 Playlist::notify_region_removed (boost::shared_ptr<Region> r)
 {
 	if (holding_state ()) {
-		pending_removals.insert (pending_removals.end(), r);
+		pending_removes.insert (r);
+		pending_modified = true;
+		pending_length = true;
 	} else {
-		RegionRemoved (r); /* EMIT SIGNAL */
 		/* this might not be true, but we have to act
 		   as though it could be.
 		*/
+	        pending_length = false;
 		LengthChanged (); /* EMIT SIGNAL */
+		pending_modified = false;
 		Modified (); /* EMIT SIGNAL */
 	}
 }
@@ -347,14 +361,18 @@ Playlist::notify_region_removed (boost::shared_ptr<Region> r)
 void
 Playlist::notify_region_added (boost::shared_ptr<Region> r)
 {
+	/* the length change might not be true, but we have to act
+	   as though it could be.
+	*/
+
 	if (holding_state()) {
-		pending_adds.insert (pending_adds.end(), r);
+		pending_adds.insert (r);
+		pending_modified = true;
+		pending_length = true;
 	} else {
-		RegionAdded (r); /* EMIT SIGNAL */
-		/* this might not be true, but we have to act
-		   as though it could be.
-		*/
+		pending_length = false;
 		LengthChanged (); /* EMIT SIGNAL */
+		pending_modified = false;
 		Modified (); /* EMIT SIGNAL */
 	}
 }
@@ -365,7 +383,9 @@ Playlist::notify_length_changed ()
 	if (holding_state ()) {
 		pending_length = true;
 	} else {
+		pending_length = false;
 		LengthChanged(); /* EMIT SIGNAL */
+		pending_modified = false;
 		Modified (); /* EMIT SIGNAL */
 	}
 }
@@ -373,9 +393,8 @@ Playlist::notify_length_changed ()
 void
 Playlist::flush_notifications ()
 {
-	RegionList::iterator r;
-	RegionList::iterator a;
 	set<boost::shared_ptr<Region> > dependent_checks_needed;
+	set<boost::shared_ptr<Region> >::iterator s;
 	uint32_t n = 0;
 
 	if (in_flush) {
@@ -394,31 +413,21 @@ Playlist::flush_notifications ()
 	// pending_bounds.sort (cmp);
 
 	for (RegionList::iterator r = pending_bounds.begin(); r != pending_bounds.end(); ++r) {
-		if (_session.get_layer_model() == Session::MoveAddHigher) {
+		if (Config->get_layer_model() == MoveAddHigher) {
 			timestamp_layer_op (*r);
 		}
 		pending_length = true;
-		n++;
-	}
-
-	for (RegionList::iterator r = pending_bounds.begin(); r != pending_bounds.end(); ++r) {
 		dependent_checks_needed.insert (*r);
-		/* don't increment n again - its the same list */
-	}
-
-	for (a = pending_adds.begin(); a != pending_adds.end(); ++a) {
-		dependent_checks_needed.insert (*a);
-		RegionAdded (*a); /* EMIT SIGNAL */
 		n++;
 	}
 
-	for (set<boost::shared_ptr<Region> >::iterator x = dependent_checks_needed.begin(); x != dependent_checks_needed.end(); ++x) {
-		check_dependents (*x, false);
+	for (s = pending_adds.begin(); s != pending_adds.end(); ++s) {
+		dependent_checks_needed.insert (*s);
+		n++;
 	}
 
-	for (r = pending_removals.begin(); r != pending_removals.end(); ++r) {
-		remove_dependents (*r);
-		RegionRemoved (*r); /* EMIT SIGNAL */
+	for (s = pending_removes.begin(); s != pending_removes.end(); ++s) {
+		remove_dependents (*s);
 		n++;
 	}
 
@@ -435,17 +444,17 @@ Playlist::flush_notifications ()
 		}
 		pending_modified = false;
 		Modified (); /* EMIT SIGNAL */
+		
+	}
+
+	for (s = dependent_checks_needed.begin(); s != dependent_checks_needed.end(); ++s) {
+		check_dependents (*s, false);
 	}
 
 	pending_adds.clear ();
-	pending_removals.clear ();
+	pending_removes.clear ();
 	pending_bounds.clear ();
 
-	if (save_on_thaw) {
-		save_on_thaw = false;
-		save_state (last_save_reason);
-	}
-	
 	in_flush = false;
 }
 
@@ -454,18 +463,18 @@ Playlist::flush_notifications ()
  *************************************************************/
 
 void
-Playlist::add_region (boost::shared_ptr<Region> region, jack_nframes_t position, float times, bool with_save) 
+Playlist::add_region (boost::shared_ptr<Region> region, nframes_t position, float times) 
 { 
 	RegionLock rlock (this);
-	
+	delay_notifications();
 	times = fabs (times);
 	
 	int itimes = (int) floor (times);
 
-	jack_nframes_t pos = position;
+	nframes_t pos = position;
 	
 	if (itimes >= 1) {
-		add_region_internal (region, pos, true);
+		add_region_internal (region, pos);
 		pos += region->length();
 		--itimes;
 	}
@@ -482,40 +491,54 @@ Playlist::add_region (boost::shared_ptr<Region> region, jack_nframes_t position,
 
 	for (int i = 0; i < itimes; ++i) {
 		boost::shared_ptr<Region> copy = RegionFactory::create (region);
-		add_region_internal (copy, pos, true);
+		add_region_internal (copy, pos);
 		pos += region->length();
 	}
 	
 	if (floor (times) != times) {
-		jack_nframes_t length = (jack_nframes_t) floor (region->length() * (times - floor (times)));
+		nframes_t length = (nframes_t) floor (region->length() * (times - floor (times)));
 		string name;
 		_session.region_name (name, region->name(), false);
 		boost::shared_ptr<Region> sub = RegionFactory::create (region, 0, length, name, region->layer(), region->flags());
-		add_region_internal (sub, pos, true);
+		add_region_internal (sub, pos);
 	}
-	
-	if (with_save) {
-		maybe_save_state (_("add region"));
+
+	release_notifications ();
+}
+
+void
+Playlist::set_region_ownership ()
+{
+	RegionLock rl (this);
+	RegionList::iterator i;
+	boost::weak_ptr<Playlist> pl (shared_from_this());
+
+	for (i = regions.begin(); i != regions.end(); ++i) {
+		(*i)->set_playlist (pl);
 	}
 }
 
 void
-Playlist::add_region_internal (boost::shared_ptr<Region> region, jack_nframes_t position, bool delay_sort)
+Playlist::add_region_internal (boost::shared_ptr<Region> region, nframes_t position)
 {
 	RegionSortByPosition cmp;
-	jack_nframes_t old_length = 0;
+	nframes_t old_length = 0;
 
 	if (!holding_state()) {
 		 old_length = _get_maximum_extent();
 	}
 
-	region->set_playlist (this);
+	if (!first_set_state) {
+		boost::shared_ptr<Playlist> foo (shared_from_this());
+		region->set_playlist (boost::weak_ptr<Playlist>(foo));
+	} 
+
 	region->set_position (position, this);
-	region->lock_sources ();
 
 	timestamp_layer_op (region);
 
 	regions.insert (upper_bound (regions.begin(), regions.end(), region, cmp), region);
+	all_regions.insert (region);
 
 	if (!holding_state () && !in_set_state) {
 		/* layers get assigned from XML state */
@@ -533,11 +556,12 @@ Playlist::add_region_internal (boost::shared_ptr<Region> region, jack_nframes_t
 		}
 	}
 
-	region->StateChanged.connect (sigc::bind (mem_fun (this, &Playlist::region_changed_proxy), region));
+	region->StateChanged.connect (sigc::bind (mem_fun (this, &Playlist::region_changed_proxy), 
+						  boost::weak_ptr<Region> (region)));
 }
 
 void
-Playlist::replace_region (boost::shared_ptr<Region> old, boost::shared_ptr<Region> newr, jack_nframes_t pos)
+Playlist::replace_region (boost::shared_ptr<Region> old, boost::shared_ptr<Region> newr, nframes_t pos)
 {
 	RegionLock rlock (this);
 
@@ -547,8 +571,6 @@ Playlist::replace_region (boost::shared_ptr<Region> old, boost::shared_ptr<Regio
 	if (!holding_state ()) {
 		possibly_splice_unlocked ();
 	}
-
-	maybe_save_state (_("replace region"));
 }
 
 void
@@ -560,22 +582,23 @@ Playlist::remove_region (boost::shared_ptr<Region> region)
 	if (!holding_state ()) {
 		possibly_splice_unlocked ();
 	}
-
-	maybe_save_state (_("remove region"));
 }
 
 int
-Playlist::remove_region_internal (boost::shared_ptr<Region>region, bool delay_sort)
+Playlist::remove_region_internal (boost::shared_ptr<Region>region)
 {
 	RegionList::iterator i;
-	jack_nframes_t old_length = 0;
-
-	// cerr << "removing region " << region->name() << endl;
+	nframes_t old_length = 0;
 
 	if (!holding_state()) {
 		old_length = _get_maximum_extent();
 	}
 
+	if (!in_set_state) {
+		/* unset playlist */
+		region->set_playlist (boost::weak_ptr<Playlist>());
+	}
+
 	for (i = regions.begin(); i != regions.end(); ++i) {
 		if (*i == region) {
 
@@ -600,11 +623,15 @@ Playlist::remove_region_internal (boost::shared_ptr<Region>region, bool delay_so
 void
 Playlist::get_equivalent_regions (boost::shared_ptr<Region> other, vector<boost::shared_ptr<Region> >& results)
 {
-	for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
-		if (Config->get_use_overlap_equivalency()) {
+	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 if ((*i)->equivalent (other)) {
+			}
+		}
+	} else {
+		for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+			if ((*i)->equivalent (other)) {
 				results.push_back ((*i));
 			}
 		}
@@ -623,7 +650,7 @@ Playlist::get_region_list_equivalent_regions (boost::shared_ptr<Region> other, v
 }
 
 void
-Playlist::partition (jack_nframes_t start, jack_nframes_t end, bool just_top_level)
+Playlist::partition (nframes_t start, nframes_t end, bool just_top_level)
 {
 	RegionList thawlist;
 
@@ -632,29 +659,31 @@ Playlist::partition (jack_nframes_t start, jack_nframes_t end, bool just_top_lev
 	for (RegionList::iterator i = thawlist.begin(); i != thawlist.end(); ++i) {
 		(*i)->thaw ("separation");
 	}
-
-	maybe_save_state (_("separate"));
 }
 
 void
-Playlist::partition_internal (jack_nframes_t start, jack_nframes_t end, bool cutting, RegionList& thawlist)
+Playlist::partition_internal (nframes_t start, nframes_t end, bool cutting, RegionList& thawlist)
 {
-	RegionLock rlock (this);
 	boost::shared_ptr<Region> region;
 	boost::shared_ptr<Region> current;
 	string new_name;
 	RegionList::iterator tmp;
 	OverlapType overlap;
-	jack_nframes_t pos1, pos2, pos3, pos4;
+	nframes_t pos1, pos2, pos3, pos4;
 	RegionList new_regions;
+	RegionList copy;
 
 	in_partition = true;
 
+	delay_notifications();
+
 	/* need to work from a copy, because otherwise the regions we add during the process
 	   get operated on as well.
 	*/
-
-	RegionList copy = regions;
+	{
+		RegionLock rlock (this);
+		copy = regions;
+	}
 
 	for (RegionList::iterator i = copy.begin(); i != copy.end(); i = tmp) {
 		
@@ -662,9 +691,10 @@ Playlist::partition_internal (jack_nframes_t start, jack_nframes_t end, bool cut
 		++tmp;
 
 		current = *i;
-		
+
 		if (current->first_frame() == start && current->last_frame() == end) {
 			if (cutting) {
+				RegionLock rlock (this);
 				remove_region_internal (current);
 			}
 			continue;
@@ -673,14 +703,14 @@ Playlist::partition_internal (jack_nframes_t start, jack_nframes_t end, bool cut
 		if ((overlap = current->coverage (start, end)) == OverlapNone) {
 			continue;
 		}
-		
+
 		pos1 = current->position();
 		pos2 = start;
 		pos3 = end;
 		pos4 = current->last_frame();
 
 		if (overlap == OverlapInternal) {
-			
+
 			/* split: we need 3 new regions, the front, middle and end.
 			   cut:   we need 2 regions, the front and end.
 			*/
@@ -700,10 +730,11 @@ Playlist::partition_internal (jack_nframes_t start, jack_nframes_t end, bool cut
 				
 				/* "middle" ++++++ */
 				
-				_session.region_name (new_name, current->name(), false);
+				_session.region_name (new_name, current->name(), false); //takes the session-wide region lock
 				region = RegionFactory::create (current, pos2 - pos1, pos3 - pos2, new_name,
 						       regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::LeftOfSplit|Region::RightOfSplit));
-				add_region_internal (region, start, true);
+				RegionLock rlock (this);
+				add_region_internal (region, start);
 				new_regions.push_back (region);
 			}
 			
@@ -712,10 +743,11 @@ Playlist::partition_internal (jack_nframes_t start, jack_nframes_t end, bool cut
 			_session.region_name (new_name, current->name(), false);
 			region = RegionFactory::create (current, pos3 - pos1, pos4 - pos3, new_name, 
 					       regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::RightOfSplit));
-
-			add_region_internal (region, end, true);
-			new_regions.push_back (region);
-
+			{
+				RegionLock rlock (this);
+				add_region_internal (region, end);
+				new_regions.push_back (region);
+			}
 		        /* "front" ***** */
 				
 			current->freeze ();
@@ -740,9 +772,10 @@ Playlist::partition_internal (jack_nframes_t start, jack_nframes_t end, bool cut
 				/* end +++++ */
 				
 				_session.region_name (new_name, current->name(), false);
-				region = RegionFactory::create (current, pos2 - pos1, pos4 - pos2, new_name, (layer_t) regions.size(),
+				region = RegionFactory::create (current, pos2 - pos1, pos4 - pos2, new_name, regions.size(),
 						       Region::Flag(current->flags()|Region::Automatic|Region::LeftOfSplit));
-				add_region_internal (region, start, true);
+				RegionLock rlock (this);
+				add_region_internal (region, start);
 				new_regions.push_back (region);
 			}
 
@@ -776,7 +809,8 @@ Playlist::partition_internal (jack_nframes_t start, jack_nframes_t end, bool cut
 				 _session.region_name (new_name, current->name(), false);
 				 region = RegionFactory::create (current, 0, pos3 - pos1, new_name,
 							regions.size(), Region::Flag(current->flags()|Region::Automatic|Region::RightOfSplit));
-				 add_region_internal (region, pos1, true);
+				 RegionLock rlock (this);
+				 add_region_internal (region, pos1);
 				 new_regions.push_back (region);
 			} 
 			
@@ -805,6 +839,7 @@ Playlist::partition_internal (jack_nframes_t start, jack_nframes_t end, bool cut
 			*/
 
 			if (cutting) {
+				RegionLock rlock (this);
 				remove_region_internal (current);
 			}
 			new_regions.push_back (current);
@@ -816,22 +851,23 @@ Playlist::partition_internal (jack_nframes_t start, jack_nframes_t end, bool cut
 	for (RegionList::iterator i = new_regions.begin(); i != new_regions.end(); ++i) {
 		check_dependents (*i, false);
 	}
+
+	release_notifications ();
 }
 
-Playlist*
-Playlist::cut_copy (Playlist* (Playlist::*pmf)(jack_nframes_t, jack_nframes_t,bool), list<AudioRange>& ranges, bool result_is_hidden)
+boost::shared_ptr<Playlist>
+Playlist::cut_copy (boost::shared_ptr<Playlist> (Playlist::*pmf)(nframes_t, nframes_t,bool), list<AudioRange>& ranges, bool result_is_hidden)
 {
-	Playlist* ret;
-	Playlist* pl;
-	jack_nframes_t start;
+	boost::shared_ptr<Playlist> ret;
+	boost::shared_ptr<Playlist> pl;
+	nframes_t start;
 
 	if (ranges.empty()) {
-		return 0;
+		return boost::shared_ptr<Playlist>();
 	}
 
 	start = ranges.front().start;
 
-
 	for (list<AudioRange>::iterator i = ranges.begin(); i != ranges.end(); ++i) {
 
 		pl = (this->*pmf)((*i).start, (*i).length(), result_is_hidden);
@@ -845,39 +881,31 @@ Playlist::cut_copy (Playlist* (Playlist::*pmf)(jack_nframes_t, jack_nframes_t,bo
 			   chopped.
 			*/
 
-			ret->paste (*pl, (*i).start - start, 1.0f);
-			delete pl;
+			ret->paste (pl, (*i).start - start, 1.0f);
 		}
 	}
 
-	if (ret) {
-		/* manually notify session of new playlist here
-		   because the playlists were constructed without notifying 
-		*/
-		PlaylistCreated (ret);
-	}
-	
 	return ret;
 }
 
-Playlist*
+boost::shared_ptr<Playlist>
 Playlist::cut (list<AudioRange>& ranges, bool result_is_hidden)
 {
-	Playlist* (Playlist::*pmf)(jack_nframes_t,jack_nframes_t,bool) = &Playlist::cut;
+	boost::shared_ptr<Playlist> (Playlist::*pmf)(nframes_t,nframes_t,bool) = &Playlist::cut;
 	return cut_copy (pmf, ranges, result_is_hidden);
 }
 
-Playlist*
+boost::shared_ptr<Playlist>
 Playlist::copy (list<AudioRange>& ranges, bool result_is_hidden)
 {
-	Playlist* (Playlist::*pmf)(jack_nframes_t,jack_nframes_t,bool) = &Playlist::copy;
+	boost::shared_ptr<Playlist> (Playlist::*pmf)(nframes_t,nframes_t,bool) = &Playlist::copy;
 	return cut_copy (pmf, ranges, result_is_hidden);
 }
 
-Playlist *
-Playlist::cut (jack_nframes_t start, jack_nframes_t cnt, bool result_is_hidden)
+boost::shared_ptr<Playlist>
+Playlist::cut (nframes_t start, nframes_t cnt, bool result_is_hidden)
 {
-	Playlist *the_copy;
+	boost::shared_ptr<Playlist> the_copy;
 	RegionList thawlist;
 	char buf[32];
 
@@ -886,8 +914,8 @@ Playlist::cut (jack_nframes_t start, jack_nframes_t cnt, bool result_is_hidden)
 	new_name += '.';
 	new_name += buf;
 
-	if ((the_copy = copyPlaylist (*this, start, cnt, new_name, result_is_hidden)) == 0) {
-		return 0;
+	if ((the_copy = PlaylistFactory::create (shared_from_this(), start, cnt, new_name, result_is_hidden)) == 0) {
+		return boost::shared_ptr<Playlist>();
 	}
 
 	partition_internal (start, start+cnt-1, true, thawlist);
@@ -897,13 +925,11 @@ Playlist::cut (jack_nframes_t start, jack_nframes_t cnt, bool result_is_hidden)
 		(*i)->thaw ("playlist cut");
 	}
 
-	maybe_save_state (_("cut"));
-
 	return the_copy;
 }
 
-Playlist *
-Playlist::copy (jack_nframes_t start, jack_nframes_t cnt, bool result_is_hidden)
+boost::shared_ptr<Playlist>
+Playlist::copy (nframes_t start, nframes_t cnt, bool result_is_hidden)
 {
 	char buf[32];
 	
@@ -913,28 +939,28 @@ Playlist::copy (jack_nframes_t start, jack_nframes_t cnt, bool result_is_hidden)
 	new_name += buf;
 
 	cnt = min (_get_maximum_extent() - start, cnt);
-	return copyPlaylist (*this, start, cnt, new_name, result_is_hidden);
+	return PlaylistFactory::create (shared_from_this(), start, cnt, new_name, result_is_hidden);
 }
 
 int
-Playlist::paste (Playlist& other, jack_nframes_t position, float times)
+Playlist::paste (boost::shared_ptr<Playlist> other, nframes_t position, float times)
 {
 	times = fabs (times);
-	jack_nframes_t old_length;
+	nframes_t old_length;
 
 	{
 		RegionLock rl1 (this);
-		RegionLock rl2 (&other);
+		RegionLock rl2 (other.get());
 
 		old_length = _get_maximum_extent();
 	
 		int itimes = (int) floor (times);
-		jack_nframes_t pos = position;
-		jack_nframes_t shift = other._get_maximum_extent();
+		nframes_t pos = position;
+		nframes_t shift = other->_get_maximum_extent();
 		layer_t top_layer = regions.size();
 
 		while (itimes--) {
-			for (RegionList::iterator i = other.regions.begin(); i != other.regions.end(); ++i) {
+			for (RegionList::iterator i = other->regions.begin(); i != other->regions.end(); ++i) {
 				boost::shared_ptr<Region> copy_of_region = RegionFactory::create (*i);
 
 				/* put these new regions on top of all existing ones, but preserve
@@ -958,40 +984,36 @@ Playlist::paste (Playlist& other, jack_nframes_t position, float times)
 		
 	}
 
-	maybe_save_state (_("paste"));
-
 	return 0;
 }
 
 
 void
-Playlist::duplicate (boost::shared_ptr<Region> region, jack_nframes_t position, float times)
+Playlist::duplicate (boost::shared_ptr<Region> region, nframes_t position, float times)
 {
 	times = fabs (times);
 
 	RegionLock rl (this);
 	int itimes = (int) floor (times);
-	jack_nframes_t pos = position;
+	nframes_t pos = position;
 
 	while (itimes--) {
 		boost::shared_ptr<Region> copy = RegionFactory::create (region);
-		add_region_internal (copy, pos, true);
+		add_region_internal (copy, pos);
 		pos += region->length();
 	}
 
 	if (floor (times) != times) {
-		jack_nframes_t length = (jack_nframes_t) floor (region->length() * (times - floor (times)));
+		nframes_t length = (nframes_t) floor (region->length() * (times - floor (times)));
 		string name;
 		_session.region_name (name, region->name(), false);
 		boost::shared_ptr<Region> sub = RegionFactory::create (region, 0, length, name, region->layer(), region->flags());
-		add_region_internal (sub, pos, true);
+		add_region_internal (sub, pos);
 	}
-
-	maybe_save_state (_("duplicate"));
 }
 
 void
-Playlist::split_region (boost::shared_ptr<Region> region, jack_nframes_t playlist_position)
+Playlist::split_region (boost::shared_ptr<Region> region, nframes_t playlist_position)
 {
 	RegionLock rl (this);
 
@@ -1006,8 +1028,8 @@ Playlist::split_region (boost::shared_ptr<Region> region, jack_nframes_t playlis
 
 	boost::shared_ptr<Region> left;
 	boost::shared_ptr<Region> right;
-	jack_nframes_t before;
-	jack_nframes_t after;
+	nframes_t before;
+	nframes_t after;
 	string before_name;
 	string after_name;
 
@@ -1021,7 +1043,7 @@ Playlist::split_region (boost::shared_ptr<Region> region, jack_nframes_t playlis
 	_session.region_name (after_name, region->name(), false);
 	right = RegionFactory::create (region, before, after, after_name, region->layer(), Region::Flag (region->flags()|Region::RightOfSplit));
 
-	add_region_internal (left, region->position(), true);
+	add_region_internal (left, region->position());
 	add_region_internal (right, region->position() + before);
 	
 	uint64_t orig_layer_op = region->last_layer_op();
@@ -1038,11 +1060,9 @@ Playlist::split_region (boost::shared_ptr<Region> region, jack_nframes_t playlis
 
 	finalize_split_region (region, left, right);
 	
-	if (remove_region_internal (region, true)) {
+	if (remove_region_internal (region)) {
 		return;
 	}
-
-	maybe_save_state (_("split"));
 }
 
 void
@@ -1131,26 +1151,32 @@ Playlist::region_bounds_changed (Change what_changed, boost::shared_ptr<Region>
 	}
 
 	if (what_changed & Change (ARDOUR::PositionChanged|ARDOUR::LengthChanged)) {
-	
 		if (holding_state ()) {
 			pending_bounds.push_back (region);
 		} else {
-			if (_session.get_layer_model() == Session::MoveAddHigher) {
+			if (Config->get_layer_model() == MoveAddHigher) {
 				/* it moved or changed length, so change the timestamp */
 				timestamp_layer_op (region);
 			}
 			
 			possibly_splice ();
-			check_dependents (region, false);
 			notify_length_changed ();
 			relayer ();
+			check_dependents (region, false);
 		}
 	}
 }
 
 void
-Playlist::region_changed_proxy (Change what_changed, boost::shared_ptr<Region> region)
+Playlist::region_changed_proxy (Change what_changed, boost::weak_ptr<Region> weak_region)
 {
+	boost::shared_ptr<Region> region (weak_region.lock());
+
+	if (!region) {
+		return;
+	}
+
+
 	/* this makes a virtual call to the right kind of playlist ... */
 
 	region_changed (what_changed, region);
@@ -1172,8 +1198,8 @@ Playlist::region_changed (Change what_changed, boost::shared_ptr<Region> region)
 			save = !(_splicing || _nudging);
 		}
 		
-		if ((what_changed & Region::MuteChanged) && 
-		    !(what_changed &  Change (ARDOUR::PositionChanged|ARDOUR::LengthChanged))) {
+		if ((what_changed & our_interests) && 
+		    !(what_changed & Change (ARDOUR::PositionChanged|ARDOUR::LengthChanged))) {
 			check_dependents (region, false);
 		}
 		
@@ -1186,24 +1212,31 @@ Playlist::region_changed (Change what_changed, boost::shared_ptr<Region> region)
 }
 
 void
-Playlist::clear (bool with_save)
+Playlist::drop_regions ()
 {
-	RegionList::iterator i;
-	RegionList tmp;
+	RegionLock rl (this);
+	regions.clear ();
+	all_regions.clear ();
+}
 
+void
+Playlist::clear (bool with_signals)
+{
 	{ 
 		RegionLock rl (this);
-		tmp = regions;
+		for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+			pending_removes.insert (*i);
+		}
 		regions.clear ();
 	}
-	
-	for (i = tmp.begin(); i != tmp.end(); ++i) {
-		notify_region_removed (*i);
-	}
 
-	if (with_save) {
-		maybe_save_state (_("clear"));
+	if (with_signals) {
+		pending_length = false;
+		LengthChanged ();
+		pending_modified = false;
+		Modified ();
 	}
+
 }
 
 /***********************************************************************
@@ -1211,7 +1244,7 @@ Playlist::clear (bool with_save)
  **********************************************************************/
 
 Playlist::RegionList *
-Playlist::regions_at (jack_nframes_t frame)
+Playlist::regions_at (nframes_t frame)
 
 {
 	RegionLock rlock (this);
@@ -1219,7 +1252,7 @@ Playlist::regions_at (jack_nframes_t frame)
 }	
 
 boost::shared_ptr<Region>
-Playlist::top_region_at (jack_nframes_t frame)
+Playlist::top_region_at (nframes_t frame)
 
 {
 	RegionLock rlock (this);
@@ -1237,7 +1270,7 @@ Playlist::top_region_at (jack_nframes_t frame)
 }	
 
 Playlist::RegionList *
-Playlist::find_regions_at (jack_nframes_t frame)
+Playlist::find_regions_at (nframes_t frame)
 {
 	RegionList *rlist = new RegionList;
 
@@ -1251,7 +1284,7 @@ Playlist::find_regions_at (jack_nframes_t frame)
 }
 
 Playlist::RegionList *
-Playlist::regions_touched (jack_nframes_t start, jack_nframes_t end)
+Playlist::regions_touched (nframes_t start, nframes_t end)
 {
 	RegionLock rlock (this);
 	RegionList *rlist = new RegionList;
@@ -1267,17 +1300,18 @@ Playlist::regions_touched (jack_nframes_t start, jack_nframes_t end)
 
 
 boost::shared_ptr<Region>
-Playlist::find_next_region (jack_nframes_t frame, RegionPoint point, int dir)
+Playlist::find_next_region (nframes_t frame, RegionPoint point, int dir)
 {
 	RegionLock rlock (this);
 	boost::shared_ptr<Region> ret;
-	jack_nframes_t closest = max_frames;
+	nframes_t closest = max_frames;
+
 
 	for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
 
-		jack_nframes_t distance;
+		nframes_t distance;
 		boost::shared_ptr<Region> r = (*i);
-		jack_nframes_t pos = 0;
+		nframes_t pos = 0;
 
 		switch (point) {
 		case Start:
@@ -1294,7 +1328,7 @@ Playlist::find_next_region (jack_nframes_t frame, RegionPoint point, int dir)
 		switch (dir) {
 		case 1: /* forwards */
 
-			if (pos > frame) {
+			if (pos >= frame) {
 				if ((distance = pos - frame) < closest) {
 					closest = distance;
 					ret = r;
@@ -1305,7 +1339,7 @@ Playlist::find_next_region (jack_nframes_t frame, RegionPoint point, int dir)
 
 		default: /* backwards */
 
-			if (pos < frame) {
+			if (pos <= frame) {
 				if ((distance = frame - pos) < closest) {
 					closest = distance;
 					ret = r;
@@ -1333,8 +1367,6 @@ Playlist::mark_session_dirty ()
 int
 Playlist::set_state (const XMLNode& node)
 {
-	in_set_state = true;
-
 	XMLNode *child;
 	XMLNodeList nlist;
 	XMLNodeConstIterator niter;
@@ -1344,13 +1376,15 @@ Playlist::set_state (const XMLNode& node)
 	boost::shared_ptr<Region> region;
 	string region_name;
 
-	clear (false);
+	in_set_state++;
 
 	if (node.name() != "Playlist") {
-		in_set_state = false;
+		in_set_state--;
 		return -1;
 	}
 
+	freeze ();
+
 	plist = node.properties();
 
 	for (piter = plist.begin(); piter != plist.end(); ++piter) {
@@ -1366,6 +1400,8 @@ Playlist::set_state (const XMLNode& node)
 		}
 	}
 
+	clear (false);
+	
 	nlist = node.children();
 
 	for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
@@ -1374,20 +1410,39 @@ Playlist::set_state (const XMLNode& node)
 		
 		if (child->name() == "Region") {
 
-			if ((region = RegionFactory::create (_session, *child, true)) == 0) {
-				error << _("Playlist: cannot create region from state file") << endmsg;
+			if ((prop = child->property ("id")) == 0) {
+				error << _("region state node has no ID, ignored") << endmsg;
+				continue;
+			}
+			
+			ID id = prop->value ();
+			
+			if ((region = region_by_id (id))) {
+
+				Change what_changed = Change (0);
+
+				if (region->set_live_state (*child, what_changed, true)) {
+					error << _("Playlist: cannot reset region state from XML") << endmsg;
+					continue;
+				}
+
+			} else if ((region = RegionFactory::create (_session, *child, true)) == 0) {
+				error << _("Playlist: cannot create region from XML") << endmsg;
 				continue;
 			}
 
-			add_region (region, region->position(), 1.0, false);
+			add_region (region, region->position(), 1.0);
 
 			// So that layer_op ordering doesn't get screwed up
 			region->set_last_layer_op( region->layer());
 
 		} 			
 	}
-
 	
+	notify_modified ();
+
+	thaw ();
+
  	/* update dependents, which was not done during add_region_internal 
 	   due to in_set_state being true 
 	*/
@@ -1395,9 +1450,9 @@ Playlist::set_state (const XMLNode& node)
 	for (RegionList::iterator r = regions.begin(); r != regions.end(); ++r) {
 		check_dependents (*r, false);
 	}
-	
-	in_set_state = false;
 
+	in_set_state--;
+	first_set_state = false;
 	return 0;
 }
 
@@ -1420,14 +1475,14 @@ Playlist::state (bool full_state)
 	char buf[64];
 	
 	node->add_property (X_("name"), _name);
+	node->add_property (X_("type"), _type.to_string());
 
-	_orig_diskstream_id.print (buf);
+	_orig_diskstream_id.print (buf, sizeof (buf));
 	node->add_property (X_("orig_diskstream_id"), buf);
 	node->add_property (X_("frozen"), _frozen ? "yes" : "no");
 
 	if (full_state) {
 		RegionLock rlock (this, false);
-
 		for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
 			node->add_child_nocopy ((*i)->get_state());
 		}
@@ -1443,22 +1498,30 @@ Playlist::state (bool full_state)
 bool
 Playlist::empty() const
 {
+	RegionLock rlock (const_cast<Playlist *>(this), false);
 	return regions.empty();
 }
 
-jack_nframes_t
+uint32_t
+Playlist::n_regions() const
+{
+	RegionLock rlock (const_cast<Playlist *>(this), false);
+	return regions.size();
+}
+
+nframes_t
 Playlist::get_maximum_extent () const
 {
-	RegionLock rlock (const_cast<Playlist *>(this));
+	RegionLock rlock (const_cast<Playlist *>(this), false);
 	return _get_maximum_extent ();
 }
 
-jack_nframes_t
+ARDOUR::nframes_t
 Playlist::_get_maximum_extent () const
 {
 	RegionList::const_iterator i;
-	jack_nframes_t max_extent = 0;
-	jack_nframes_t end = 0;
+	nframes_t max_extent = 0;
+	nframes_t end = 0;
 
 	for (i = regions.begin(); i != regions.end(); ++i) {
 		if ((end = (*i)->position() + (*i)->length()) > max_extent) {
@@ -1476,7 +1539,7 @@ Playlist::bump_name (string name, Session &session)
 
 	do {
 		newname = Playlist::bump_name_once (newname);
-	} while (session.playlist_by_name(newname)!=NULL);
+	} while (session.playlist_by_name (newname)!=NULL);
 
 	return newname;
 }
@@ -1488,17 +1551,33 @@ Playlist::bump_name_once (string name)
 	string newname;
 
 	if ((period = name.find_last_of ('.')) == string::npos) {
-		newname = name;
+		newname  = name;
 		newname += ".1";
 	} else {
-		char buf[32];
-		int version;
-		
-		sscanf (name.substr (period+1).c_str(), "%d", &version);
-		snprintf (buf, sizeof(buf), "%d", version+1);
+		int isnumber = 1;
+		const char *last_element = name.c_str() + period + 1;
+		for (size_t i = 0; i < strlen(last_element); i++) {
+			if (!isdigit(last_element[i])) {
+				isnumber = 0;
+				break;
+			}
+		}
+
+		errno = 0;
+		long int version = strtol (name.c_str()+period+1, (char **)NULL, 10);
+
+		if (isnumber == 0 || errno != 0) {
+			// last_element is not a number, or is too large
+			newname  = name;
+			newname += ".1";
+		} else {
+			char buf[32];
+
+			snprintf (buf, sizeof(buf), "%ld", version+1);
 		
-		newname = name.substr (0, period+1);
-		newname += buf;
+			newname  = name.substr (0, period+1);
+			newname += buf;
+		}
 	}
 
 	return newname;
@@ -1529,33 +1608,65 @@ Playlist::set_edit_mode (EditMode mode)
 void
 Playlist::relayer ()
 {
-	RegionList::iterator i;
-	uint32_t layer = 0;
-
 	/* don't send multiple Modified notifications
 	   when multiple regions are relayered.
 	*/
-
+ 
 	freeze ();
 
-	if (_session.get_layer_model() == Session::MoveAddHigher || 
-	    _session.get_layer_model() == Session::AddHigher) {
+	/* build up a new list of regions on each layer */
 
-		RegionSortByLastLayerOp cmp;
-		RegionList copy = regions;
+	std::vector<RegionList> layers;
+
+	/* we want to go through regions from desired lowest to desired highest layer,
+	   which depends on the layer model
+	*/
+
+	RegionList copy = regions;
 
+	/* sort according to the model */
+
+	if (Config->get_layer_model() == MoveAddHigher || Config->get_layer_model() == AddHigher) {
+		RegionSortByLastLayerOp cmp;
 		copy.sort (cmp);
+	}
+	
+	for (RegionList::iterator i = copy.begin(); i != copy.end(); ++i) {
 
-		for (i = copy.begin(); i != copy.end(); ++i) {
-			(*i)->set_layer (layer++);
+		/* find the lowest layer that this region can go on */
+		size_t j = layers.size();
+		while (j > 0) {
+			/* try layer j - 1; it can go on if it overlaps no other region
+			   that is already on that layer
+			*/
+			RegionList::iterator k = layers[j - 1].begin();
+			while (k != layers[j - 1].end()) {
+				if ((*k)->overlap_equivalent (*i)) {
+					break;
+				}
+				k++;
+			}
+
+			if (k != layers[j - 1].end()) {
+				/* no overlap, so we can use this layer */
+				break;
+			}
+					
+			j--;
 		}
 
-	} else {
-		
-		/* Session::LaterHigher model */
+		if (j == layers.size()) {
+			/* we need a new layer for this region */
+			layers.push_back (RegionList ());
+		}
 
-		for (i = regions.begin(); i != regions.end(); ++i) {
-			(*i)->set_layer (layer++);
+		layers[j].push_back (*i);
+	}
+
+	/* first pass: set up the layer numbers in the regions */
+	for (size_t j = 0; j < layers.size(); ++j) {
+		for (RegionList::iterator i = layers[j].begin(); i != layers[j].end(); ++i) {
+			(*i)->set_layer (j);
 		}
 	}
 
@@ -1574,39 +1685,12 @@ Playlist::relayer ()
 
 /* XXX these layer functions are all deprecated */
 
-void
-Playlist::raise_region (boost::shared_ptr<Region> region)
-{
-	uint32_t rsz = regions.size();
-	layer_t target = region->layer() + 1U;
-
-	if (target >= rsz) {
-		/* its already at the effective top */
-		return;
-	}
-
-	move_region_to_layer (target, region, 1);
-}
-
-void
-Playlist::lower_region (boost::shared_ptr<Region> region)
-{
-	if (region->layer() == 0) {
-		/* its already at the bottom */
-		return;
-	}
-
-	layer_t target = region->layer() - 1U;
-
-	move_region_to_layer (target, region, -1);
-}
-
 void
 Playlist::raise_region_to_top (boost::shared_ptr<Region> region)
 {
 	/* does nothing useful if layering mode is later=higher */
-	if ((_session.get_layer_model() == Session::MoveAddHigher) ||
-	    (_session.get_layer_model() == Session::AddHigher)) {
+	if ((Config->get_layer_model() == MoveAddHigher) ||
+	    (Config->get_layer_model() == AddHigher)) {
 		timestamp_layer_op (region);
 		relayer ();
 	}
@@ -1616,89 +1700,18 @@ void
 Playlist::lower_region_to_bottom (boost::shared_ptr<Region> region)
 {
 	/* does nothing useful if layering mode is later=higher */
-	if ((_session.get_layer_model() == Session::MoveAddHigher) ||
-	    (_session.get_layer_model() == Session::AddHigher)) {
+	if ((Config->get_layer_model() == MoveAddHigher) ||
+	    (Config->get_layer_model() == AddHigher)) {
 		region->set_last_layer_op (0);
 		relayer ();
 	}
 }
 
-int
-Playlist::move_region_to_layer (layer_t target_layer, boost::shared_ptr<Region> region, int dir)
-{
-	RegionList::iterator i;
-	typedef pair<boost::shared_ptr<Region>,layer_t> LayerInfo;
-	list<LayerInfo> layerinfo;
-	layer_t dest;
-
-	{
-		RegionLock rlock (const_cast<Playlist *> (this));
-		
-		for (i = regions.begin(); i != regions.end(); ++i) {
-			
-			if (region == *i) {
-				continue;
-			}
-
-			if (dir > 0) {
-
-				/* region is moving up, move all regions on intermediate layers
-				   down 1
-				*/
-				
-				if ((*i)->layer() > region->layer() && (*i)->layer() <= target_layer) {
-					dest = (*i)->layer() - 1;
-				} else {
-					/* not affected */
-					continue;
-				}
-			} else {
-
-				/* region is moving down, move all regions on intermediate layers
-				   up 1
-				*/
-
-				if ((*i)->layer() < region->layer() && (*i)->layer() >= target_layer) {
-					dest = (*i)->layer() + 1;
-				} else {
-					/* not affected */
-					continue;
-				}
-			}
-
-			LayerInfo newpair;
-			
-			newpair.first = *i;
-			newpair.second = dest;
-			
-			layerinfo.push_back (newpair);
-		} 
-	}
-
-	/* now reset the layers without holding the region lock */
-
-	for (list<LayerInfo>::iterator x = layerinfo.begin(); x != layerinfo.end(); ++x) {
-		x->first->set_layer (x->second);
-	}
-
-	region->set_layer (target_layer);
-
-	/* now check all dependents */
-
-	for (list<LayerInfo>::iterator x = layerinfo.begin(); x != layerinfo.end(); ++x) {
-		check_dependents (x->first, false);
-	}
-	
-	check_dependents (region, false);
-	
-	return 0;
-}
-
 void
-Playlist::nudge_after (jack_nframes_t start, jack_nframes_t distance, bool forwards)
+Playlist::nudge_after (nframes_t start, nframes_t distance, bool forwards)
 {
 	RegionList::iterator i;
-	jack_nframes_t new_pos;
+	nframes_t new_pos;
 	bool moved = false;
 
 	_nudging = true;
@@ -1735,7 +1748,6 @@ Playlist::nudge_after (jack_nframes_t start, jack_nframes_t distance, bool forwa
 
 	if (moved) {
 		_nudging = false;
-		maybe_save_state (_("nudged"));
 		notify_length_changed ();
 	}
 
@@ -1745,26 +1757,31 @@ boost::shared_ptr<Region>
 Playlist::find_region (const ID& id) const
 {
 	RegionLock rlock (const_cast<Playlist*> (this));
-	RegionList::const_iterator i;
-	boost::shared_ptr<Region> ret;
 
-	for (i = regions.begin(); i != regions.end(); ++i) {
+	/* searches all regions currently in use by the playlist */
+
+	for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
 		if ((*i)->id() == id) {
-			ret = *i;
+			return *i;
 		}
 	}
 
-	return ret;
+	return boost::shared_ptr<Region> ();
 }
-	
-void
-Playlist::save_state (std::string why)
+
+boost::shared_ptr<Region>
+Playlist::region_by_id (ID id)
 {
-	if (!in_set_state) {
-		StateManager::save_state (why);
+	/* searches all regions ever added to this playlist */
+
+	for (set<boost::shared_ptr<Region> >::iterator i = all_regions.begin(); i != all_regions.end(); ++i) {
+		if ((*i)->id() == id) {
+			return *i;
+		}
 	}
+	return boost::shared_ptr<Region> ();
 }
-
+	
 void
 Playlist::dump () const
 {
@@ -1800,13 +1817,3 @@ Playlist::timestamp_layer_op (boost::shared_ptr<Region> region)
 	region->set_last_layer_op (++layer_op_counter);
 }
 
-void
-Playlist::maybe_save_state (string why)
-{
-	if (holding_state ()) {
-		save_on_thaw = true;
-		last_save_reason = why;
-	} else {
-		save_state (why);
-	}
-}