X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Feditor_ops.cc;h=77dad5bf29de7806cd6caf7f6f2cd0f1aeefeefc;hb=5fef65538040fbac1b9edd1847a269aa925a49c9;hp=0562befb953844ec643bc3fa0d914f89190ddda9;hpb=c04285addf47b71c4046a97de231cab88edd5241;p=ardour.git

diff --git a/gtk2_ardour/editor_ops.cc b/gtk2_ardour/editor_ops.cc
index 0562befb95..77dad5bf29 100644
--- a/gtk2_ardour/editor_ops.cc
+++ b/gtk2_ardour/editor_ops.cc
@@ -24,6 +24,7 @@
 #include <cstdlib>
 #include <cmath>
 #include <string>
+#include <limits>
 #include <map>
 #include <set>
 
@@ -47,7 +48,9 @@
 #include "ardour/midi_track.h"
 #include "ardour/operations.h"
 #include "ardour/playlist_factory.h"
+#include "ardour/profile.h"
 #include "ardour/quantize.h"
+#include "ardour/legatize.h"
 #include "ardour/region_factory.h"
 #include "ardour/reverse.h"
 #include "ardour/session.h"
@@ -57,37 +60,42 @@
 
 #include "canvas/canvas.h"
 
+#include "actions.h"
 #include "ardour_ui.h"
-#include "debug.h"
-#include "editor.h"
-#include "time_axis_view.h"
-#include "route_time_axis.h"
+#include "audio_region_view.h"
+#include "audio_streamview.h"
 #include "audio_time_axis.h"
+#include "automation_region_view.h"
 #include "automation_time_axis.h"
 #include "control_point.h"
-#include "streamview.h"
-#include "audio_streamview.h"
-#include "audio_region_view.h"
-#include "midi_region_view.h"
-#include "rgb_macros.h"
-#include "selection_templates.h"
-#include "selection.h"
+#include "debug.h"
 #include "editing.h"
-#include "gtk-custom-hruler.h"
-#include "gui_thread.h"
-#include "keyboard.h"
-#include "utils.h"
+#include "editor.h"
+#include "editor_cursors.h"
 #include "editor_drag.h"
-#include "strip_silence_dialog.h"
-#include "editor_routes.h"
 #include "editor_regions.h"
-#include "quantize_dialog.h"
-#include "interthread_progress_window.h"
+#include "editor_routes.h"
+#include "gui_thread.h"
 #include "insert_time_dialog.h"
-#include "normalize_dialog.h"
-#include "editor_cursors.h"
+#include "interthread_progress_window.h"
+#include "item_counts.h"
+#include "keyboard.h"
+#include "midi_region_view.h"
+#include "mixer_strip.h"
 #include "mouse_cursors.h"
+#include "normalize_dialog.h"
+#include "note.h"
+#include "paste_context.h"
 #include "patch_change_dialog.h"
+#include "quantize_dialog.h"
+#include "region_gain_line.h"
+#include "rgb_macros.h"
+#include "route_time_axis.h"
+#include "selection.h"
+#include "selection_templates.h"
+#include "streamview.h"
+#include "strip_silence_dialog.h"
+#include "time_axis_view.h"
 #include "transpose_dialog.h"
 
 #include "i18n.h"
@@ -133,7 +141,11 @@ Editor::split_regions_at (framepos_t where, RegionSelection& regions)
 {
 	bool frozen = false;
 
-	list <boost::shared_ptr<Playlist > > used_playlists;
+	RegionSelection pre_selected_regions = selection->regions;
+	bool working_on_selection = !pre_selected_regions.empty();
+
+	list<boost::shared_ptr<Playlist> > used_playlists;
+	list<RouteTimeAxisView*> used_trackviews;
 
 	if (regions.empty()) {
 		return;
@@ -188,9 +200,16 @@ Editor::split_regions_at (framepos_t where, RegionSelection& regions)
 
 			/* remember used playlists so we can thaw them later */
 			used_playlists.push_back(pl);
+
+			TimeAxisView& tv = (*a)->get_time_axis_view();
+			RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (&tv);
+			if (rtv) {
+				used_trackviews.push_back (rtv);
+			}
 			pl->freeze();
 		}
 
+
 		if (pl) {
 			pl->clear_changes ();
 			pl->split_region ((*a)->region(), where);
@@ -200,17 +219,45 @@ Editor::split_regions_at (framepos_t where, RegionSelection& regions)
 		a = tmp;
 	}
 
+	latest_regionviews.clear ();
+
+	vector<sigc::connection> region_added_connections;
+
+	for (list<RouteTimeAxisView*>::iterator i = used_trackviews.begin(); i != used_trackviews.end(); ++i) {
+		region_added_connections.push_back ((*i)->view()->RegionViewAdded.connect (sigc::mem_fun(*this, &Editor::collect_new_region_view)));
+	}
+	
 	while (used_playlists.size() > 0) {
 		list <boost::shared_ptr<Playlist > >::iterator i = used_playlists.begin();
 		(*i)->thaw();
 		used_playlists.pop_front();
 	}
 
-	commit_reversible_command ();
+	for (vector<sigc::connection>::iterator c = region_added_connections.begin(); c != region_added_connections.end(); ++c) {
+		(*c).disconnect ();
+	}
 
 	if (frozen){
 		EditorThaw(); /* Emit Signal */
 	}
+
+	if (ARDOUR::Profile->get_mixbus()) {
+		//IFF we were working on selected regions, try to reinstate the other region selections that existed before the freeze/thaw.
+		_ignore_follow_edits = true;  //a split will change the region selection in mysterious ways;  its not practical or wanted to follow this edit
+		if( working_on_selection ) {
+			selection->add ( pre_selected_regions );
+			selection->add (latest_regionviews);  //these are the new regions created after the split
+		}
+		_ignore_follow_edits = false;
+	} else {
+		_ignore_follow_edits = true;
+		if( working_on_selection ) {
+			selection->add (latest_regionviews);  //these are the new regions created after the split
+		}
+		_ignore_follow_edits = false;
+	}
+
+	commit_reversible_command ();
 }
 
 /** Move one extreme of the current range selection.  If more than one range is selected,
@@ -511,6 +558,60 @@ Editor::nudge_backward_capture_offset ()
 	commit_reversible_command ();
 }
 
+struct RegionSelectionPositionSorter {
+        bool operator() (RegionView* a, RegionView* b) {
+                return a->region()->position() < b->region()->position();
+        }
+};
+
+void
+Editor::sequence_regions ()
+{
+	framepos_t r_end;
+	framepos_t r_end_prev;
+
+	int iCount=0;
+
+	if (!_session) {
+		return;
+	}
+
+	RegionSelection rs = get_regions_from_selection_and_entered ();
+	rs.sort(RegionSelectionPositionSorter());
+
+	if (!rs.empty()) {
+
+		begin_reversible_command (_("sequence regions"));
+		for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
+			boost::shared_ptr<Region> r ((*i)->region());
+
+			r->clear_changes();
+
+			if(r->locked())
+			{
+				continue;
+			}
+			if(r->position_locked())
+			{
+				continue;
+			}
+			if(iCount>0)
+			{
+				r_end_prev=r_end;
+				r->set_position(r_end_prev);
+			}
+
+			_session->add_command (new StatefulDiffCommand (r));
+
+			r_end=r->position() + r->length();
+
+			iCount++;
+		}
+		commit_reversible_command ();
+	} 
+} 
+
+
 /* DISPLAY MOTION */
 
 void
@@ -557,7 +658,7 @@ Editor::build_region_boundary_cache ()
 		break;
 	default:
 		fatal << string_compose (_("build_region_boundary_cache called with snap_type = %1"), _snap_type) << endmsg;
-		/*NOTREACHED*/
+		abort(); /*NOTREACHED*/
 		return;
 	}
 
@@ -1275,12 +1376,78 @@ Editor::scroll_tracks_up_line ()
 	reset_y_origin (vertical_adjustment.get_value() - 60);
 }
 
+bool
+Editor::scroll_down_one_track ()
+{
+	TrackViewList::reverse_iterator next = track_views.rend();
+	std::pair<TimeAxisView*,double> res;
+	const double top_of_trackviews = vertical_adjustment.get_value();
+
+	for (TrackViewList::reverse_iterator t = track_views.rbegin(); t != track_views.rend(); ++t) {
+		if ((*t)->hidden()) {
+			continue;
+		}
+
+
+		/* If this is the upper-most visible trackview, we want to display
+		   the one above it (next)
+		*/
+
+		res = (*t)->covers_y_position (top_of_trackviews);
+
+		if (res.first) {
+			break;
+		}
+		next = t;
+	}
+
+	/* move to the track below the first one that covers the */
+	
+	if (next != track_views.rend()) {
+		ensure_time_axis_view_is_visible (**next, true);
+		return true;
+	}
+
+	return false;
+}	
+
+bool
+Editor::scroll_up_one_track ()
+{
+	TrackViewList::iterator prev = track_views.end();
+	std::pair<TimeAxisView*,double> res;
+	double top_of_trackviews = vertical_adjustment.get_value ();
+	
+	for (TrackViewList::iterator t = track_views.begin(); t != track_views.end(); ++t) {
+
+		if ((*t)->hidden()) {
+			continue;
+		}
+
+		/* find the trackview at the top of the trackview group */
+		res = (*t)->covers_y_position (top_of_trackviews);
+		
+		if (res.first) {
+			break;
+		}
+
+		prev = t;
+	}
+	
+	if (prev != track_views.end()) {
+		ensure_time_axis_view_is_visible (**prev, true);
+		return true;
+	}
+
+	return false;
+}
+
 /* ZOOM */
 
 void
 Editor::tav_zoom_step (bool coarser)
 {
-	_routes->suspend_redisplay ();
+	DisplaySuspender ds;
 
 	TrackViewList* ts;
 
@@ -1294,14 +1461,12 @@ Editor::tav_zoom_step (bool coarser)
 		TimeAxisView *tv = (static_cast<TimeAxisView*>(*i));
 			tv->step_height (coarser);
 	}
-
-	_routes->resume_redisplay ();
 }
 
 void
 Editor::tav_zoom_smooth (bool coarser, bool force_all)
 {
-	_routes->suspend_redisplay ();
+	DisplaySuspender ds;
 
 	TrackViewList* ts;
 
@@ -1326,27 +1491,8 @@ Editor::tav_zoom_smooth (bool coarser, bool force_all)
 			tv->set_height (h + 5);
 		}
 	}
-
-	_routes->resume_redisplay ();
 }
 
-bool
-Editor::clamp_samples_per_pixel (framecnt_t& fpp) const
-{
-	bool clamped = false;
-	
-	if (fpp < 1) {
-		fpp = 1;
-		clamped = true;
-	}
-
-	if (max_framepos / fpp < 800) {
-		fpp = max_framepos / 800;
-		clamped = true;
-	}
-
-	return clamped;
-}
 
 void
 Editor::temporal_zoom_step (bool coarser)
@@ -1383,7 +1529,6 @@ Editor::temporal_zoom (framecnt_t fpp)
 	framecnt_t nfpp;
 	double l;
 
-	clamp_samples_per_pixel (fpp);
 	if (fpp == samples_per_pixel) {
 		return;
 	}
@@ -1397,7 +1542,7 @@ Editor::temporal_zoom (framecnt_t fpp)
 	// would be 4147200000 samples, so 2592000 samples per pixel.
 
 	nfpp = min (fpp, (framecnt_t) 2592000);
-	nfpp = max ((framecnt_t) 1, fpp);
+	nfpp = max ((framecnt_t) 1, nfpp);
 
 	new_page_size = (framepos_t) floor (_visible_canvas_width * nfpp);
 	half_page_size = new_page_size / 2;
@@ -1495,6 +1640,37 @@ Editor::temporal_zoom (framecnt_t fpp)
 	reposition_and_zoom (leftmost_after_zoom, nfpp);
 }
 
+void
+Editor::calc_extra_zoom_edges(framepos_t &start, framepos_t &end)
+{
+	/* this func helps make sure we leave a little space
+	   at each end of the editor so that the zoom doesn't fit the region
+	   precisely to the screen.
+	*/
+
+	GdkScreen* screen = gdk_screen_get_default ();
+	const gint pixwidth = gdk_screen_get_width (screen);
+	const gint mmwidth = gdk_screen_get_width_mm (screen);
+	const double pix_per_mm = (double) pixwidth/ (double) mmwidth;
+	const double one_centimeter_in_pixels = pix_per_mm * 10.0;
+
+	const framepos_t range = end - start;
+	const framecnt_t new_fpp = (framecnt_t) ceil ((double) range / (double) _visible_canvas_width);
+	const framepos_t extra_samples = (framepos_t) floor (one_centimeter_in_pixels * new_fpp);
+
+	if (start > extra_samples) {
+		start -= extra_samples;
+	} else {
+		start = 0;
+	}
+
+	if (max_framepos - extra_samples > end) {
+		end += extra_samples;
+	} else {
+		end = max_framepos;
+	}
+}
+
 void
 Editor::temporal_zoom_region (bool both_axes)
 {
@@ -1521,36 +1697,11 @@ Editor::temporal_zoom_region (bool both_axes)
 		tracks.insert (&((*i)->get_time_axis_view()));
 	}
 
-	/* now comes an "interesting" hack ... make sure we leave a little space
-	   at each end of the editor so that the zoom doesn't fit the region
-	   precisely to the screen.
-	*/
-
-	GdkScreen* screen = gdk_screen_get_default ();
-	gint pixwidth = gdk_screen_get_width (screen);
-	gint mmwidth = gdk_screen_get_width_mm (screen);
-	double pix_per_mm = (double) pixwidth/ (double) mmwidth;
-	double one_centimeter_in_pixels = pix_per_mm * 10.0;
-
 	if ((start == 0 && end == 0) || end < start) {
 		return;
 	}
 
-	framepos_t range = end - start;
-	double new_fpp = (double) range / (double) _visible_canvas_width;
-	framepos_t extra_samples = (framepos_t) floor (one_centimeter_in_pixels * new_fpp);
-
-	if (start > extra_samples) {
-		start -= extra_samples;
-	} else {
-		start = 0;
-	}
-
-	if (max_framepos - extra_samples > end) {
-		end += extra_samples;
-	} else {
-		end = max_framepos;
-	}
+	calc_extra_zoom_edges (start, end);
 
 	/* if we're zooming on both axes we need to save track heights etc.
 	 */
@@ -1572,7 +1723,7 @@ Editor::temporal_zoom_region (bool both_axes)
 
 		/* hide irrelevant tracks */
 
-		_routes->suspend_redisplay ();
+		DisplaySuspender ds;
 
 		for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
 			if (find (tracks.begin(), tracks.end(), (*i)) == tracks.end()) {
@@ -1580,8 +1731,6 @@ Editor::temporal_zoom_region (bool both_axes)
 			}
 		}
 
-		_routes->resume_redisplay ();
-
 		vertical_adjustment.set_value (0.0);
 	}
 
@@ -1595,18 +1744,28 @@ Editor::zoom_to_region (bool both_axes)
 }
 
 void
-Editor::temporal_zoom_selection ()
+Editor::temporal_zoom_selection (bool both_axes)
 {
 	if (!selection) return;
 
-	if (selection->time.empty()) {
-		return;
+	//if a range is selected, zoom to that
+	if (!selection->time.empty()) {
+
+		framepos_t start = selection->time.start();
+		framepos_t end = selection->time.end_frame();
+
+		calc_extra_zoom_edges(start, end);
+
+		temporal_zoom_by_frame (start, end);
+
+		if (both_axes)
+			fit_selected_tracks();
+
+	} else {
+		temporal_zoom_region (both_axes);
 	}
 
-	framepos_t start = selection->time[clicked_selection].start;
-	framepos_t end = selection->time[clicked_selection].end;
 
-	temporal_zoom_by_frame (start, end);
 }
 
 void
@@ -1615,13 +1774,28 @@ Editor::temporal_zoom_session ()
 	ENSURE_GUI_THREAD (*this, &Editor::temporal_zoom_session)
 
 	if (_session) {
-		framecnt_t const l = _session->current_end_frame() - _session->current_start_frame();
-		double s = _session->current_start_frame() - l * 0.01;
-		if (s < 0) {
-			s = 0;
+		framecnt_t start = _session->current_start_frame();
+		framecnt_t end = _session->current_end_frame();
+
+		if (_session->actively_recording () ) {
+			framepos_t cur = playhead_cursor->current_frame ();
+			if (cur > end) {
+				/* recording beyond the end marker; zoom out
+				 * by 5 seconds more so that if 'follow
+				 * playhead' is active we don't immediately
+				 * scroll.
+				 */
+				end = cur + _session->frame_rate() * 5;
+			}
+		}
+
+		if ((start == 0 && end == 0) || end < start) {
+			return;
 		}
-		framecnt_t const e = _session->current_end_frame() + l * 0.01;
-		temporal_zoom_by_frame (framecnt_t (s), e);
+
+		calc_extra_zoom_edges(start, end);
+
+		temporal_zoom_by_frame (start, end);
 	}
 }
 
@@ -1636,9 +1810,9 @@ Editor::temporal_zoom_by_frame (framepos_t start, framepos_t end)
 
 	framepos_t range = end - start;
 
-	double const new_fpp = (double) range / (double) _visible_canvas_width;
-
-	framepos_t new_page = (framepos_t) floor (_visible_canvas_width * new_fpp);
+	const framecnt_t new_fpp = (framecnt_t) ceil ((double) range / (double) _visible_canvas_width);
+	
+	framepos_t new_page = range;
 	framepos_t middle = (framepos_t) floor ((double) start + ((double) range / 2.0f));
 	framepos_t new_leftmost = (framepos_t) floor ((double) middle - ((double) new_page / 2.0f));
 
@@ -1659,23 +1833,38 @@ Editor::temporal_zoom_to_frame (bool coarser, framepos_t frame)
 	if (!_session) {
 		return;
 	}
-	double range_before = frame - leftmost_frame;
-	double new_fpp;
 
-	new_fpp = samples_per_pixel;
+	framecnt_t range_before = frame - leftmost_frame;
+	framecnt_t new_spp;
 
 	if (coarser) {
-		new_fpp *= 1.61803399;
-		range_before *= 1.61803399;
+		if (samples_per_pixel <= 1) {
+			new_spp = 2;
+		} else {
+			new_spp = samples_per_pixel + (samples_per_pixel/2);
+		}
+		range_before += range_before/2;
 	} else {
-		new_fpp = max(1.0,(new_fpp/1.61803399));
-		range_before /= 1.61803399;
+		if (samples_per_pixel >= 1) {
+			new_spp = samples_per_pixel - (samples_per_pixel/2);
+		} else {
+			/* could bail out here since we cannot zoom any finer,
+			   but leave that to the equality test below
+			*/
+			new_spp = samples_per_pixel;
+		}
+
+		range_before -= range_before/2;
 	}
 
-	if (new_fpp == samples_per_pixel)  {
+	if (new_spp == samples_per_pixel)  {
 		return;
 	}
 
+	/* zoom focus is automatically taken as @param frame when this
+	   method is used.
+	*/
+	
 	framepos_t new_leftmost = frame - (framepos_t)range_before;
 
 	if (new_leftmost > frame) {
@@ -1686,7 +1875,7 @@ Editor::temporal_zoom_to_frame (bool coarser, framepos_t frame)
 		new_leftmost = 0;
 	}
 
-	reposition_and_zoom (new_leftmost, new_fpp);
+	reposition_and_zoom (new_leftmost, new_spp);
 }
 
 
@@ -1745,12 +1934,14 @@ Editor::add_location_from_selection ()
 	_session->locations()->next_available_name(rangename,"selection");
 	Location *location = new Location (*_session, start, end, rangename, Location::IsRangeMarker);
 
-	_session->begin_reversible_command (_("add marker"));
+	begin_reversible_command (_("add marker"));
+	
 	XMLNode &before = _session->locations()->get_state();
 	_session->locations()->add (location, true);
 	XMLNode &after = _session->locations()->get_state();
 	_session->add_command(new MementoCommand<Locations>(*(_session->locations()), &before, &after));
-	_session->commit_reversible_command ();
+	
+	commit_reversible_command ();
 }
 
 void
@@ -1765,12 +1956,14 @@ Editor::add_location_mark (framepos_t where)
 		return;
 	}
 	Location *location = new Location (*_session, where, where, markername, Location::IsMark);
-	_session->begin_reversible_command (_("add marker"));
+	begin_reversible_command (_("add marker"));
+	
 	XMLNode &before = _session->locations()->get_state();
 	_session->locations()->add (location, true);
 	XMLNode &after = _session->locations()->get_state();
 	_session->add_command(new MementoCommand<Locations>(*(_session->locations()), &before, &after));
-	_session->commit_reversible_command ();
+	
+	commit_reversible_command ();
 }
 
 void
@@ -1779,6 +1972,37 @@ Editor::add_location_from_playhead_cursor ()
 	add_location_mark (_session->audible_frame());
 }
 
+void
+Editor::remove_location_at_playhead_cursor ()
+{
+	if (_session) {
+
+		//set up for undo
+		begin_reversible_command (_("remove marker"));
+		
+		XMLNode &before = _session->locations()->get_state();
+		bool removed = false;
+
+		//find location(s) at this time
+		Locations::LocationList locs;
+		_session->locations()->find_all_between (_session->audible_frame(), _session->audible_frame()+1, locs, Location::Flags(0));
+		for (Locations::LocationList::iterator i = locs.begin(); i != locs.end(); ++i) {
+			if ((*i)->is_mark()) {
+				_session->locations()->remove (*i);
+				removed = true;
+			}
+		}
+		
+		//store undo
+		if (removed) {
+			XMLNode &after = _session->locations()->get_state();
+			_session->add_command(new MementoCommand<Locations>(*(_session->locations()), &before, &after));
+			
+			commit_reversible_command ();
+		}
+	}
+}
+
 /** Add a range marker around each selected region */
 void
 Editor::add_locations_from_region ()
@@ -1789,7 +2013,8 @@ Editor::add_locations_from_region ()
 		return;
 	}
 
-	_session->begin_reversible_command (selection->regions.size () > 1 ? _("add markers") : _("add marker"));
+	begin_reversible_command (selection->regions.size () > 1 ? _("add markers") : _("add marker"));
+	
 	XMLNode &before = _session->locations()->get_state();
 
 	for (RegionSelection::iterator i = rs.begin (); i != rs.end (); ++i) {
@@ -1803,7 +2028,8 @@ Editor::add_locations_from_region ()
 
 	XMLNode &after = _session->locations()->get_state();
 	_session->add_command (new MementoCommand<Locations>(*(_session->locations()), &before, &after));
-	_session->commit_reversible_command ();
+	
+	commit_reversible_command ();
 }
 
 /** Add a single range marker around all selected regions */
@@ -1816,7 +2042,8 @@ Editor::add_location_from_region ()
 		return;
 	}
 
-	_session->begin_reversible_command (_("add marker"));
+	begin_reversible_command (_("add marker"));
+	
 	XMLNode &before = _session->locations()->get_state();
 
 	string markername;
@@ -1839,7 +2066,8 @@ Editor::add_location_from_region ()
 
 	XMLNode &after = _session->locations()->get_state();
 	_session->add_command (new MementoCommand<Locations>(*(_session->locations()), &before, &after));
-	_session->commit_reversible_command ();
+	
+	commit_reversible_command ();
 }
 
 /* MARKS */
@@ -1895,12 +2123,14 @@ void
 Editor::clear_markers ()
 {
 	if (_session) {
-		_session->begin_reversible_command (_("clear markers"));
+		begin_reversible_command (_("clear markers"));
+		
 		XMLNode &before = _session->locations()->get_state();
 		_session->locations()->clear_markers ();
 		XMLNode &after = _session->locations()->get_state();
 		_session->add_command(new MementoCommand<Locations>(*(_session->locations()), &before, &after));
-		_session->commit_reversible_command ();
+		
+		commit_reversible_command ();
 	}
 }
 
@@ -1908,35 +2138,30 @@ void
 Editor::clear_ranges ()
 {
 	if (_session) {
-		_session->begin_reversible_command (_("clear ranges"));
+		begin_reversible_command (_("clear ranges"));
+		
 		XMLNode &before = _session->locations()->get_state();
 
-		Location * looploc = _session->locations()->auto_loop_location();
-		Location * punchloc = _session->locations()->auto_punch_location();
-		Location * sessionloc = _session->locations()->session_range_location();
-
 		_session->locations()->clear_ranges ();
-		// re-add these
-		if (looploc) _session->locations()->add (looploc);
-		if (punchloc) _session->locations()->add (punchloc);
-		if (sessionloc) _session->locations()->add (sessionloc);
 
 		XMLNode &after = _session->locations()->get_state();
 		_session->add_command(new MementoCommand<Locations>(*(_session->locations()), &before, &after));
-		_session->commit_reversible_command ();
+		
+		commit_reversible_command ();
 	}
 }
 
 void
 Editor::clear_locations ()
 {
-	_session->begin_reversible_command (_("clear locations"));
+	begin_reversible_command (_("clear locations"));
+	
 	XMLNode &before = _session->locations()->get_state();
 	_session->locations()->clear ();
 	XMLNode &after = _session->locations()->get_state();
 	_session->add_command(new MementoCommand<Locations>(*(_session->locations()), &before, &after));
-	_session->commit_reversible_command ();
-	_session->locations()->clear ();
+	
+	commit_reversible_command ();
 }
 
 void
@@ -1963,85 +2188,6 @@ Editor::unhide_ranges ()
 
 /* INSERT/REPLACE */
 
-void
-Editor::insert_region_list_drag (boost::shared_ptr<Region> region, int x, int y)
-{
-	double cx, cy;
-	framepos_t where;
-	RouteTimeAxisView *rtv = 0;
-	boost::shared_ptr<Playlist> playlist;
-
-	GdkEvent event;
-	event.type = GDK_BUTTON_RELEASE;
-	event.button.x = x;
-	event.button.y = y;
-
-	where = window_event_sample (&event, &cx, &cy);
-
-	if (where < leftmost_frame || where > leftmost_frame + current_page_samples()) {
-		/* clearly outside canvas area */
-		return;
-	}
-
-	std::pair<TimeAxisView*, int> tv = trackview_by_y_position (cy);
-	if (tv.first == 0) {
-		return;
-	}
-
-	if ((rtv = dynamic_cast<RouteTimeAxisView*> (tv.first)) == 0) {
-		return;
-	}
-
-	if ((playlist = rtv->playlist()) == 0) {
-		return;
-	}
-
-	snap_to (where);
-
-	begin_reversible_command (_("insert dragged region"));
-	playlist->clear_changes ();
-	playlist->add_region (RegionFactory::create (region, true), where, 1.0);
-	_session->add_command(new StatefulDiffCommand (playlist));
-	commit_reversible_command ();
-}
-
-void
-Editor::insert_route_list_drag (boost::shared_ptr<Route> route, int x, int y)
-{
-	double cx, cy;
-	RouteTimeAxisView *dest_rtv = 0;
-	RouteTimeAxisView *source_rtv = 0;
-
-	GdkEvent event;
-	event.type = GDK_BUTTON_RELEASE;
-	event.button.x = x;
-	event.button.y = y;
-
-	window_event_sample (&event, &cx, &cy);
-
-	std::pair<TimeAxisView*, int> const tv = trackview_by_y_position (cy);
-	if (tv.first == 0) {
-		return;
-	}
-
-	if ((dest_rtv = dynamic_cast<RouteTimeAxisView*> (tv.first)) == 0) {
-		return;
-	}
-
-	/* use this drag source to add underlay to a track. But we really don't care
-	   about the Route, only the view of the route, so find it first */
-	for(TrackViewList::iterator it = track_views.begin(); it != track_views.end(); ++it) {
-		if((source_rtv = dynamic_cast<RouteTimeAxisView*>(*it)) == 0) {
-			continue;
-		}
-
-		if(source_rtv->route() == route && source_rtv != dest_rtv) {
-			dest_rtv->add_underlay(source_rtv->view());
-			break;
-		}
-	}
-}
-
 void
 Editor::insert_region_list_selection (float times)
 {
@@ -2074,6 +2220,9 @@ Editor::insert_region_list_selection (float times)
 	begin_reversible_command (_("insert region"));
 	playlist->clear_changes ();
 	playlist->add_region ((RegionFactory::create (region, true)), get_preferred_edit_position(), times);
+	if (Config->get_edit_mode() == Ripple)
+		playlist->ripple (get_preferred_edit_position(), region->length() * times, boost::shared_ptr<Region>());
+
 	_session->add_command(new StatefulDiffCommand (playlist));
 	commit_reversible_command ();
 }
@@ -2176,7 +2325,7 @@ Editor::get_preroll ()
 void
 Editor::maybe_locate_with_edit_preroll ( framepos_t location )
 {
-	if ( _session->transport_rolling() || !Config->get_always_play_range() )
+	if ( _session->transport_rolling() || !Config->get_follow_edits() || _ignore_follow_edits )
 		return;
 
 	location -= get_preroll();
@@ -2238,8 +2387,8 @@ Editor::loop_location (Location& location)
 		tll->set (location.start(), location.end());
 
 		// enable looping, reposition and start rolling
-		_session->request_play_loop (true);
 		_session->request_locate (tll->start(), true);
+		_session->request_play_loop (true);
 	}
 }
 
@@ -2578,6 +2727,7 @@ static void
 add_if_covered (RegionView* rv, const AudioRange* ar, RegionSelection* rs)
 {
 	switch (rv->region()->coverage (ar->start, ar->end - 1)) {
+	// n.b. -1 because AudioRange::end is one past the end, but coverage expects inclusive ranges
 	case Evoral::OverlapNone:
 		break;
 	default:
@@ -2697,8 +2847,7 @@ Editor::separate_regions_between (const TimeSelection& ts)
 	}
 
 	if (in_command)	{
-		selection->set (new_selection);
-		set_mouse_mode (MouseObject);
+//		selection->set (new_selection);
 
 		commit_reversible_command ();
 	}
@@ -3457,10 +3606,8 @@ Editor::freeze_thread ()
 	/* create event pool because we may need to talk to the session */
 	SessionEvent::create_per_thread_pool ("freeze events", 64);
 	/* create per-thread buffers for process() tree to use */
-	current_interthread_info->process_thread.get_buffers ();
 	clicked_routeview->audio_track()->freeze_me (*current_interthread_info);
 	current_interthread_info->done = true;
-	current_interthread_info->process_thread.drop_buffers();
 	return 0;
 }
 
@@ -3615,7 +3762,14 @@ Editor::bounce_range_selection (bool replace, bool enable_processing)
 void
 Editor::delete_ ()
 {
-	cut_copy (Delete);
+	//special case: if the user is pointing in the editor/mixer strip, they may be trying to delete a plugin.
+	//we need this because the editor-mixer strip is in the editor window, so it doesn't get the bindings from the mix window
+	bool deleted = false;
+	if ( current_mixer_strip && current_mixer_strip == MixerStrip::entered_mixer_strip() )
+		deleted = current_mixer_strip->delete_processors ();
+
+	if (!deleted)
+		cut_copy (Delete);
 }
 
 /** Cut selected regions, automation points or a time range */
@@ -3637,30 +3791,15 @@ Editor::copy ()
 bool
 Editor::can_cut_copy () const
 {
-	switch (effective_mouse_mode()) {
-
-	case MouseObject:
-		if (!selection->regions.empty() || !selection->points.empty()) {
-			return true;
-		}
-		break;
-
-	case MouseRange:
-		if (!selection->time.empty()) {
-			return true;
-		}
-		break;
-
-	default:
-		break;
-	}
+	if (!selection->time.empty() || !selection->regions.empty() || !selection->points.empty())
+		return true;
 
 	return false;
 }
 
 
 /** Cut, copy or clear selected regions, automation points or a time range.
- * @param op Operation (Cut, Copy or Clear)
+ * @param op Operation (Delete, Cut, Copy or Clear)
  */
 void
 Editor::cut_copy (CutCopyOp op)
@@ -3696,7 +3835,7 @@ Editor::cut_copy (CutCopyOp op)
 		}
 	}
 
-	if ( op != Clear )  //"Delete" doesn't change copy/paste buf
+	if ( op != Delete )  //"Delete" doesn't change copy/paste buf
 		cut_buffer->clear ();
 
 	if (entered_marker) {
@@ -3714,125 +3853,75 @@ Editor::cut_copy (CutCopyOp op)
 		return;
 	}
 
-	if (internal_editing()) {
-
-		switch (effective_mouse_mode()) {
-		case MouseObject:
-		case MouseRange:
-			cut_copy_midi (op);
-			break;
-		default:
-			break;
-		}
-
-	} else {
-
-	RegionSelection rs; 
-
-	/* we only want to cut regions if some are selected */
-
-	if (!selection->regions.empty()) {
-		rs = selection->regions;
+	switch (mouse_mode) {
+	case MouseDraw:
+	case MouseContent:
+		begin_reversible_command (opname + ' ' + X_("MIDI"));
+		cut_copy_midi (op);
+		commit_reversible_command ();
+		return;
+	default:
+		break;
 	}
 
-	switch (effective_mouse_mode()) {
-/*
- * 		case MouseGain: {
-			//find regions's gain line
-			AudioRegionView *rview = dynamic_cast<AudioRegionView*>(clicked_regionview);
-				AutomationTimeAxisView *tview = dynamic_cast<AutomationTimeAxisView*>(clicked_trackview);
-			if (rview) {
-				AudioRegionGainLine *line = rview->get_gain_line();
-				if (!line) break;
-				
-				//cut region gain points in the selection
-				AutomationList& alist (line->the_list());
-				XMLNode &before = alist.get_state();
-				AutomationList* what_we_got = 0;
-				if ((what_we_got = alist.cut (selection->time.front().start - rview->audio_region()->position(), selection->time.front().end - rview->audio_region()->position())) != 0) {
-					session->add_command(new MementoCommand<AutomationList>(alist, &before, &alist.get_state()));
-					delete what_we_got;
-					what_we_got = 0;
-				}
-				
-				rview->set_envelope_visible(true);
-				rview->audio_region()->set_envelope_active(true);
-				
-			} else if (tview) {
-				AutomationLine *line = *(tview->lines.begin());
-				if (!line) break;
-				
-				//cut auto points in the selection
-				AutomationList& alist (line->the_list());
-				XMLNode &before = alist.get_state();
-				AutomationList* what_we_got = 0;
-				if ((what_we_got = alist.cut (selection->time.front().start, selection->time.front().end)) != 0) {
-					session->add_command(new MementoCommand<AutomationList>(alist, &before, &alist.get_state()));
-					delete what_we_got;
-					what_we_got = 0;
-				}		
-			} else
-				break;
-		} break;
-*/			
-		case MouseObject: 
-		case MouseRange:
-			if (!rs.empty() || !selection->points.empty()) {
-				begin_reversible_command (opname + _(" objects"));
-
-				if (!rs.empty()) {
-					cut_copy_regions (op, rs);
-					
-					if (op == Cut || op == Delete) {
-						selection->clear_regions ();
-					}
-				}
+	bool did_edit = false;
 
-				if (!selection->points.empty()) {
-					cut_copy_points (op);
+	if (!selection->regions.empty() || !selection->points.empty()) {
+		begin_reversible_command (opname + ' ' + _("objects"));
+		did_edit = true;
 
-					if (op == Cut || op == Delete) {
-						selection->clear_points ();
-					}
-				}
-
-				commit_reversible_command ();	
-				break;
-			} 
+		if (!selection->regions.empty()) {
+			cut_copy_regions (op, selection->regions);
 			
-			if (selection->time.empty()) {
-				framepos_t start, end;
-				if (!get_edit_op_range (start, end)) {
-					return;
-				}
-				selection->set (start, end);
+			if (op == Cut || op == Delete) {
+				selection->clear_regions ();
 			}
-				
-			begin_reversible_command (opname + _(" range"));
-			cut_copy_ranges (op);
-			commit_reversible_command ();
+		}
+		
+		if (!selection->points.empty()) {
+			cut_copy_points (op);
 			
 			if (op == Cut || op == Delete) {
-				selection->clear_time ();
+				selection->clear_points ();
 			}
+		}
+	} else if (selection->time.empty()) {
+		framepos_t start, end;
+		/* no time selection, see if we can get an edit range
+		   and use that.
+		*/
+		if (get_edit_op_range (start, end)) {
+			selection->set (start, end);
+		}
+	} else if (!selection->time.empty()) {
+		begin_reversible_command (opname + ' ' + _("range"));
 
-			break;
-			
-		default:
-			break;
+		did_edit = true;
+		cut_copy_ranges (op);
+		
+		if (op == Cut || op == Delete) {
+			selection->clear_time ();
 		}
 	}
-
+	
+	if (did_edit) {
+		/* reset repeated paste state */
+		paste_count    = 0;
+		last_paste_pos = 0;
+		commit_reversible_command ();	
+	}
+	
 	if (op == Delete || op == Cut || op == Clear) {
 		_drags->abort ();
 	}
 }
 
 struct AutomationRecord {
-	AutomationRecord () : state (0) {}
-	AutomationRecord (XMLNode* s) : state (s) {}
+	AutomationRecord () : state (0) , line(NULL) {}
+	AutomationRecord (XMLNode* s, const AutomationLine* l) : state (s) , line (l) {}
 	
 	XMLNode* state; ///< state before any operation
+	const AutomationLine* line; ///< line this came from
 	boost::shared_ptr<Evoral::ControlList> copy; ///< copied events for the cut buffer
 };
 
@@ -3840,7 +3929,7 @@ struct AutomationRecord {
  *  @param op Operation (Cut, Copy or Clear)
  */
 void
-Editor::cut_copy_points (CutCopyOp op)
+Editor::cut_copy_points (Editing::CutCopyOp op, Evoral::MusicalTime earliest, bool midi)
 {
 	if (selection->points.empty ()) {
 		return;
@@ -3855,12 +3944,13 @@ Editor::cut_copy_points (CutCopyOp op)
 
 	/* Go through all selected points, making an AutomationRecord for each distinct AutomationList */
 	for (PointSelection::iterator i = selection->points.begin(); i != selection->points.end(); ++i) {
-		boost::shared_ptr<AutomationList> al = (*i)->line().the_list();
+		const AutomationLine&                   line = (*i)->line();
+		const boost::shared_ptr<AutomationList> al   = line.the_list();
 		if (lists.find (al) == lists.end ()) {
 			/* We haven't seen this list yet, so make a record for it.  This includes
 			   taking a copy of its current state, in case this is needed for undo later.
 			*/
-			lists[al] = AutomationRecord (&al->get_state ());
+			lists[al] = AutomationRecord (&al->get_state (), &line);
 		}
 	}
 
@@ -3869,21 +3959,46 @@ Editor::cut_copy_points (CutCopyOp op)
 		   ControlList for each of our source lists to put the cut buffer data in.
 		*/
 		for (Lists::iterator i = lists.begin(); i != lists.end(); ++i) {
-			i->second.copy = i->first->create (i->first->parameter ());
+			i->second.copy = i->first->create (i->first->parameter (), i->first->descriptor());
 		}
 
 		/* Add all selected points to the relevant copy ControlLists */
+		framepos_t start = std::numeric_limits<framepos_t>::max();
 		for (PointSelection::iterator i = selection->points.begin(); i != selection->points.end(); ++i) {
 			boost::shared_ptr<AutomationList> al = (*i)->line().the_list();
-			AutomationList::const_iterator j = (*i)->model ();
-			lists[al].copy->add ((*j)->when, (*j)->value);
+			AutomationList::const_iterator    j  = (*i)->model();
+
+			lists[al].copy->fast_simple_add ((*j)->when, (*j)->value);
+			if (midi) {
+				/* Update earliest MIDI start time in beats */
+				earliest = std::min(earliest,  Evoral::MusicalTime((*j)->when));
+			} else {
+				/* Update earliest session start time in frames */
+				start = std::min(start, (*i)->line().session_position(j));
+			}
+		}
+
+		/* Snap start time backwards, so copy/paste is snap aligned. */
+		if (midi) {
+			if (earliest == Evoral::MusicalTime::max()) {
+				earliest = Evoral::MusicalTime();  // Weird... don't offset
+			}
+			earliest.round_down_to_beat();
+		} else {
+			if (start == std::numeric_limits<double>::max()) {
+				start = 0;  // Weird... don't offset
+			}
+			snap_to(start, RoundDownMaybe);
 		}
 
+		const double line_offset = midi ? earliest.to_double() : start;
 		for (Lists::iterator i = lists.begin(); i != lists.end(); ++i) {
-			/* Correct this copy list so that it starts at time 0 */
-			double const start = i->second.copy->front()->when;
+			/* Correct this copy list so that it is relative to the earliest
+			   start time, so relative ordering between points is preserved
+			   when copying from several lists and the paste starts at the
+			   earliest copied piece of data. */
 			for (AutomationList::iterator j = i->second.copy->begin(); j != i->second.copy->end(); ++j) {
-				(*j)->when -= start;
+				(*j)->when -= line_offset;
 			}
 
 			/* And add it to the cut buffer */
@@ -3919,13 +4034,27 @@ Editor::cut_copy_points (CutCopyOp op)
 void
 Editor::cut_copy_midi (CutCopyOp op)
 {
+	Evoral::MusicalTime earliest = Evoral::MusicalTime::max();
 	for (MidiRegionSelection::iterator i = selection->midi_regions.begin(); i != selection->midi_regions.end(); ++i) {
-		MidiRegionView* mrv = *i;
-		mrv->cut_copy_clear (op);
-	}
-}
+		MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(*i);
+		if (mrv) {
+			if (!mrv->selection().empty()) {
+				earliest = std::min(earliest, (*mrv->selection().begin())->note()->time());
+			}
+			mrv->cut_copy_clear (op);
 
+			/* XXX: not ideal, as there may be more than one track involved in the selection */
+			_last_cut_copy_source_track = &mrv->get_time_axis_view();
+		}
+	}
 
+	if (!selection->points.empty()) {
+		cut_copy_points (op, earliest, true);
+		if (op == Cut || op == Delete) {
+			selection->clear_points ();
+		}
+	}
+}
 
 struct lt_playlist {
     bool operator () (const PlaylistState& a, const PlaylistState& b) {
@@ -3948,12 +4077,15 @@ Editor::remove_clicked_region ()
 		return;
 	}
 
+	begin_reversible_command (_("remove region"));
+
 	boost::shared_ptr<Playlist> playlist = clicked_routeview->playlist();
 
-	begin_reversible_command (_("remove region"));
 	playlist->clear_changes ();
 	playlist->clear_owned_changes ();
 	playlist->remove_region (clicked_regionview->region());
+	if (Config->get_edit_mode() == Ripple)
+		playlist->ripple (clicked_regionview->region()->position(), -clicked_regionview->region()->length(), boost::shared_ptr<Region>());
 
 	/* We might have removed regions, which alters other regions' layering_index,
 	   so we need to do a recursive diff here.
@@ -4016,6 +4148,9 @@ Editor::remove_selected_regions ()
 		playlist->clear_owned_changes ();
 		playlist->freeze ();
 		playlist->remove_region (*rl);
+		if (Config->get_edit_mode() == Ripple)
+			playlist->ripple ((*rl)->position(), -(*rl)->length(), boost::shared_ptr<Region>());
+
 	}
 
 	vector<boost::shared_ptr<Playlist> >::iterator pl;
@@ -4145,12 +4280,16 @@ Editor::cut_copy_regions (CutCopyOp op, RegionSelection& rs)
 		switch (op) {
 		case Delete:
 			pl->remove_region (r);
+			if (Config->get_edit_mode() == Ripple)
+				pl->ripple (r->position(), -r->length(), boost::shared_ptr<Region>());
 			break;
 			
 		case Cut:
 			_xx = RegionFactory::create (r);
 			npl->add_region (_xx, r->position() - first_position);
 			pl->remove_region (r);
+			if (Config->get_edit_mode() == Ripple)
+				pl->ripple (r->position(), -r->length(), boost::shared_ptr<Region>());
 			break;
 
 		case Copy:
@@ -4159,7 +4298,9 @@ Editor::cut_copy_regions (CutCopyOp op, RegionSelection& rs)
 			break;
 
 		case Clear:
-			pl->remove_region (r);	
+			pl->remove_region (r);
+			if (Config->get_edit_mode() == Ripple)
+				pl->ripple (r->position(), -r->length(), boost::shared_ptr<Region>());
 			break;
 		}
 
@@ -4256,14 +4397,8 @@ Editor::paste_internal (framepos_t position, float times)
 {
         DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("apparent paste position is %1\n", position));
 
-	if (internal_editing()) {
-		if (cut_buffer->midi_notes.empty()) {
-			return;
-		}
-	} else {
-		if (cut_buffer->empty()) {
-			return;
-		}
+	if (cut_buffer->empty(internal_editing())) {
+		return;
 	}
 
 	if (position == max_framepos) {
@@ -4271,45 +4406,102 @@ Editor::paste_internal (framepos_t position, float times)
                 DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("preferred edit position is %1\n", position));
 	}
 
-	TrackViewList ts;
-	TrackViewList::iterator i;
-	size_t nth;
+	if (position == last_paste_pos) {
+		/* repeated paste in the same position */
+		++paste_count;
+	} else {
+		/* paste in new location, reset repeated paste state */
+		paste_count = 0;
+		last_paste_pos = position;
+	}
 
 	/* get everything in the correct order */
 
-	if (_edit_point == Editing::EditAtMouse && entered_track) {
-		/* With the mouse edit point, paste onto the track under the mouse */
-		ts.push_back (entered_track);
-	} else if (!selection->tracks.empty()) {
-		/* Otherwise, if there are some selected tracks, paste to them */
+	TrackViewList ts;
+	if (!selection->tracks.empty()) {
+		/* If there is a track selection, paste into exactly those tracks and
+		   only those tracks.  This allows the user to be explicit and override
+		   the below "do the reasonable thing" logic. */
 		ts = selection->tracks.filter_to_unique_playlists ();
 		sort_track_selection (ts);
-	} else if (_last_cut_copy_source_track) {
-		/* Otherwise paste to the track that the cut/copy came from;
-		   see discussion in mantis #3333.
-		*/
-		ts.push_back (_last_cut_copy_source_track);
+	} else {
+		/* Figure out which track to base the paste at. */
+		TimeAxisView* base_track = NULL;
+		if (_edit_point == Editing::EditAtMouse && entered_track) {
+			/* With the mouse edit point, paste onto the track under the mouse. */
+			base_track = entered_track;
+		} else if (_edit_point == Editing::EditAtMouse && entered_regionview) {
+			/* With the mouse edit point, paste onto the track of the region under the mouse. */
+			base_track = &entered_regionview->get_time_axis_view();
+		} else if (_last_cut_copy_source_track) {
+			/* Paste to the track that the cut/copy came from (see mantis #333). */
+			base_track = _last_cut_copy_source_track;
+		} else {
+			/* This is "impossible" since we've copied... well, do nothing. */
+			return;
+		}
+
+		/* Walk up to parent if necessary, so base track is a route. */
+		while (base_track->get_parent()) {
+			base_track = base_track->get_parent();
+		}
+
+		/* Add base track and all tracks below it.  The paste logic will select
+		   the appropriate object types from the cut buffer in relative order. */
+		for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
+			if ((*i)->order() >= base_track->order()) {
+				ts.push_back(*i);
+			}
+		}
+
+		/* Sort tracks so the nth track of type T will pick the nth object of type T. */
+		sort_track_selection (ts);
+
+		/* Add automation children of each track in order, for pasting several lines. */
+		for (TrackViewList::iterator i = ts.begin(); i != ts.end();) {
+			/* Add any automation children for pasting several lines */
+			RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*>(*i++);
+			if (!rtv) {
+				continue;
+			}
+
+			typedef RouteTimeAxisView::AutomationTracks ATracks;
+			const ATracks& atracks = rtv->automation_tracks();
+			for (ATracks::const_iterator a = atracks.begin(); a != atracks.end(); ++a) {
+				i = ts.insert(i, a->second.get());
+				++i;
+			}
+		}
+
+		/* We now have a list of trackviews starting at base_track, including
+		   automation children, in the order shown in the editor, e.g. R1,
+		   R1.A1, R1.A2, R2, R2.A1, ... */
 	}
 
-	if (internal_editing ()) {
+	if (ts.size() == 1 && cut_buffer->lines.size() == 1 &&
+	    dynamic_cast<AutomationTimeAxisView*>(ts.front())) {
+	    /* Only one line copied, and one automation track selected.  Do a
+	       "greedy" paste from one automation type to another. */
 
-		/* undo/redo is handled by individual tracks/regions */
+	    begin_reversible_command (Operations::paste);
 
-		for (nth = 0, i = ts.begin(); i != ts.end(); ++i, ++nth) {
+	    PasteContext ctx(paste_count, times, ItemCounts(), true);
+	    ts.front()->paste (position, *cut_buffer, ctx);
 
-			RegionSelection rs;
-			RegionSelection::iterator r;
-			MidiNoteSelection::iterator cb;
+	    commit_reversible_command ();
 
-			get_regions_at (rs, position, ts);
+	} else if (internal_editing ()) {
 
-			for (cb = cut_buffer->midi_notes.begin(), r = rs.begin();
-			     cb != cut_buffer->midi_notes.end() && r != rs.end(); ++r) {
-				MidiRegionView* mrv = dynamic_cast<MidiRegionView*> (*r);
-				if (mrv) {
-					mrv->paste (position, times, **cb);
-					++cb;
-				}
+		/* undo/redo is handled by individual tracks/regions */
+
+		RegionSelection rs;
+		get_regions_at (rs, position, ts);
+
+		PasteContext ctx(paste_count, times, ItemCounts(), false);
+		for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
+			MidiRegionView* mrv = dynamic_cast<MidiRegionView*> (*r);
+			if (mrv) {
+				mrv->paste (position, *cut_buffer, ctx);
 			}
 		}
 
@@ -4319,8 +4511,9 @@ Editor::paste_internal (framepos_t position, float times)
 
 		begin_reversible_command (Operations::paste);
 
-		for (nth = 0, i = ts.begin(); i != ts.end(); ++i, ++nth) {
-			(*i)->paste (position, times, *cut_buffer, nth);
+		PasteContext ctx(paste_count, times, ItemCounts(), false);
+		for (TrackViewList::iterator i = ts.begin(); i != ts.end(); ++i) {
+			(*i)->paste (position, *cut_buffer, ctx);
 		}
 
 		commit_reversible_command ();
@@ -4360,11 +4553,11 @@ Editor::duplicate_some_regions (RegionSelection& regions, float times)
 		foo.insert (foo.end(), latest_regionviews.begin(), latest_regionviews.end());
 	}
 
-	commit_reversible_command ();
-
 	if (!foo.empty()) {
 		selection->set (foo);
 	}
+
+	commit_reversible_command ();
 }
 
 void
@@ -4708,8 +4901,8 @@ Editor::apply_midi_note_edit_op_to_region (MidiOperator& op, MidiRegionView& mrv
 	vector<Evoral::Sequence<Evoral::MusicalTime>::Notes> v;
 	v.push_back (selected);
 
-	framepos_t pos_frames = mrv.midi_region()->position() - mrv.midi_region()->start();
-	double     pos_beats  = _session->tempo_map().framewalk_to_beats(0, pos_frames);
+	framepos_t          pos_frames = mrv.midi_region()->position() - mrv.midi_region()->start();
+	Evoral::MusicalTime pos_beats  = _session->tempo_map().framewalk_to_beats(0, pos_frames);
 
 	return op (mrv.midi_region()->model(), pos_beats, v);
 }
@@ -4768,12 +4961,17 @@ Editor::fork_region ()
 		MidiRegionView* const mrv = dynamic_cast<MidiRegionView*>(*r);
 
 		if (mrv) {
-			boost::shared_ptr<Playlist> playlist = mrv->region()->playlist();
-			boost::shared_ptr<MidiRegion> newregion = mrv->midi_region()->clone ();
-
-			playlist->clear_changes ();
-			playlist->replace_region (mrv->region(), newregion, mrv->region()->position());
-			_session->add_command(new StatefulDiffCommand (playlist));
+			try {
+				boost::shared_ptr<Playlist> playlist = mrv->region()->playlist();
+				boost::shared_ptr<MidiSource> new_source = _session->create_midi_source_by_stealing_name (mrv->midi_view()->track());
+				boost::shared_ptr<MidiRegion> newregion = mrv->midi_region()->clone (new_source);
+				
+				playlist->clear_changes ();
+				playlist->replace_region (mrv->region(), newregion, mrv->region()->position());
+				_session->add_command(new StatefulDiffCommand (playlist));
+			} catch (...) {
+				error << string_compose (_("Could not unlink %1"), mrv->region()->name()) << endmsg;
+			}
 		}
 
 		r = tmp;
@@ -4817,7 +5015,7 @@ Editor::quantize_region ()
 	qd->hide ();
 
 	if (r == Gtk::RESPONSE_OK) {
-		Quantize quant (*_session, qd->snap_start(), qd->snap_end(),
+		Quantize quant (qd->snap_start(), qd->snap_end(),
 				qd->start_grid_size(), qd->end_grid_size(),
 				qd->strength(), qd->swing(), qd->threshold());
 
@@ -4825,6 +5023,36 @@ Editor::quantize_region ()
 	}
 }
 
+void
+Editor::legatize_region (bool shrink_only)
+{
+	int selected_midi_region_cnt = 0;
+
+	if (!_session) {
+		return;
+	}
+
+	RegionSelection rs = get_regions_from_selection_and_entered ();
+
+	if (rs.empty()) {
+		return;
+	}
+
+	for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
+		MidiRegionView* const mrv = dynamic_cast<MidiRegionView*> (*r);
+		if (mrv) {
+			selected_midi_region_cnt++;
+		}
+	}
+
+	if (selected_midi_region_cnt == 0) {
+		return;
+	}
+
+	Legatize legatize(shrink_only);
+	apply_midi_note_edit_op (legatize);
+}
+
 void
 Editor::insert_patch_change (bool from_context)
 {
@@ -4842,7 +5070,7 @@ Editor::insert_patch_change (bool from_context)
 	*/
 	MidiRegionView* first = dynamic_cast<MidiRegionView*> (rs.front ());
 
-	Evoral::PatchChange<Evoral::MusicalTime> empty (0, 0, 0, 0);
+	Evoral::PatchChange<Evoral::MusicalTime> empty (Evoral::MusicalTime(), 0, 0, 0);
         PatchChangeDialog d (0, _session, empty, first->instrument_info(), Gtk::Stock::ADD);
 
 	if (d.run() == RESPONSE_CANCEL) {
@@ -4956,8 +5184,8 @@ Editor::reset_region_gain_envelopes ()
 		return;
 	}
 
-	_session->begin_reversible_command (_("reset region gain"));
-
+	begin_reversible_command (_("reset region gain"));
+	
 	for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
 		AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
 		if (arv) {
@@ -4968,8 +5196,8 @@ Editor::reset_region_gain_envelopes ()
 			_session->add_command (new MementoCommand<AutomationList>(*arv->audio_region()->envelope().get(), &before, &alist->get_state()));
 		}
 	}
-
-	_session->commit_reversible_command ();
+	
+	commit_reversible_command ();
 }
 
 void
@@ -5009,8 +5237,8 @@ Editor::toggle_gain_envelope_active ()
 		return;
 	}
 
-	_session->begin_reversible_command (_("region gain envelope active"));
-
+	begin_reversible_command (_("region gain envelope active"));
+	
 	for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
 		AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
 		if (arv) {
@@ -5019,8 +5247,8 @@ Editor::toggle_gain_envelope_active ()
 			_session->add_command (new StatefulDiffCommand (arv->region()));
 		}
 	}
-
-	_session->commit_reversible_command ();
+	
+	commit_reversible_command ();
 }
 
 void
@@ -5036,15 +5264,15 @@ Editor::toggle_region_lock ()
 		return;
 	}
 
-	_session->begin_reversible_command (_("toggle region lock"));
-
+	begin_reversible_command (_("toggle region lock"));
+	
 	for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
 		(*i)->region()->clear_changes ();
 		(*i)->region()->set_locked (!(*i)->region()->locked());
 		_session->add_command (new StatefulDiffCommand ((*i)->region()));
 	}
-
-	_session->commit_reversible_command ();
+	
+	commit_reversible_command ();
 }
 
 void
@@ -5060,15 +5288,15 @@ Editor::toggle_region_video_lock ()
 		return;
 	}
 
-	_session->begin_reversible_command (_("Toggle Video Lock"));
-
+	begin_reversible_command (_("Toggle Video Lock"));
+	
 	for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
 		(*i)->region()->clear_changes ();
 		(*i)->region()->set_video_locked (!(*i)->region()->video_locked());
 		_session->add_command (new StatefulDiffCommand ((*i)->region()));
 	}
-
-	_session->commit_reversible_command ();
+	
+	commit_reversible_command ();
 }
 
 void
@@ -5084,16 +5312,16 @@ Editor::toggle_region_lock_style ()
 		return;
 	}
 
-	_session->begin_reversible_command (_("region lock style"));
-
+	begin_reversible_command (_("region lock style"));
+	
 	for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
 		(*i)->region()->clear_changes ();
 		PositionLockStyle const ns = (*i)->region()->position_lock_style() == AudioTime ? MusicTime : AudioTime;
 		(*i)->region()->set_position_lock_style (ns);
 		_session->add_command (new StatefulDiffCommand ((*i)->region()));
 	}
-
-	_session->commit_reversible_command ();
+	
+	commit_reversible_command ();
 }
 
 void
@@ -5109,15 +5337,15 @@ Editor::toggle_opaque_region ()
 		return;
 	}
 
-	_session->begin_reversible_command (_("change region opacity"));
-
+	begin_reversible_command (_("change region opacity"));
+	
 	for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
 		(*i)->region()->clear_changes ();
 		(*i)->region()->set_opaque (!(*i)->region()->opaque());
 		_session->add_command (new StatefulDiffCommand ((*i)->region()));
 	}
-
-	_session->commit_reversible_command ();
+	
+	commit_reversible_command ();
 }
 
 void
@@ -5196,6 +5424,22 @@ Editor::toggle_solo_isolate ()
 {
 }
 
+
+void
+Editor::fade_range ()
+{
+	TrackViewList ts = selection->tracks.filter_to_unique_playlists ();
+
+	begin_reversible_command (_("fade range"));
+
+	for (TrackViewList::iterator i = ts.begin(); i != ts.end(); ++i) {
+		(*i)->fade_range (selection->time);
+	}
+
+	commit_reversible_command ();
+}
+
+
 void
 Editor::set_fade_length (bool in)
 {
@@ -5499,7 +5743,7 @@ Editor::set_playhead_cursor ()
 		}
 	}
 
-	if ( Config->get_always_play_range() )
+	if ( Config->get_follow_edits() )
 		cancel_time_selection();
 }
 
@@ -5557,7 +5801,7 @@ Editor::select_next_route()
 
 	selection->set(current);
 
-	ensure_track_visible(current);
+	ensure_time_axis_view_is_visible (*current, false);
 }
 
 void
@@ -5588,37 +5832,7 @@ Editor::select_prev_route()
 
 	selection->set (current);
 
-	ensure_track_visible(current);
-}
-
-void
-Editor::ensure_track_visible(TimeAxisView *track)
-{
-	if (track->hidden())
-		return;
-
-	double const current_view_min_y = vertical_adjustment.get_value();
-	double const current_view_max_y = vertical_adjustment.get_value() + vertical_adjustment.get_page_size();
-
-	double const track_min_y = track->y_position ();
-	double const track_max_y = track->y_position () + track->effective_height ();
-
-	if (track_min_y >= current_view_min_y &&
-	    track_max_y <= current_view_max_y) {
-		return;
-	}
-
-	double new_value;
-
-	if (track_min_y < current_view_min_y) {
-		// Track is above the current view
-		new_value = track_min_y;
-	} else {
-		// Track is below the current view
-		new_value = track->y_position () + track->effective_height() - vertical_adjustment.get_page_size();
-	}
-
-	vertical_adjustment.set_value(new_value);
+	ensure_time_axis_view_is_visible (*current, false);
 }
 
 void
@@ -5634,8 +5848,8 @@ Editor::set_loop_from_selection (bool play)
 	set_loop_range (start, end,  _("set loop range from selection"));
 
 	if (play) {
-		_session->request_play_loop (true);
 		_session->request_locate (start, true);
+		_session->request_play_loop (true);
 	}
 }
 
@@ -5656,8 +5870,8 @@ Editor::set_loop_from_edit_range (bool play)
 	set_loop_range (start, end,  _("set loop range from edit range"));
 
 	if (play) {
-		_session->request_play_loop (true);
 		_session->request_locate (start, true);
+		_session->request_play_loop (true);
 	}
 }
 
@@ -5685,8 +5899,8 @@ Editor::set_loop_from_region (bool play)
 	set_loop_range (start, end, _("set loop range from region"));
 
 	if (play) {
-		_session->request_play_loop (true);
 		_session->request_locate (start, true);
+		_session->request_play_loop (true);
 	}
 }
 
@@ -5703,6 +5917,34 @@ Editor::set_punch_from_selection ()
 	set_punch_range (start, end,  _("set punch range from selection"));
 }
 
+void
+Editor::set_session_extents_from_selection ()
+{
+	if (_session == 0 || selection->time.empty()) {
+		return;
+	}
+
+	begin_reversible_command (_("set session start/stop from selection"));
+
+	framepos_t start = selection->time[clicked_selection].start;
+	framepos_t end = selection->time[clicked_selection].end;
+
+	Location* loc;
+	if ((loc = _session->locations()->session_range_location()) == 0) {
+		_session->set_session_extents ( start, end );  // this will create a new session range;  no need for UNDO
+	} else {
+		XMLNode &before = loc->get_state();
+
+		_session->set_session_extents ( start, end );
+
+		XMLNode &after = loc->get_state();
+
+		_session->add_command (new MementoCommand<Location>(*loc, &before, &after));
+
+		commit_reversible_command ();
+	}
+}
+
 void
 Editor::set_punch_from_edit_range ()
 {
@@ -5911,8 +6153,8 @@ Editor::split_region_at_transients ()
 		return;
 	}
 
-	_session->begin_reversible_command (_("split regions"));
-
+	begin_reversible_command (_("split regions"));
+	
 	for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ) {
 
 		RegionSelection::iterator tmp;
@@ -5929,8 +6171,8 @@ Editor::split_region_at_transients ()
 
 		i = tmp;
 	}
-
-	_session->commit_reversible_command ();
+	
+	commit_reversible_command ();
 
 }
 
@@ -6118,14 +6360,14 @@ Editor::place_transient()
 
 	framepos_t where = get_preferred_edit_position();
 
-	_session->begin_reversible_command (_("place transient"));
-
+	begin_reversible_command (_("place transient"));
+	
 	for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
 		framepos_t position = (*r)->region()->position();
 		(*r)->region()->add_transient(where - position);
 	}
-
-	_session->commit_reversible_command ();
+	
+	commit_reversible_command ();
 }
 
 void
@@ -6153,8 +6395,8 @@ Editor::snap_regions_to_grid ()
 		return;
 	}
 
-	_session->begin_reversible_command (_("snap regions to grid"));
-
+	begin_reversible_command (_("snap regions to grid"));
+	
 	for (RegionSelection::iterator r = rs.begin(); r != rs.end(); ++r) {
 
 		boost::shared_ptr<Playlist> pl = (*r)->region()->playlist();
@@ -6177,8 +6419,8 @@ Editor::snap_regions_to_grid ()
 		(*i)->thaw();
 		used_playlists.pop_front();
 	}
-
-	_session->commit_reversible_command ();
+	
+	commit_reversible_command ();
 }
 
 void
@@ -6236,8 +6478,8 @@ Editor::close_region_gaps ()
 
 	/* Iterate over the region list and make adjacent regions overlap by crossfade_len_ms */
 
-	_session->begin_reversible_command (_("close region gaps"));
-
+	begin_reversible_command (_("close region gaps"));
+	
 	int idx = 0;
 	boost::shared_ptr<Region> last_region;
 
@@ -6276,8 +6518,8 @@ Editor::close_region_gaps ()
 		(*i)->thaw();
 		used_playlists.pop_front();
 	}
-
-	_session->commit_reversible_command ();
+	
+	commit_reversible_command ();
 }
 
 void
@@ -6370,7 +6612,7 @@ Editor::playhead_forward_to_grid ()
 	framepos_t pos = playhead_cursor->current_frame ();
 	if (pos < max_framepos - 1) {
 		pos += 2;
-		snap_to_internal (pos, 1, false);
+		snap_to_internal (pos, RoundUpAlways, false);
 		_session->request_locate (pos);
 	}
 }
@@ -6386,7 +6628,7 @@ Editor::playhead_backward_to_grid ()
 	framepos_t pos = playhead_cursor->current_frame ();
 	if (pos > 2) {
 		pos -= 2;
-		snap_to_internal (pos, -1, false);
+		snap_to_internal (pos, RoundDownAlways, false);
 		_session->request_locate (pos);
 	}
 }
@@ -6445,12 +6687,13 @@ Editor::remove_tracks ()
 
 	for (TrackSelection::iterator x = ts.begin(); x != ts.end(); ++x) {
 		RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*x);
-		if (rtv) {
-			if (rtv->is_track()) {
-				ntracks++;
-			} else {
-				nbusses++;
-			}
+		if (!rtv) {
+			continue;
+		}
+		if (rtv->is_track()) {
+			ntracks++;
+		} else {
+			nbusses++;
 		}
 		routes.push_back (rtv->_route);
 
@@ -6481,6 +6724,7 @@ edit your ardour.rc file to set the\n\
 		return;
 	}
 
+	// XXX should be using gettext plural forms, maybe?
 	if (ntracks > 1) {
 		trackstr = _("tracks");
 	} else {
@@ -6507,7 +6751,7 @@ edit your ardour.rc file to set the\n\
 		}
 	} else if (nbusses) {
 		prompt  = string_compose (_("Do you really want to remove %1 %2?\n\n"
-		                            "This action cannot be undon, and the session file will be overwritten"),
+		                            "This action cannot be undone, and the session file will be overwritten"),
 					  nbusses, busstr);
 	}
 
@@ -6531,8 +6775,12 @@ edit your ardour.rc file to set the\n\
 		return;
 	}
 
-	for (vector<boost::shared_ptr<Route> >::iterator x = routes.begin(); x != routes.end(); ++x) {
-		_session->remove_route (*x);
+	{
+		Session::StateProtector sp (_session);
+		DisplaySuspender ds;
+		for (vector<boost::shared_ptr<Route> >::iterator x = routes.begin(); x != routes.end(); ++x) {
+			_session->remove_route (*x);
+		}
 	}
 }
 
@@ -6712,6 +6960,7 @@ Editor::fit_selected_tracks ()
                         }
                 }
         }
+
 }
 
 void
@@ -6734,7 +6983,13 @@ Editor::fit_tracks (TrackViewList & tracks)
 		++visible_tracks;
 	}
 
-	uint32_t h = (uint32_t) floor ((_visible_canvas_height - child_heights) / visible_tracks);
+	/* compute the per-track height from:
+
+	   total canvas visible height - 
+                 height that will be taken by visible children of selected
+                 tracks - height of the ruler/hscroll area 
+	*/
+	uint32_t h = (uint32_t) floor ((trackviews_height() - child_heights) / visible_tracks);
 	double first_y_pos = DBL_MAX;
 
 	if (h < TimeAxisView::preset_height (HeightSmall)) {
@@ -6757,8 +7012,6 @@ Editor::fit_tracks (TrackViewList & tracks)
 		}
 	}
 
-	/* operate on all tracks, hide unselected ones that are in the middle of selected ones */
-
 	bool prev_was_selected = false;
 	bool is_selected = tracks.contains (all.front());
 	bool next_is_selected;
@@ -6800,6 +7053,8 @@ Editor::fit_tracks (TrackViewList & tracks)
 	vertical_adjustment.set_value (first_y_pos);
 
 	redo_visual_stack.push_back (current_visual_state (true));
+
+	visible_tracks_selector.set_text (_("Sel"));
 }
 
 void
@@ -6872,7 +7127,7 @@ Editor::toggle_region_mute ()
 
 		(*i)->region()->playlist()->clear_changes ();
 		(*i)->region()->set_muted (!(*i)->region()->muted ());
-		_session->add_command (new StatefulDiffCommand ((*i)->region()->playlist()));
+		_session->add_command (new StatefulDiffCommand ((*i)->region()));
 
 	}
 
@@ -6972,3 +7227,83 @@ Editor::toggle_midi_input_active (bool flip_others)
 	
 	_session->set_exclusive_input_active (rl, onoff, flip_others);
 }
+
+void
+Editor::lock ()
+{
+	if (!lock_dialog) {
+		lock_dialog = new Gtk::Dialog (string_compose (_("%1: Locked"), PROGRAM_NAME), true);
+
+		Gtk::Image* padlock = manage (new Gtk::Image (ARDOUR_UI_UTILS::get_icon ("padlock_closed")));
+		lock_dialog->get_vbox()->pack_start (*padlock);
+
+		ArdourButton* b = manage (new ArdourButton);
+		b->set_name ("lock button");
+		b->set_text (_("Click to unlock"));
+		b->signal_clicked.connect (sigc::mem_fun (*this, &Editor::unlock));
+		lock_dialog->get_vbox()->pack_start (*b);
+		
+		lock_dialog->get_vbox()->show_all ();
+		lock_dialog->set_size_request (200, 200);
+	}
+	
+#ifdef __APPLE__
+	/* The global menu bar continues to be accessible to applications
+	   with modal dialogs, which means that we need to desensitize
+	   all items in the menu bar. Since those items are really just
+	   proxies for actions, that means disabling all actions.
+	*/
+	ActionManager::disable_all_actions ();
+#endif
+	lock_dialog->present ();
+}
+
+void
+Editor::unlock ()
+{
+	lock_dialog->hide ();
+	
+#ifdef __APPLE__
+	ActionManager::pop_action_state ();
+#endif	
+
+	if (ARDOUR_UI::config()->get_lock_gui_after_seconds()) {
+		start_lock_event_timing ();
+	}
+}
+
+void
+Editor::bring_in_callback (Gtk::Label* label, uint32_t n, uint32_t total, string name)
+{
+	Gtkmm2ext::UI::instance()->call_slot (invalidator (*this), boost::bind (&Editor::update_bring_in_message, this, label, n, total, name));
+}
+
+void
+Editor::update_bring_in_message (Gtk::Label* label, uint32_t n, uint32_t total, string name)
+{
+	label->set_text (string_compose ("Copying %1, %2 of %3", name, n, total));
+	Gtkmm2ext::UI::instance()->flush_pending ();
+}
+
+void
+Editor::bring_all_sources_into_session ()
+{
+	if (!_session) {
+		return;
+	}
+
+	Gtk::Label msg;
+	ArdourDialog w (_("Moving embedded files into session folder"));
+	w.get_vbox()->pack_start (msg);
+	w.present ();
+	
+	/* flush all pending GUI events because we're about to start copying
+	 * files
+	 */
+	
+	Gtkmm2ext::UI::instance()->flush_pending ();
+
+	cerr << " Do it\n";
+
+	_session->bring_all_sources_into_session (boost::bind (&Editor::bring_in_callback, this, &msg, _1, _2, _3));
+}