X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Feditor_ops.cc;h=b70d0f06647ec4088b86be5c501061515b7091ad;hb=5dca8270eb589cc60c756e09bd02ce323805b741;hp=2427f53962a0654a6e44dbf4b8266ab7e9ce5544;hpb=ed76a3554c9291ff6dafe0e3334da1aea916f3c8;p=ardour.git

diff --git a/gtk2_ardour/editor_ops.cc b/gtk2_ardour/editor_ops.cc
index 2427f53962..b70d0f0664 100644
--- a/gtk2_ardour/editor_ops.cc
+++ b/gtk2_ardour/editor_ops.cc
@@ -31,6 +31,7 @@
 #include "pbd/basename.h"
 #include "pbd/pthread_utils.h"
 #include "pbd/memento_command.h"
+#include "pbd/unwind.h"
 #include "pbd/whitespace.h"
 #include "pbd/stateful_diff_command.h"
 
@@ -38,24 +39,21 @@
 #include <gtkmm2ext/choice.h>
 #include <gtkmm2ext/popup.h>
 
-#include "ardour/audioengine.h"
-#include "ardour/session.h"
-#include "ardour/audioplaylist.h"
+#include "ardour/audio_track.h"
 #include "ardour/audioregion.h"
-#include "ardour/audio_diskstream.h"
-#include "ardour/utils.h"
+#include "ardour/dB.h"
 #include "ardour/location.h"
-#include "ardour/audio_track.h"
-#include "ardour/audioplaylist.h"
-#include "ardour/region_factory.h"
+#include "ardour/midi_region.h"
+#include "ardour/midi_track.h"
+#include "ardour/operations.h"
 #include "ardour/playlist_factory.h"
-#include "ardour/reverse.h"
-#include "ardour/transient_detector.h"
-#include "ardour/dB.h"
 #include "ardour/quantize.h"
+#include "ardour/region_factory.h"
+#include "ardour/reverse.h"
+#include "ardour/session.h"
+#include "ardour/session_playlists.h"
 #include "ardour/strip_silence.h"
-#include "ardour/route_group.h"
-#include "ardour/operations.h"
+#include "ardour/transient_detector.h"
 
 #include "ardour_ui.h"
 #include "debug.h"
@@ -64,6 +62,7 @@
 #include "route_time_axis.h"
 #include "audio_time_axis.h"
 #include "automation_time_axis.h"
+#include "control_point.h"
 #include "streamview.h"
 #include "audio_streamview.h"
 #include "audio_region_view.h"
@@ -106,6 +105,10 @@ using Gtkmm2ext::Keyboard;
 void
 Editor::undo (uint32_t n)
 {
+	if (_drags->active ()) {
+		_drags->abort ();
+	}
+	
 	if (_session) {
 		_session->undo (n);
 	}
@@ -114,6 +117,10 @@ Editor::undo (uint32_t n)
 void
 Editor::redo (uint32_t n)
 {
+	if (_drags->active ()) {
+		_drags->abort ();
+	}
+	
 	if (_session) {
 		_session->redo (n);
 	}
@@ -482,7 +489,7 @@ Editor::nudge_backward_capture_offset ()
 		return;
 	}
 
-	begin_reversible_command (_("nudge forward"));
+	begin_reversible_command (_("nudge backward"));
 
 	framepos_t const distance = _session->worst_output_latency();
 
@@ -554,11 +561,11 @@ Editor::build_region_boundary_cache ()
 
 	TimeAxisView *ontrack = 0;
 	TrackViewList tlist;
-
+	
 	if (!selection->tracks.empty()) {
-		tlist = selection->tracks;
+		tlist = selection->tracks.filter_to_unique_playlists ();
 	} else {
-		tlist = track_views;
+		tlist = track_views.filter_to_unique_playlists ();
 	}
 
 	while (pos < _session->current_end_frame() && !at_end) {
@@ -1271,11 +1278,17 @@ Editor::scroll_tracks_up_line ()
 void
 Editor::tav_zoom_step (bool coarser)
 {
-	ENSURE_GUI_THREAD (*this, &Editor::temporal_zoom_step, coarser)
-
 	_routes->suspend_redisplay ();
 
-	for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
+	TrackViewList* ts;
+
+	if (selection->tracks.empty()) {
+		ts = &track_views;
+	} else {
+		ts = &selection->tracks;
+	}
+	
+	for (TrackViewList::iterator i = ts->begin(); i != ts->end(); ++i) {
 		TimeAxisView *tv = (static_cast<TimeAxisView*>(*i));
 			tv->step_height (coarser);
 	}
@@ -1283,28 +1296,78 @@ Editor::tav_zoom_step (bool coarser)
 	_routes->resume_redisplay ();
 }
 
+void
+Editor::tav_zoom_smooth (bool coarser, bool force_all)
+{
+	_routes->suspend_redisplay ();
+
+	TrackViewList* ts;
+
+	if (selection->tracks.empty() || force_all) {
+		ts = &track_views;
+	} else {
+		ts = &selection->tracks;
+	}
+	
+	for (TrackViewList::iterator i = ts->begin(); i != ts->end(); ++i) {
+		TimeAxisView *tv = (static_cast<TimeAxisView*>(*i));
+		uint32_t h = tv->current_height ();
+
+		if (coarser) {
+			if (h > 5) {
+				h -= 5; // pixels
+				if (h >= TimeAxisView::preset_height (HeightSmall)) {
+					tv->set_height (h);
+				}
+			}
+		} else {
+			tv->set_height (h + 5);
+		}
+	}
+
+	_routes->resume_redisplay ();
+}
+
+bool
+Editor::clamp_frames_per_unit (double& fpu) const
+{
+	bool clamped = false;
+	
+	if (fpu < 2.0) {
+		fpu = 2.0;
+		clamped = true;
+	}
+
+	if (max_framepos / fpu < 800) {
+		fpu = max_framepos / 800.0;
+		clamped = true;
+	}
+
+	return clamped;
+}
+
 void
 Editor::temporal_zoom_step (bool coarser)
 {
 	ENSURE_GUI_THREAD (*this, &Editor::temporal_zoom_step, coarser)
 
-	double nfpu;
-
-	nfpu = frames_per_unit;
+	double nfpu = frames_per_unit;
 
 	if (coarser) {
-		nfpu *= 1.61803399;
+		nfpu = min (9e6, nfpu * 1.61803399);
 	} else {
-		nfpu = max(1.0,(nfpu/1.61803399));
+		nfpu = max (1.0, nfpu / 1.61803399);
 	}
 
 	temporal_zoom (nfpu);
 }
 
 void
-Editor::temporal_zoom (gdouble fpu)
+Editor::temporal_zoom (double fpu)
 {
-	if (!_session) return;
+	if (!_session) {
+		return;
+	}
 
 	framepos_t current_page = current_page_frames();
 	framepos_t current_leftmost = leftmost_frame;
@@ -1318,13 +1381,19 @@ Editor::temporal_zoom (gdouble fpu)
 	double nfpu;
 	double l;
 
-	/* XXX this limit is also in ::set_frames_per_unit() */
-
-	if (frames_per_unit <= 1.0 && fpu <= frames_per_unit) {
+	clamp_frames_per_unit (fpu);
+	if (fpu == frames_per_unit) {
 		return;
 	}
 
 	nfpu = fpu;
+	
+	// Imposing an arbitrary limit to zoom out as too much zoom out produces 
+	// segfaults for lack of memory. If somebody decides this is not high enough I
+	// believe it can be raisen to higher values but some limit must be in place.
+	if (nfpu > 8e+08) {
+		nfpu = 8e+08;
+	}
 
 	new_page_size = (framepos_t) floor (_canvas_width * nfpu);
 	half_page_size = new_page_size / 2;
@@ -1479,16 +1548,15 @@ Editor::temporal_zoom_region (bool both_axes)
 		end = max_framepos;
 	}
 
-	if (both_axes) {
-		/* save visual state with track states included, and prevent
-		   set_frames_per_unit() from doing it again.
-		*/
-		undo_visual_stack.push_back (current_visual_state(true));
-		no_save_visual = true;
-	}
+	/* if we're zooming on both axes we need to save track heights etc.
+	 */
+
+	undo_visual_stack.push_back (current_visual_state (both_axes));
 
-	temporal_zoom_by_frame (start, end, "zoom to region");
+	PBD::Unwinder<bool> nsv (no_save_visual, true);
 
+	temporal_zoom_by_frame (start, end);
+	
 	if (both_axes) {
 		uint32_t per_track_height = (uint32_t) floor ((_canvas_height - canvas_timebars_vsize - 10.0) / tracks.size());
 
@@ -1511,10 +1579,9 @@ Editor::temporal_zoom_region (bool both_axes)
 		_routes->resume_redisplay ();
 
 		vertical_adjustment.set_value (0.0);
-		no_save_visual = false;
 	}
 
-	redo_visual_stack.push_back (current_visual_state());
+	redo_visual_stack.push_back (current_visual_state (both_axes));
 }
 
 void
@@ -1535,7 +1602,7 @@ Editor::temporal_zoom_selection ()
 	framepos_t start = selection->time[clicked_selection].start;
 	framepos_t end = selection->time[clicked_selection].end;
 
-	temporal_zoom_by_frame (start, end, "zoom to selection");
+	temporal_zoom_by_frame (start, end);
 }
 
 void
@@ -1550,12 +1617,12 @@ Editor::temporal_zoom_session ()
 			s = 0;
 		}
 		framecnt_t const e = _session->current_end_frame() + l * 0.01;
-		temporal_zoom_by_frame (framecnt_t (s), e, "zoom to _session");
+		temporal_zoom_by_frame (framecnt_t (s), e);
 	}
 }
 
 void
-Editor::temporal_zoom_by_frame (framepos_t start, framepos_t end, const string & /*op*/)
+Editor::temporal_zoom_by_frame (framepos_t start, framepos_t end)
 {
 	if (!_session) return;
 
@@ -1575,6 +1642,10 @@ Editor::temporal_zoom_by_frame (framepos_t start, framepos_t end, const string &
 		new_leftmost = 0;
 	}
 
+	if (new_leftmost < 0) {
+		new_leftmost = 0;
+	}
+
 	reposition_and_zoom (new_leftmost, new_fpu);
 }
 
@@ -1776,13 +1847,13 @@ Editor::jump_forward_to_mark ()
 		return;
 	}
 
-	Location *location = _session->locations()->first_location_after (playhead_cursor->current_frame);
+	framepos_t pos = _session->locations()->first_mark_after (playhead_cursor->current_frame);
 
-	if (location) {
-		_session->request_locate (location->start(), _session->transport_rolling());
-	} else {
-		_session->request_locate (_session->current_end_frame());
+	if (pos < 0) {
+		return;
 	}
+	
+	_session->request_locate (pos, _session->transport_rolling());
 }
 
 void
@@ -1792,13 +1863,13 @@ Editor::jump_backward_to_mark ()
 		return;
 	}
 
-	Location *location = _session->locations()->first_location_before (playhead_cursor->current_frame);
+	framepos_t pos = _session->locations()->first_mark_before (playhead_cursor->current_frame);
 
-	if (location) {
-		_session->request_locate (location->start(), _session->transport_rolling());
-	} else {
-		_session->goto_start ();
+	if (pos < 0) {
+		return;
 	}
+
+	_session->request_locate (pos, _session->transport_rolling());
 }
 
 void
@@ -1838,11 +1909,13 @@ Editor::clear_ranges ()
 
 		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));
@@ -1936,7 +2009,6 @@ Editor::insert_route_list_drag (boost::shared_ptr<Route> route, int x, int y)
 {
 	double wx, wy;
 	double cx, cy;
-	framepos_t where;
 	RouteTimeAxisView *dest_rtv = 0;
 	RouteTimeAxisView *source_rtv = 0;
 
@@ -1949,7 +2021,7 @@ Editor::insert_route_list_drag (boost::shared_ptr<Route> route, int x, int y)
 	event.button.x = wx;
 	event.button.y = wy;
 
-	where = event_frame (&event, &cx, &cy);
+	event_frame (&event, &cx, &cy);
 
 	std::pair<TimeAxisView*, int> const tv = trackview_by_y_position (cy);
 	if (tv.first == 0) {
@@ -2035,7 +2107,7 @@ Editor::transition_to_rolling (bool fwd)
 	}
 
 	if (_session->config.get_external_sync()) {
-		switch (_session->config.get_sync_source()) {
+		switch (Config->get_sync_source()) {
 		case JACK:
 			break;
 		default:
@@ -2098,6 +2170,55 @@ Editor::play_selection ()
 	_session->request_play_range (&selection->time, true);
 }
 
+framepos_t
+Editor::get_preroll ()
+{
+	return 1.0 /*Config->get_edit_preroll_seconds()*/ * _session->frame_rate();
+}
+
+
+void
+Editor::maybe_locate_with_edit_preroll ( framepos_t location )
+{
+	if ( _session->transport_rolling() || !Config->get_always_play_range() )
+		return;
+
+	location -= get_preroll();
+	
+	//don't try to locate before the beginning of time
+	if ( location < 0 ) 
+		location = 0;
+		
+	//if follow_playhead is on, keep the playhead on the screen
+	if ( _follow_playhead )
+		if ( location < leftmost_frame ) 
+			location = leftmost_frame;
+
+	_session->request_locate( location );
+}
+
+void
+Editor::play_with_preroll ()
+{
+	if (selection->time.empty()) {
+		return;
+	} else {
+		framepos_t preroll = get_preroll();
+		
+		framepos_t start = 0;
+		if (selection->time[clicked_selection].start > preroll)
+			start = selection->time[clicked_selection].start - preroll;
+		
+		framepos_t end = selection->time[clicked_selection].end + preroll;
+		
+		AudioRange ar (start, end, 0);
+		list<AudioRange> lar;
+		lar.push_back (ar);
+
+		_session->request_play_range (&lar, true);
+	}
+}
+
 void
 Editor::play_location (Location& location)
 {
@@ -2126,28 +2247,101 @@ Editor::loop_location (Location& location)
 	}
 }
 
+void
+Editor::do_layer_operation (LayerOperation op)
+{
+	if (selection->regions.empty ()) {
+		return;
+	}
+
+	bool const multiple = selection->regions.size() > 1;
+	switch (op) {
+	case Raise:
+		if (multiple) {
+			begin_reversible_command (_("raise regions"));
+		} else {
+			begin_reversible_command (_("raise region"));
+		}
+		break;
+
+	case RaiseToTop:
+		if (multiple) {
+			begin_reversible_command (_("raise regions to top"));
+		} else {
+			begin_reversible_command (_("raise region to top"));
+		}
+		break;
+		
+	case Lower:
+		if (multiple) {
+			begin_reversible_command (_("lower regions"));
+		} else {
+			begin_reversible_command (_("lower region"));
+		}
+		break;
+		
+	case LowerToBottom:
+		if (multiple) {
+			begin_reversible_command (_("lower regions to bottom"));
+		} else {
+			begin_reversible_command (_("lower region"));
+		}
+		break;
+	}
+
+	set<boost::shared_ptr<Playlist> > playlists = selection->regions.playlists ();
+	for (set<boost::shared_ptr<Playlist> >::iterator i = playlists.begin(); i != playlists.end(); ++i) {
+		(*i)->clear_owned_changes ();
+	}
+	
+	for (RegionSelection::iterator i = selection->regions.begin(); i != selection->regions.end(); ++i) {
+		boost::shared_ptr<Region> r = (*i)->region ();
+		switch (op) {
+		case Raise:
+			r->raise ();
+			break;
+		case RaiseToTop:
+			r->raise_to_top ();
+			break;
+		case Lower:
+			r->lower ();
+			break;
+		case LowerToBottom:
+			r->lower_to_bottom ();
+		}
+	}
+
+	for (set<boost::shared_ptr<Playlist> >::iterator i = playlists.begin(); i != playlists.end(); ++i) {
+		vector<Command*> cmds;
+		(*i)->rdiff (cmds);
+		_session->add_commands (cmds);
+	}
+	
+	commit_reversible_command ();
+}
+
 void
 Editor::raise_region ()
 {
-	selection->foreach_region (&Region::raise);
+	do_layer_operation (Raise);
 }
 
 void
 Editor::raise_region_to_top ()
 {
-	selection->foreach_region (&Region::raise_to_top);
+	do_layer_operation (RaiseToTop);
 }
 
 void
 Editor::lower_region ()
 {
-	selection->foreach_region (&Region::lower);
+	do_layer_operation (Lower);
 }
 
 void
 Editor::lower_region_to_bottom ()
 {
-	selection->foreach_region (&Region::lower_to_bottom);
+	do_layer_operation (LowerToBottom);
 }
 
 /** Show the region editor for the selected regions */
@@ -2189,9 +2383,8 @@ Editor::rename_region ()
 	d.add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);
 
 	d.set_size_request (300, -1);
-	d.set_position (Gtk::WIN_POS_MOUSE);
 
-	entry.set_text (selection->regions.front()->region()->name());
+	entry.set_text (rs.front()->region()->name());
 	entry.select_region (0, -1);
 
 	entry.signal_activate().connect (sigc::bind (sigc::mem_fun (d, &Dialog::response), RESPONSE_OK));
@@ -2332,9 +2525,10 @@ Editor::create_region_from_selection (vector<boost::shared_ptr<Region> >& new_re
 	framepos_t start = selection->time[clicked_selection].start;
 	framepos_t end = selection->time[clicked_selection].end;
 
-	sort_track_selection ();
+	TrackViewList ts = selection->tracks.filter_to_unique_playlists ();
+	sort_track_selection (ts);
 
-	for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
+	for (TrackSelection::iterator i = ts.begin(); i != ts.end(); ++i) {
 		boost::shared_ptr<Region> current;
 		boost::shared_ptr<Playlist> playlist;
 		framepos_t internal_start;
@@ -2388,7 +2582,7 @@ static void
 add_if_covered (RegionView* rv, const AudioRange* ar, RegionSelection* rs)
 {
 	switch (rv->region()->coverage (ar->start, ar->end - 1)) {
-	case OverlapNone:
+	case Evoral::OverlapNone:
 		break;
 	default:
 		rs->push_back (rv);
@@ -2430,7 +2624,7 @@ Editor::get_tracks_for_range_action () const
 		t = selection->tracks;
 	}
 
-	return t;
+	return t.filter_to_unique_playlists();
 }
 
 void
@@ -2441,7 +2635,7 @@ Editor::separate_regions_between (const TimeSelection& ts)
 	RegionSelection new_selection;
 
 	TrackViewList tmptracks = get_tracks_for_range_action ();
-	sort_track_selection (&tmptracks);
+	sort_track_selection (tmptracks);
 
 	for (TrackSelection::iterator i = tmptracks.begin(); i != tmptracks.end(); ++i) {
 
@@ -2531,7 +2725,7 @@ Editor::separate_region_from_selection ()
 	   returns a single range.
 	*/
 
-	if (mouse_mode == MouseRange && !selection->time.empty()) {
+	if (!selection->time.empty()) {
 
 		separate_regions_between (selection->time);
 
@@ -2684,16 +2878,17 @@ Editor::crop_region_to (framepos_t start, framepos_t end)
 {
 	vector<boost::shared_ptr<Playlist> > playlists;
 	boost::shared_ptr<Playlist> playlist;
-	TrackViewList* ts;
+	TrackViewList ts;
 
 	if (selection->tracks.empty()) {
-		ts = &track_views;
+		ts = track_views.filter_to_unique_playlists();
 	} else {
-		sort_track_selection ();
-		ts = &selection->tracks;
+		ts = selection->tracks.filter_to_unique_playlists ();
 	}
 
-	for (TrackSelection::iterator i = ts->begin(); i != ts->end(); ++i) {
+	sort_track_selection (ts);
+
+	for (TrackSelection::iterator i = ts.begin(); i != ts.end(); ++i) {
 
 		RouteTimeAxisView* rtv;
 
@@ -2818,7 +3013,9 @@ Editor::region_fill_selection ()
 
 	begin_reversible_command (Operations::fill_selection);
 
-	for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
+	TrackViewList ts = selection->tracks.filter_to_unique_playlists ();
+
+	for (TrackViewList::iterator i = ts.begin(); i != ts.end(); ++i) {
 
 		if ((playlist = (*i)->playlist()) == 0) {
 			continue;
@@ -3076,15 +3273,10 @@ Editor::trim_region (bool front)
 	framepos_t where = get_preferred_edit_position();
 	RegionSelection rs = get_regions_from_selection_and_edit_point ();
 
-	cerr << "trim regions\n";
-
 	if (rs.empty()) {
-		cerr << " no regions\n";
 		return;
 	}
 
-	cerr << "where = " << where << endl;
-
 	begin_reversible_command (front ? _("trim front") : _("trim back"));
 
 	for (list<RegionView*>::const_iterator i = rs.by_layer().begin(); i != rs.by_layer().end(); ++i) {
@@ -3094,8 +3286,10 @@ Editor::trim_region (bool front)
 
 			if (front) {
 				(*i)->region()->trim_front (where);
+				maybe_locate_with_edit_preroll ( where );
 			} else {
 				(*i)->region()->trim_end (where);
+				maybe_locate_with_edit_preroll ( where );
 			}
 
 			_session->add_command (new StatefulDiffCommand ((*i)->region()));
@@ -3138,7 +3332,7 @@ Editor::trim_region_to_location (const Location& loc, const char* str)
 
 		/* require region to span proposed trim */
 		switch (rv->region()->coverage (loc.start(), loc.end())) {
-		case OverlapInternal:
+		case Evoral::OverlapInternal:
 			break;
 		default:
 			continue;
@@ -3258,36 +3452,67 @@ Editor::unfreeze_route ()
 void*
 Editor::_freeze_thread (void* arg)
 {
-	SessionEvent::create_per_thread_pool ("freeze events", 64);
-
 	return static_cast<Editor*>(arg)->freeze_thread ();
 }
 
 void*
 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;
 }
 
 void
 Editor::freeze_route ()
 {
+	if (!_session) {
+		return;
+	}
+
+	/* stop transport before we start. this is important */
+
+	_session->request_transport_speed (0.0);
+	
+	/* wait for just a little while, because the above call is asynchronous */
+
+	::usleep (250000);
+
 	if (clicked_routeview == 0 || !clicked_routeview->is_audio_track()) {
 		return;
 	}
 
-	if (!clicked_routeview->track()->bounceable()) {
-		RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (clicked_routeview);
-		if (rtv && !rtv->track()->bounceable()) {
-			MessageDialog d (
-				_("This route cannot be frozen because it has more outputs than inputs.  "
-				  "You can fix this by increasing the number of inputs.")
-				);
-			d.set_title (_("Cannot freeze"));
-			d.run ();
+	if (!clicked_routeview->track()->bounceable (clicked_routeview->track()->main_outs(), true)) {
+		MessageDialog d (
+			_("This track/bus cannot be frozen because the signal adds or loses channels before reaching the outputs.\n"
+			  "This is typically caused by plugins that generate stereo output from mono input or vice versa.")
+			);
+		d.set_title (_("Cannot freeze"));
+		d.run ();
+		return;
+	}
+
+	if (clicked_routeview->track()->has_external_redirects()) {
+		MessageDialog d (string_compose (_("<b>%1</b>\n\nThis track has at least one send/insert/return as part of its signal flow.\n\n"
+						   "Freezing will only process the signal as far as the first send/insert/return."),
+						 clicked_routeview->track()->name()), true, MESSAGE_INFO, BUTTONS_NONE, true);
+
+		d.add_button (_("Freeze anyway"), Gtk::RESPONSE_OK);
+		d.add_button (_("Don't freeze"), Gtk::RESPONSE_CANCEL);
+		d.set_title (_("Freeze Limits"));
+
+		int response = d.run ();
+
+		switch (response) {
+		case Gtk::RESPONSE_CANCEL:
 			return;
+		default:
+			break;
 		}
 	}
 
@@ -3318,16 +3543,21 @@ Editor::bounce_range_selection (bool replace, bool enable_processing)
 	TrackSelection views = selection->tracks;
 
 	for (TrackViewList::iterator i = views.begin(); i != views.end(); ++i) {
-		RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
-		if (rtv && rtv->track() && replace && enable_processing && !rtv->track()->bounceable()) {
-			MessageDialog d (
-				_("You can't perform this operation because the processing of the signal "
-				  "will cause one or more of the tracks will end up with a region with more channels than this track has inputs.\n\n"
-				  "You can do this without processing, which is a different operation.")
-				);
-			d.set_title (_("Cannot bounce"));
-			d.run ();
-			return;
+
+		if (enable_processing) {
+
+			RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
+
+			if (rtv && rtv->track() && replace && enable_processing && !rtv->track()->bounceable (rtv->track()->main_outs(), false)) {
+				MessageDialog d (
+					_("You can't perform this operation because the processing of the signal "
+					  "will cause one or more of the tracks to end up with a region with more channels than this track has inputs.\n\n"
+					  "You can do this without processing, which is a different operation.")
+					);
+				d.set_title (_("Cannot bounce"));
+				d.run ();
+				return;
+			}
 		}
 	}
 
@@ -3356,7 +3586,17 @@ Editor::bounce_range_selection (bool replace, bool enable_processing)
 		playlist->clear_changes ();
 		playlist->clear_owned_changes ();
 
-		boost::shared_ptr<Region> r = rtv->track()->bounce_range (start, start+cnt, itt, enable_processing);
+		boost::shared_ptr<Region> r;
+
+		if (enable_processing) {
+			r = rtv->track()->bounce_range (start, start+cnt, itt, rtv->track()->main_outs(), false);
+		} else {
+			r = rtv->track()->bounce_range (start, start+cnt, itt, boost::shared_ptr<Processor>(), false);
+		}
+
+		if (!r) {
+			continue;
+		}
 
 		if (replace) {
 			list<AudioRange> ranges;
@@ -3401,7 +3641,7 @@ Editor::copy ()
 bool
 Editor::can_cut_copy () const
 {
-	switch (current_mouse_mode()) {
+	switch (effective_mouse_mode()) {
 
 	case MouseObject:
 		if (!selection->regions.empty() || !selection->points.empty()) {
@@ -3460,7 +3700,8 @@ Editor::cut_copy (CutCopyOp op)
 		}
 	}
 
-	cut_buffer->clear ();
+	if ( op != Clear )  //"Delete" doesn't change copy/paste buf
+		cut_buffer->clear ();
 
 	if (entered_marker) {
 
@@ -3479,7 +3720,7 @@ Editor::cut_copy (CutCopyOp op)
 
 	if (internal_editing()) {
 
-		switch (current_mouse_mode()) {
+		switch (effective_mouse_mode()) {
 		case MouseObject:
 		case MouseRange:
 			cut_copy_midi (op);
@@ -3490,23 +3731,62 @@ Editor::cut_copy (CutCopyOp op)
 
 	} else {
 
-		RegionSelection rs;
+	RegionSelection rs; 
 
-		/* we only want to cut regions if some are selected */
+	/* we only want to cut regions if some are selected */
 
-		if (!selection->regions.empty()) {
-			rs = selection->regions;
-		}
+	if (!selection->regions.empty()) {
+		rs = selection->regions;
+	}
 
-		switch (current_mouse_mode()) {
-		case MouseObject:
+	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 ();
 					}
@@ -3519,16 +3799,11 @@ Editor::cut_copy (CutCopyOp op)
 						selection->clear_points ();
 					}
 				}
-				commit_reversible_command ();
-				break; // terminate case statement here
-			}
-			if (!selection->time.empty()) {
-				/* don't cause suprises */
-				break;
-			}
-			// fall thru if there was nothing selected
 
-		case MouseRange:
+				commit_reversible_command ();	
+				break;
+			} 
+			
 			if (selection->time.empty()) {
 				framepos_t start, end;
 				if (!get_edit_op_range (start, end)) {
@@ -3536,17 +3811,17 @@ Editor::cut_copy (CutCopyOp op)
 				}
 				selection->set (start, end);
 			}
-
+				
 			begin_reversible_command (opname + _(" range"));
 			cut_copy_ranges (op);
 			commit_reversible_command ();
-
+			
 			if (op == Cut || op == Delete) {
 				selection->clear_time ();
 			}
 
 			break;
-
+			
 		default:
 			break;
 		}
@@ -3557,19 +3832,87 @@ Editor::cut_copy (CutCopyOp op)
 	}
 }
 
+struct AutomationRecord {
+	AutomationRecord () : state (0) {}
+	AutomationRecord (XMLNode* s) : state (s) {}
+	
+	XMLNode* state; ///< state before any operation
+	boost::shared_ptr<Evoral::ControlList> copy; ///< copied events for the cut buffer
+};
+
 /** Cut, copy or clear selected automation points.
- * @param op Operation (Cut, Copy or Clear)
+ *  @param op Operation (Cut, Copy or Clear)
  */
 void
 Editor::cut_copy_points (CutCopyOp op)
 {
+	if (selection->points.empty ()) {
+		return;
+	}
+
+	/* XXX: not ideal, as there may be more than one track involved in the point selection */
+	_last_cut_copy_source_track = &selection->points.front()->line().trackview;
+
+	/* Keep a record of the AutomationLists that we end up using in this operation */
+	typedef std::map<boost::shared_ptr<AutomationList>, AutomationRecord> Lists;
+	Lists lists;
+
+	/* 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();
+		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 ());
+		}
+	}
+
+	if (op == Cut || op == Copy) {
+		/* This operation will involve putting things in the cut buffer, so create an empty
+		   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 ());
+		}
+
+		/* Add all selected points to the relevant copy ControlLists */
+		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);
+		}
+
+		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;
+			for (AutomationList::iterator j = i->second.copy->begin(); j != i->second.copy->end(); ++j) {
+				(*j)->when -= start;
+			}
+
+			/* And add it to the cut buffer */
+			cut_buffer->add (i->second.copy);
+		}
+	}
+		
+	if (op == Delete || op == Cut) {
+		/* This operation needs to remove things from the main AutomationList, so do that now */
+		
+		for (Lists::iterator i = lists.begin(); i != lists.end(); ++i) {
+			i->first->freeze ();
+		}
 
-		AutomationTimeAxisView* atv = dynamic_cast<AutomationTimeAxisView*>((*i).track);
-		_last_cut_copy_source_track = atv;
+		/* Remove each selected point from its AutomationList */
+		for (PointSelection::iterator i = selection->points.begin(); i != selection->points.end(); ++i) {
+			boost::shared_ptr<AutomationList> al = (*i)->line().the_list();
+			al->erase ((*i)->model ());
+		}
 
-		if (atv) {
-			atv->cut_copy_clear_objects (selection->points, op);
+		/* Thaw the lists and add undo records for them */
+		for (Lists::iterator i = lists.begin(); i != lists.end(); ++i) {
+			boost::shared_ptr<AutomationList> al = i->first;
+			al->thaw ();
+			_session->add_command (new MementoCommand<AutomationList> (*al.get(), i->second.state, &(al->get_state ())));
 		}
 	}
 }
@@ -3613,7 +3956,16 @@ Editor::remove_clicked_region ()
 
 	begin_reversible_command (_("remove region"));
 	playlist->clear_changes ();
+	playlist->clear_owned_changes ();
 	playlist->remove_region (clicked_regionview->region());
+
+	/* We might have removed regions, which alters other regions' layering_index,
+	   so we need to do a recursive diff here.
+	*/
+	vector<Command*> cmds;
+	playlist->rdiff (cmds);
+	_session->add_commands (cmds);
+	
 	_session->add_command(new StatefulDiffCommand (playlist));
 	commit_reversible_command ();
 }
@@ -3657,23 +4009,16 @@ Editor::remove_selected_regions ()
 	        	continue;
 	        }
 
-		vector<boost::shared_ptr<Playlist> >::iterator i;
-
-		//only prep history if this is a new playlist.
-		for (i = playlists.begin(); i != playlists.end(); ++i) {
-			if ((*i) == playlist) {
-				break;
-			}
-		}
-
-		if (i == playlists.end()) {
-
-			playlist->clear_changes ();
-			playlist->freeze ();
+		/* get_regions_from_selection_and_entered() guarantees that
+		   the playlists involved are unique, so there is no need
+		   to check here.
+		*/
 
-			playlists.push_back (playlist);
-		}
+		playlists.push_back (playlist);
 
+		playlist->clear_changes ();
+		playlist->clear_owned_changes ();
+		playlist->freeze ();
 		playlist->remove_region (*rl);
 	}
 
@@ -3681,6 +4026,14 @@ Editor::remove_selected_regions ()
 
 	for (pl = playlists.begin(); pl != playlists.end(); ++pl) {
 		(*pl)->thaw ();
+
+		/* We might have removed regions, which alters other regions' layering_index,
+		   so we need to do a recursive diff here.
+		*/
+		vector<Command*> cmds;
+		(*pl)->rdiff (cmds);
+		_session->add_commands (cmds);
+		
 		_session->add_command(new StatefulDiffCommand (*pl));
 	}
 
@@ -3727,6 +4080,7 @@ Editor::cut_copy_regions (CutCopyOp op, RegionSelection& rs)
 
 				if (fl == freezelist.end()) {
 					pl->clear_changes();
+					pl->clear_owned_changes ();
 					pl->freeze ();
 					freezelist.insert (pl);
 				}
@@ -3842,6 +4196,14 @@ Editor::cut_copy_regions (CutCopyOp op, RegionSelection& rs)
 
 	for (FreezeList::iterator pl = freezelist.begin(); pl != freezelist.end(); ++pl) {
 		(*pl)->thaw ();
+
+		/* We might have removed regions, which alters other regions' layering_index,
+		   so we need to do a recursive diff here.
+		*/
+		vector<Command*> cmds;
+		(*pl)->rdiff (cmds);
+		_session->add_commands (cmds);
+		
 		_session->add_command (new StatefulDiffCommand (*pl));
 	}
 }
@@ -3849,36 +4211,34 @@ Editor::cut_copy_regions (CutCopyOp op, RegionSelection& rs)
 void
 Editor::cut_copy_ranges (CutCopyOp op)
 {
-	TrackViewList* ts;
-	TrackViewList entered;
+	TrackViewList ts = selection->tracks.filter_to_unique_playlists ();
 
 	/* Sort the track selection now, so that it if is used, the playlists
 	   selected by the calls below to cut_copy_clear are in the order that
 	   their tracks appear in the editor.  This makes things like paste
 	   of ranges work properly.
 	*/
-	sort_track_selection (&selection->tracks);
 
-	if (selection->tracks.empty()) {
+	sort_track_selection (ts);
+
+	if (ts.empty()) {
 		if (!entered_track) {
 			return;
 		}
-		entered.push_back (entered_track);
-		ts = &entered;
-	} else {
-		ts = &selection->tracks;
-	}
+		ts.push_back (entered_track);
+	} 
 
-	for (TrackSelection::iterator i = ts->begin(); i != ts->end(); ++i) {
+	for (TrackViewList::iterator i = ts.begin(); i != ts.end(); ++i) {
 		(*i)->cut_copy_clear (*selection, op);
 	}
 }
 
 void
-Editor::paste (float times)
+Editor::paste (float times, bool from_context)
 {
         DEBUG_TRACE (DEBUG::CutNPaste, "paste to preferred edit pos\n");
-	paste_internal (get_preferred_edit_position(), times);
+
+	paste_internal (get_preferred_edit_position (false, from_context), times);
 }
 
 void
@@ -3921,12 +4281,15 @@ Editor::paste_internal (framepos_t position, float times)
 
 	/* get everything in the correct order */
 
-	if (!selection->tracks.empty()) {
-		/* there are some selected tracks, so paste to them */
-		sort_track_selection ();
-		ts = selection->tracks;
+	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 */
+		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;
+		/* Otherwise paste to the track that the cut/copy came from;
 		   see discussion in mantis #3333.
 		*/
 		ts.push_back (_last_cut_copy_source_track);
@@ -4029,7 +4392,9 @@ Editor::duplicate_selection (float times)
 
 	ri = new_regions.begin();
 
-	for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
+	TrackViewList ts = selection->tracks.filter_to_unique_playlists ();
+
+	for (TrackViewList::iterator i = ts.begin(); i != ts.end(); ++i) {
 		if ((playlist = (*i)->playlist()) == 0) {
 			continue;
 		}
@@ -4046,18 +4411,13 @@ Editor::duplicate_selection (float times)
 	commit_reversible_command ();
 }
 
+/** Reset all selected points to the relevant default value */
 void
 Editor::reset_point_selection ()
 {
-	/* reset all selected points to the relevant default value */
-
 	for (PointSelection::iterator i = selection->points.begin(); i != selection->points.end(); ++i) {
-
-		AutomationTimeAxisView* atv = dynamic_cast<AutomationTimeAxisView*>((*i).track);
-
-		if (atv) {
-			atv->reset_objects (selection->points);
-		}
+		ARDOUR::AutomationList::iterator j = (*i)->model ();
+		(*j)->value = (*i)->line().the_list()->default_value ();
 	}
 }
 
@@ -4108,7 +4468,9 @@ Editor::nudge_track (bool use_edit, bool forwards)
 
 	begin_reversible_command (_("nudge track"));
 
-	for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
+	TrackViewList ts = selection->tracks.filter_to_unique_playlists ();
+
+	for (TrackViewList::iterator i = ts.begin(); i != ts.end(); ++i) {
 
 		if ((playlist = (*i)->playlist()) == 0) {
 			continue;
@@ -4459,8 +4821,7 @@ Editor::quantize_region ()
 	qd->hide ();
 
 	if (r == Gtk::RESPONSE_OK) {
-		Quantize quant (*_session, Plain,
-				qd->snap_start(), qd->snap_end(),
+		Quantize quant (*_session, qd->snap_start(), qd->snap_end(),
 				qd->start_grid_size(), qd->end_grid_size(),
 				qd->strength(), qd->swing(), qd->threshold());
 
@@ -4469,17 +4830,24 @@ Editor::quantize_region ()
 }
 
 void
-Editor::insert_patch_change ()
+Editor::insert_patch_change (bool from_context)
 {
 	RegionSelection rs = get_regions_from_selection_and_entered ();
+
 	if (rs.empty ()) {
 		return;
 	}
 
-	framepos_t const p = get_preferred_edit_position (false);
+	const framepos_t p = get_preferred_edit_position (false, from_context);
+
+	/* XXX: bit of a hack; use the MIDNAM from the first selected region;
+	   there may be more than one, but the PatchChangeDialog can only offer
+	   one set of patch menus.
+	*/
+	MidiRegionView* first = dynamic_cast<MidiRegionView*> (rs.front ());
 
 	Evoral::PatchChange<Evoral::MusicalTime> empty (0, 0, 0, 0);
-	PatchChangeDialog d (0, _session, empty, Gtk::Stock::ADD);
+        PatchChangeDialog d (0, _session, empty, first->instrument_info(), Gtk::Stock::ADD);
 
 	if (d.run() == RESPONSE_CANCEL) {
 		return;
@@ -4527,6 +4895,7 @@ Editor::apply_filter (Filter& filter, string command, ProgressReporter* progress
 			if (arv->audio_region()->apply (filter, progress) == 0) {
 
 				playlist->clear_changes ();
+				playlist->clear_owned_changes ();
 
 				if (filter.results.empty ()) {
 
@@ -4549,6 +4918,13 @@ Editor::apply_filter (Filter& filter, string command, ProgressReporter* progress
 
 				}
 
+				/* We might have removed regions, which alters other regions' layering_index,
+				   so we need to do a recursive diff here.
+				*/
+				vector<Command*> cmds;
+				playlist->rdiff (cmds);
+				_session->add_commands (cmds);
+				
 				_session->add_command(new StatefulDiffCommand (playlist));
 			} else {
 				goto out;
@@ -4601,7 +4977,31 @@ Editor::reset_region_gain_envelopes ()
 }
 
 void
-Editor::toggle_gain_envelope_visibility ()
+Editor::set_region_gain_visibility (RegionView* rv)
+{
+	AudioRegionView* arv = dynamic_cast<AudioRegionView*> (rv);
+	if (arv) {
+		arv->update_envelope_visibility();
+	}
+}
+
+void
+Editor::set_gain_envelope_visibility ()
+{
+	if (!_session) {
+		return;
+	}
+
+	for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
+		AudioTimeAxisView* v = dynamic_cast<AudioTimeAxisView*>(*i);
+		if (v) {
+			v->audio_view()->foreach_regionview (sigc::mem_fun (this, &Editor::set_region_gain_visibility));
+		}
+	}
+}
+
+void
+Editor::toggle_gain_envelope_active ()
 {
 	if (_ignore_region_action) {
 		return;
@@ -4613,13 +5013,13 @@ Editor::toggle_gain_envelope_visibility ()
 		return;
 	}
 
-	_session->begin_reversible_command (_("region gain envelope visible"));
+	_session->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) {
 			arv->region()->clear_changes ();
-			arv->set_envelope_visible (!arv->envelope_visible());
+			arv->audio_region()->set_envelope_active (!arv->audio_region()->envelope_active());
 			_session->add_command (new StatefulDiffCommand (arv->region()));
 		}
 	}
@@ -4628,7 +5028,7 @@ Editor::toggle_gain_envelope_visibility ()
 }
 
 void
-Editor::toggle_gain_envelope_active ()
+Editor::toggle_region_lock ()
 {
 	if (_ignore_region_action) {
 		return;
@@ -4640,22 +5040,19 @@ Editor::toggle_gain_envelope_active ()
 		return;
 	}
 
-	_session->begin_reversible_command (_("region gain envelope active"));
+	_session->begin_reversible_command (_("toggle region lock"));
 
 	for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
-		AudioRegionView* const arv = dynamic_cast<AudioRegionView*>(*i);
-		if (arv) {
-			arv->region()->clear_changes ();
-			arv->audio_region()->set_envelope_active (!arv->audio_region()->envelope_active());
-			_session->add_command (new StatefulDiffCommand (arv->region()));
-		}
+		(*i)->region()->clear_changes ();
+		(*i)->region()->set_locked (!(*i)->region()->locked());
+		_session->add_command (new StatefulDiffCommand ((*i)->region()));
 	}
 
 	_session->commit_reversible_command ();
 }
 
 void
-Editor::toggle_region_lock ()
+Editor::toggle_region_video_lock ()
 {
 	if (_ignore_region_action) {
 		return;
@@ -4667,11 +5064,11 @@ Editor::toggle_region_lock ()
 		return;
 	}
 
-	_session->begin_reversible_command (_("toggle region lock"));
+	_session->begin_reversible_command (_("Toggle Video Lock"));
 
 	for (RegionSelection::iterator i = rs.begin(); i != rs.end(); ++i) {
 		(*i)->region()->clear_changes ();
-		(*i)->region()->set_locked (!(*i)->region()->locked());
+		(*i)->region()->set_video_locked (!(*i)->region()->video_locked());
 		_session->add_command (new StatefulDiffCommand ((*i)->region()));
 	}
 
@@ -4748,6 +5145,60 @@ Editor::toggle_record_enable ()
 	}
 }
 
+void
+Editor::toggle_solo ()
+{
+	bool new_state = false;
+	bool first = true;
+	boost::shared_ptr<RouteList> rl (new RouteList);
+
+	for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
+		RouteTimeAxisView *rtav = dynamic_cast<RouteTimeAxisView *>(*i);
+
+		if (!rtav) {
+			continue;
+		}
+
+		if (first) {
+			new_state = !rtav->route()->soloed ();
+			first = false;
+		}
+
+		rl->push_back (rtav->route());
+	}
+
+	_session->set_solo (rl, new_state, Session::rt_cleanup, true);
+}
+
+void
+Editor::toggle_mute ()
+{
+	bool new_state = false;
+	bool first = true;
+	boost::shared_ptr<RouteList> rl (new RouteList);
+
+	for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
+		RouteTimeAxisView *rtav = dynamic_cast<RouteTimeAxisView *>(*i);
+
+		if (!rtav) {
+			continue;
+		}
+
+		if (first) {
+			new_state = !rtav->route()->muted();
+			first = false;
+		}
+
+		rl->push_back (rtav->route());
+	}
+
+	_session->set_mute (rl, new_state, Session::rt_cleanup, true);
+}
+
+void
+Editor::toggle_solo_isolate ()
+{
+}
 
 void
 Editor::set_fade_length (bool in)
@@ -4941,8 +5392,12 @@ Editor::set_fade_out_active (bool yn)
 void
 Editor::toggle_region_fades (int dir)
 {
+	if (_ignore_region_action) {
+		return;
+	}
+	
 	boost::shared_ptr<AudioRegion> ar;
-	bool yn;
+	bool yn = false;
 
 	RegionSelection rs = get_regions_from_selection_and_entered ();
 
@@ -5001,24 +5456,6 @@ Editor::update_region_fade_visibility ()
 	}
 }
 
-/** Update crossfade visibility after its configuration has been changed */
-void
-Editor::update_xfade_visibility ()
-{
-	_xfade_visibility = _session->config.get_xfades_visible ();
-
-	for (TrackViewList::iterator i = track_views.begin(); i != track_views.end(); ++i) {
-		AudioTimeAxisView* v = dynamic_cast<AudioTimeAxisView*>(*i);
-		if (v) {
-			if (_xfade_visibility) {
-				v->show_all_xfades ();
-			} else {
-				v->hide_all_xfades ();
-			}
-		}
-	}
-}
-
 void
 Editor::set_edit_point ()
 {
@@ -5065,14 +5502,15 @@ Editor::set_playhead_cursor ()
 			_session->request_locate (where, _session->transport_rolling());
 		}
 	}
+
+	if ( Config->get_always_play_range() )
+		cancel_time_selection();
 }
 
 void
 Editor::split_region ()
 {
-	if (((mouse_mode == MouseRange) ||
-	     (mouse_mode != MouseObject && _join_object_range_state == JOIN_OBJECT_RANGE_RANGE)) &&
-	    !selection->time.empty()) {
+	if ( !selection->time.empty()) {
 		separate_regions_between (selection->time);
 		return;
 	}
@@ -5088,28 +5526,9 @@ Editor::split_region ()
 	split_regions_at (where, rs);
 }
 
-void
-Editor::ensure_entered_track_selected (bool op_really_wants_one_track_if_none_are_selected)
-{
-	if (entered_track && mouse_mode == MouseObject) {
-		if (!selection->tracks.empty()) {
-			if (!selection->selected (entered_track)) {
-				selection->add (entered_track);
-			}
-		} else {
-			/* there is no selection, but this operation requires/prefers selected objects */
-
-			if (op_really_wants_one_track_if_none_are_selected) {
-				selection->set (entered_track);
-			}
-		}
-	}
-}
-
 struct EditorOrderRouteSorter {
     bool operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b) {
-	    /* use of ">" forces the correct sort order */
-	    return a->order_key ("editor") < b->order_key ("editor");
+	    return a->order_key (EditorSort) < b->order_key (EditorSort);
     }
 };
 
@@ -5408,7 +5827,9 @@ Editor::define_one_bar (framepos_t start, framepos_t end)
 	   we have frames per bar, and beats per bar, so ...
 	*/
 
-	double frames_per_beat = length / m.beats_per_bar();
+	/* XXXX METER MATH */
+
+	double frames_per_beat = length / m.divisions_per_bar();
 
 	/* beats per minute = */
 
@@ -5472,7 +5893,9 @@ Editor::define_one_bar (framepos_t start, framepos_t end)
 	} else if (t.frame() == start) {
 		_session->tempo_map().change_existing_tempo_at (start, beats_per_minute, t.note_type());
 	} else {
-		_session->tempo_map().add_tempo (Tempo (beats_per_minute, t.note_type()), start);
+		Timecode::BBT_Time bbt;
+		_session->tempo_map().bbt_time (start, bbt);
+		_session->tempo_map().add_tempo (Tempo (beats_per_minute, t.note_type()), bbt);
 	}
 
 	XMLNode& after (_session->tempo_map().get_state());
@@ -5572,6 +5995,7 @@ Editor::split_region_at_points (boost::shared_ptr<Region> r, AnalysisFeatureList
 	AnalysisFeatureList::const_iterator x;
 
 	pl->clear_changes ();
+	pl->clear_owned_changes ();
 
 	x = positions.begin();
 
@@ -5626,6 +6050,10 @@ Editor::split_region_at_points (boost::shared_ptr<Region> r, AnalysisFeatureList
 		plist.add (ARDOUR::Properties::layer, 0);
 
 		boost::shared_ptr<Region> nr = RegionFactory::create (r->sources(), plist, false);
+		/* because we set annouce to false, manually add the new region to the
+		   RegionFactory map
+		*/
+		RegionFactory::map_add (nr);
 
 		pl->add_region (nr, r->position() + pos);
 
@@ -5650,6 +6078,10 @@ Editor::split_region_at_points (boost::shared_ptr<Region> r, AnalysisFeatureList
 	plist.add (ARDOUR::Properties::layer, 0);
 
 	boost::shared_ptr<Region> nr = RegionFactory::create (r->sources(), plist, false);
+	/* because we set annouce to false, manually add the new region to the
+	   RegionFactory map
+	*/
+	RegionFactory::map_add (nr);
 	pl->add_region (nr, r->position() + pos);
 
 	if (select_new) {
@@ -5658,6 +6090,13 @@ Editor::split_region_at_points (boost::shared_ptr<Region> r, AnalysisFeatureList
 
 	pl->thaw ();
 
+	/* We might have removed regions, which alters other regions' layering_index,
+	   so we need to do a recursive diff here.
+	*/
+	vector<Command*> cmds;
+	pl->rdiff (cmds);
+	_session->add_commands (cmds);
+	
 	_session->add_command (new StatefulDiffCommand (pl));
 
 	if (select_new) {
@@ -5762,8 +6201,7 @@ Editor::close_region_gaps ()
 	Table table (2, 3);
 	table.set_spacings (12);
 	table.set_border_width (12);
-	Label* l = manage (new Label (_("Crossfade length")));
-	l->set_alignment (0, 0.5);
+	Label* l = manage (left_aligned_label (_("Crossfade length")));
 	table.attach (*l, 0, 1, 0, 1);
 
 	SpinButton spin_crossfade (1, 0);
@@ -5774,8 +6212,7 @@ Editor::close_region_gaps ()
 
 	table.attach (*manage (new Label (_("ms"))), 2, 3, 0, 1);
 
-	l = manage (new Label (_("Pull-back length")));
-	l->set_alignment (0, 0.5);
+	l = manage (left_aligned_label (_("Pull-back length")));
 	table.attach (*l, 0, 1, 1, 2);
 
 	SpinButton spin_pullback (1, 0);
@@ -5862,7 +6299,12 @@ Editor::tab_to_transient (bool forward)
 
 	if (!selection->tracks.empty()) {
 
-		for (TrackSelection::iterator t = selection->tracks.begin(); t != selection->tracks.end(); ++t) {
+		/* don't waste time searching for transients in duplicate playlists.
+		 */
+
+		TrackViewList ts = selection->tracks.filter_to_unique_playlists ();
+
+		for (TrackViewList::iterator t = ts.begin(); t != ts.end(); ++t) {
 
 			RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*t);
 
@@ -6116,6 +6558,7 @@ Editor::do_insert_time ()
 		get_preferred_edit_position(),
 		d.distance(),
 		opt,
+		d.all_playlists(),
 		d.move_glued(),
 		d.move_markers(),
 		d.move_glued_markers(),
@@ -6125,8 +6568,10 @@ Editor::do_insert_time ()
 }
 
 void
-Editor::insert_time (framepos_t pos, framecnt_t frames, InsertTimeOption opt,
-		     bool ignore_music_glue, bool markers_too, bool glued_markers_too, bool locked_markers_too, bool tempo_too)
+Editor::insert_time (
+	framepos_t pos, framecnt_t frames, InsertTimeOption opt,
+	bool all_playlists, bool ignore_music_glue, bool markers_too, bool glued_markers_too, bool locked_markers_too, bool tempo_too
+	)
 {
 	bool commit = false;
 
@@ -6136,26 +6581,49 @@ Editor::insert_time (framepos_t pos, framecnt_t frames, InsertTimeOption opt,
 
 	begin_reversible_command (_("insert time"));
 
-	for (TrackSelection::iterator x = selection->tracks.begin(); x != selection->tracks.end(); ++x) {
+	TrackViewList ts = selection->tracks.filter_to_unique_playlists ();
+
+	for (TrackViewList::iterator x = ts.begin(); x != ts.end(); ++x) {
+
 		/* regions */
-		boost::shared_ptr<Playlist> pl = (*x)->playlist();
 
-		if (pl) {
+		/* don't operate on any playlist more than once, which could
+		 * happen if "all playlists" is enabled, but there is more
+		 * than 1 track using playlists "from" a given track.
+		 */
 
-			pl->clear_changes ();
-			pl->clear_owned_changes ();
+		set<boost::shared_ptr<Playlist> > pl;
+
+		if (all_playlists) {
+			RouteTimeAxisView* rtav = dynamic_cast<RouteTimeAxisView*> (*x);
+			if (rtav) {
+				vector<boost::shared_ptr<Playlist> > all = _session->playlists->playlists_for_track (rtav->track ());
+				for (vector<boost::shared_ptr<Playlist> >::iterator p = all.begin(); p != all.end(); ++p) {
+					pl.insert (*p);
+				}
+			}
+		} else {
+			if ((*x)->playlist ()) {
+				pl.insert ((*x)->playlist ());
+			}
+		}
+		
+		for (set<boost::shared_ptr<Playlist> >::iterator i = pl.begin(); i != pl.end(); ++i) {
+
+			(*i)->clear_changes ();
+			(*i)->clear_owned_changes ();
 
 			if (opt == SplitIntersected) {
-				pl->split (pos);
+				(*i)->split (pos);
 			}
 
-			pl->shift (pos, frames, (opt == MoveIntersected), ignore_music_glue);
+			(*i)->shift (pos, frames, (opt == MoveIntersected), ignore_music_glue);
 
 			vector<Command*> cmds;
-			pl->rdiff (cmds);
+			(*i)->rdiff (cmds);
 			_session->add_commands (cmds);
 
-			_session->add_command (new StatefulDiffCommand (pl));
+			_session->add_command (new StatefulDiffCommand (*i));
 			commit = true;
 		}
 
@@ -6273,7 +6741,8 @@ Editor::fit_tracks (TrackViewList & tracks)
 		return;
 	}
 
-	undo_visual_stack.push_back (current_visual_state());
+	undo_visual_stack.push_back (current_visual_state (true));
+	no_save_visual = true;
 
 	/* build a list of all tracks, including children */
 
@@ -6328,7 +6797,7 @@ Editor::fit_tracks (TrackViewList & tracks)
 	controls_layout.property_height () = full_canvas_height - canvas_timebars_vsize;
 	vertical_adjustment.set_value (first_y_pos);
 
-	redo_visual_stack.push_back (current_visual_state());
+	redo_visual_stack.push_back (current_visual_state (true));
 }
 
 void
@@ -6338,7 +6807,9 @@ Editor::save_visual_state (uint32_t n)
 		visual_states.push_back (0);
 	}
 
-	delete visual_states[n];
+	if (visual_states[n] != 0) {
+		delete visual_states[n];
+	}
 
 	visual_states[n] = current_visual_state (true);
 	gdk_beep ();
@@ -6361,38 +6832,19 @@ Editor::goto_visual_state (uint32_t n)
 void
 Editor::start_visual_state_op (uint32_t n)
 {
-	if (visual_state_op_connection.empty()) {
-		visual_state_op_connection = Glib::signal_timeout().connect (sigc::bind (sigc::mem_fun (*this, &Editor::end_visual_state_op), n), 1000);
-	}
-}
-
-void
-Editor::cancel_visual_state_op (uint32_t n)
-{
-	if (!visual_state_op_connection.empty()) {
-		visual_state_op_connection.disconnect();
-		goto_visual_state (n);
-	}  else {
-		//we land here if called from the menu OR if end_visual_state_op has been called
-		//so check if we are already in visual state n
-		// XXX not yet checking it at all, but redoing does not hurt
-		goto_visual_state (n);
-	}
-}
-
-bool
-Editor::end_visual_state_op (uint32_t n)
-{
-	visual_state_op_connection.disconnect();
 	save_visual_state (n);
-
+	
 	PopUp* pup = new PopUp (WIN_POS_MOUSE, 1000, true);
 	char buf[32];
 	snprintf (buf, sizeof (buf), _("Saved view %u"), n+1);
 	pup->set_text (buf);
 	pup->touch();
+}
 
-	return false; // do not call again
+void
+Editor::cancel_visual_state_op (uint32_t n)
+{
+        goto_visual_state (n);
 }
 
 void
@@ -6495,3 +6947,26 @@ Editor::uncombine_regions ()
 	commit_reversible_command ();
 }
 
+void
+Editor::toggle_midi_input_active (bool flip_others)
+{
+	bool onoff;
+	boost::shared_ptr<RouteList> rl (new RouteList);
+
+	for (TrackSelection::iterator i = selection->tracks.begin(); i != selection->tracks.end(); ++i) {
+		RouteTimeAxisView *rtav = dynamic_cast<RouteTimeAxisView *>(*i);
+
+		if (!rtav) {
+			continue;
+		}
+
+		boost::shared_ptr<MidiTrack> mt = rtav->midi_track();
+
+		if (mt) {
+			rl->push_back (rtav->route());
+			onoff = !mt->input_active();
+		}
+	}
+	
+	_session->set_exclusive_input_active (rl, onoff, flip_others);
+}