1 files changed, 294 insertions, 200 deletions

diff --git a/gtk2_ardour/editor_drag.cc b/gtk2_ardour/editor_drag.cc
index dd4c8c1b32..d41a91aadd 100644
--- a/gtk2_ardour/editor_drag.cc
+++ b/gtk2_ardour/editor_drag.cc
@@ -33,6 +33,8 @@
 #include "utils.h"
 #include "region_gain_line.h"
 #include "editor_drag.h"
+#include "audio_time_axis.h"
+#include "midi_time_axis.h"
 
 using namespace std;
 using namespace ARDOUR;
@@ -50,7 +52,6 @@ Drag::Drag (Editor* e, ArdourCanvas::Item* i) :
 	_grab_frame (0),
 	_last_pointer_frame (0),
 	_current_pointer_frame (0),
-	_copy (false),
 	_had_movement (false),
 	_move_threshold_passed (false)
 {
@@ -138,11 +139,9 @@ Drag::end_grab (GdkEvent* event)
 
 	_item->ungrab (event ? event->button.time : 0);
 
-	if (event) {
-		_last_pointer_x = _current_pointer_x;
-		_last_pointer_y = _current_pointer_y;
-		finished (event, _had_movement);
-	}
+	_last_pointer_x = _current_pointer_x;
+	_last_pointer_y = _current_pointer_y;
+	finished (event, _had_movement);
 
 	_editor->hide_verbose_canvas_cursor();
 
@@ -256,147 +255,108 @@ RegionDrag::update_selection ()
 	_editor->selection->set (s);
 }
 
-RegionMoveDrag::RegionMoveDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v, bool b, bool c)
+RegionMotionDrag::RegionMotionDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v, bool b)
 	: RegionDrag (e, i, p, v),
+	  _dest_trackview (0),
+	  _dest_layer (0),
 	  _brushing (b)
 {
-	_copy = c;
 	
-	TimeAxisView* const tv = &_primary->get_time_axis_view ();
-	
-	_dest_trackview = tv;
-	_dest_layer = _primary->region()->layer ();
-
-	double speed = 1;
-	RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
-	if (rtv && rtv->is_track()) {
-		speed = rtv->get_diskstream()->speed ();
-	}
-
-	_last_frame_position = static_cast<nframes64_t> (_primary->region()->position() / speed);
 }
 
+
 void
-RegionMoveDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
+RegionMotionDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
 {
 	Drag::start_grab (event);
 	
-	_pointer_frame_offset = _grab_frame - _last_frame_position;
 	_editor->show_verbose_time_cursor (_last_frame_position, 10);
 }
 
-void
-RegionMoveDrag::motion (GdkEvent* event, bool first_move)
+RegionMotionDrag::TimeAxisViewSummary
+RegionMotionDrag::get_time_axis_view_summary ()
 {
-	double x_delta = 0;
-	double y_delta = 0;
-	nframes64_t pending_region_position = 0;
-	int32_t pointer_order_span = 0, canvas_pointer_order_span = 0;
-	int32_t pointer_layer_span = 0;
-	
-	bool clamp_y_axis = false;
-	vector<int32_t>::iterator j;
+	int32_t children = 0;
+	TimeAxisViewSummary sum;
 
-	if (_copy && first_move) {
-		copy_regions (event);
-	}
-	
-	/* *pointer* variables reflect things about the pointer; as we may be moving
-	   multiple regions, much detail must be computed per-region */
+	_editor->visible_order_range (&sum.visible_y_low, &sum.visible_y_high);
+		
+	/* get a bitmask representing the visible tracks */
 
-	/* current_pointer_view will become the TimeAxisView that we're currently pointing at, and
-	   current_pointer_layer the current layer on that TimeAxisView */
-	RouteTimeAxisView* current_pointer_view;
-	layer_t current_pointer_layer;
-	if (!check_possible (&current_pointer_view, &current_pointer_layer)) {
-		return;
+	for (Editor::TrackViewList::iterator i = _editor->track_views.begin(); i != _editor->track_views.end(); ++i) {
+		RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
+		TimeAxisView::Children children_list;
+		
+		/* zeroes are audio/MIDI tracks. ones are other types. */
+		
+		if (!rtv->hidden()) {
+			
+			if (!rtv->is_track()) {
+				/* not an audio nor MIDI track */
+				sum.tracks = sum.tracks |= (0x01 << rtv->order());
+			}
+			
+			sum.height_list[rtv->order()] = (*i)->current_height();
+			children = 1;
+
+			if ((children_list = rtv->get_child_list()).size() > 0) {
+				for (TimeAxisView::Children::iterator j = children_list.begin(); j != children_list.end(); ++j) { 
+					sum.tracks = sum.tracks |= (0x01 << (rtv->order() + children));
+					sum.height_list[rtv->order() + children] = (*j)->current_height();
+					children++;	
+				}
+			}
+		}
 	}
 
-	/* TimeAxisView that we were pointing at last time we entered this method */
-	TimeAxisView const * const last_pointer_view = _dest_trackview;
-	/* the order of the track that we were pointing at last time we entered this method */
-	int32_t const last_pointer_order = last_pointer_view->order ();
-	/* the layer that we were pointing at last time we entered this method */
-	layer_t const last_pointer_layer = _dest_layer;
-
-	/************************************************************
-	     Y DELTA COMPUTATION
-	************************************************************/	
+	return sum;
+}
 
-	/* Height of TimeAxisViews, indexed by order */
-	/* XXX: hard-coded limit of TimeAxisViews */
-	vector<int32_t> height_list (512);
-	
+bool
+RegionMotionDrag::compute_y_delta (
+	TimeAxisView const * last_pointer_view, TimeAxisView* current_pointer_view,
+	int32_t last_pointer_layer, int32_t current_pointer_layer,
+	TimeAxisViewSummary const & tavs,
+	int32_t* pointer_order_span, int32_t* pointer_layer_span,
+	int32_t* canvas_pointer_order_span
+	)
+{
 	if (_brushing) {
-		clamp_y_axis = true;
-		pointer_order_span = 0;
-		goto y_axis_done;
+		*pointer_order_span = 0;
+		*pointer_layer_span = 0;
+		return true;
 	}
 
+	bool clamp_y_axis = false;
+		
 	/* the change in track order between this callback and the last */
-	pointer_order_span = last_pointer_view->order() - current_pointer_view->order();
+	*pointer_order_span = last_pointer_view->order() - current_pointer_view->order();
 	/* the change in layer between this callback and the last;
 	   only meaningful if pointer_order_span == 0 (ie we've not moved tracks) */
-	pointer_layer_span = last_pointer_layer - current_pointer_layer;
-
-	if (pointer_order_span != 0) {
-
-		int32_t children = 0;
-		/* XXX: hard-coded limit of tracks */
-		bitset <512> tracks (0x00);
-
-		int visible_y_high;
-		int visible_y_low;
-		_editor->visible_order_range (&visible_y_low, &visible_y_high);
-		
-		/* get a bitmask representing the visible tracks */
+	*pointer_layer_span = last_pointer_layer - current_pointer_layer;
 
-		for (Editor::TrackViewList::iterator i = _editor->track_views.begin(); i != _editor->track_views.end(); ++i) {
-			RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (*i);
-			TimeAxisView::Children children_list;
-	      
-			/* zeroes are audio/MIDI tracks. ones are other types. */
-	      
-			if (!rtv->hidden()) {
-				
-				if (!rtv->is_track()) {
-					/* not an audio nor MIDI track */
-					tracks = tracks |= (0x01 << rtv->order());
-				}
-	
-				height_list[rtv->order()] = (*i)->current_height();
-				children = 1;
+	if (*pointer_order_span != 0) {
 
-				if ((children_list = rtv->get_child_list()).size() > 0) {
-					for (TimeAxisView::Children::iterator j = children_list.begin(); j != children_list.end(); ++j) { 
-						tracks = tracks |= (0x01 << (rtv->order() + children));
-						height_list[rtv->order() + children] = (*j)->current_height();
-						children++;	
-					}
-				}
-			}
-		}
-		
 		/* find the actual pointer span, in terms of the number of visible tracks;
 		   to do this, we reduce |pointer_order_span| by the number of hidden tracks
 		   over the span */
 
-		canvas_pointer_order_span = pointer_order_span;
+		*canvas_pointer_order_span = *pointer_order_span;
 		if (last_pointer_view->order() >= current_pointer_view->order()) {
 			for (int32_t y = current_pointer_view->order(); y < last_pointer_view->order(); y++) {
-				if (height_list[y] == 0) {
-					canvas_pointer_order_span--;
+				if (tavs.height_list[y] == 0) {
+					*canvas_pointer_order_span--;
 				}
 			}
 		} else {
 			for (int32_t y = last_pointer_view->order(); y <= current_pointer_view->order(); y++) {
-				if (height_list[y] == 0) {
-					canvas_pointer_order_span++;
+				if (tavs.height_list[y] == 0) {
+					*canvas_pointer_order_span++;
 				}
 			}
 		}
 
-		for (list<RegionView*>::const_iterator i = _editor->selection->regions.by_layer().begin(); i != _editor->selection->regions.by_layer().end(); ++i) {
+		for (list<RegionView*>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
 			
 			RegionView* rv = (*i);
 
@@ -414,18 +374,11 @@ RegionMoveDrag::motion (GdkEvent* event, bool first_move)
 			assert (tvp.first);
 			RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tvp.first);
 
-			/* I know this method has a slightly excessive argument list, but I think
-			   it's nice to separate the code out all the same, since it has such a
-			   simple result, and it makes it clear that there are no other
-			   side-effects.
-			*/
-
 			/* XXX: not sure that we should be passing canvas_pointer_order_span in here,
 			   as surely this is a per-region thing... */
 			
 			clamp_y_axis = y_movement_disallowed (
-				rtv->order(), last_pointer_order, canvas_pointer_order_span, visible_y_low, visible_y_high,
-				tracks, height_list
+				rtv->order(), last_pointer_view->order(), *canvas_pointer_order_span, tavs
 				);
 
 			if (clamp_y_axis) {
@@ -441,16 +394,20 @@ RegionMoveDrag::motion (GdkEvent* event, bool first_move)
 		} 
 	}
 
-  y_axis_done:
 	if (!clamp_y_axis) {
 		_dest_trackview = current_pointer_view;
 		_dest_layer = current_pointer_layer;
 	}
-	  
-	/************************************************************
-	    X DELTA COMPUTATION
-	************************************************************/
 
+	return clamp_y_axis;
+}
+
+
+double
+RegionMotionDrag::compute_x_delta (GdkEvent const * event, nframes64_t* pending_region_position)
+{
+	*pending_region_position = 0;
+	
 	/* compute the amount of pointer motion in frames, and where
 	   the region would be if we moved it by that much.
 	*/
@@ -460,14 +417,15 @@ RegionMoveDrag::motion (GdkEvent* event, bool first_move)
 		nframes64_t sync_offset;
 		int32_t sync_dir;
 		
-		pending_region_position = _current_pointer_frame - _pointer_frame_offset;
+		*pending_region_position = _current_pointer_frame - _pointer_frame_offset;
 		
 		sync_offset = _primary->region()->sync_offset (sync_dir);
 		
 		/* we don't handle a sync point that lies before zero.
 		 */
-		if (sync_dir >= 0 || (sync_dir < 0 && pending_region_position >= sync_offset)) {
-			sync_frame = pending_region_position + (sync_dir*sync_offset);
+		if (sync_dir >= 0 || (sync_dir < 0 && *pending_region_position >= sync_offset)) {
+			
+			sync_frame = *pending_region_position + (sync_dir*sync_offset);
 			
 			/* we snap if the snap modifier is not enabled.
 			 */
@@ -476,43 +434,30 @@ RegionMoveDrag::motion (GdkEvent* event, bool first_move)
 				_editor->snap_to (sync_frame);	
 			}
 			
-			pending_region_position = _primary->region()->adjust_to_sync (sync_frame);
+			*pending_region_position = _primary->region()->adjust_to_sync (sync_frame);
 			
 		} else {
-			pending_region_position = _last_frame_position;
+			*pending_region_position = _last_frame_position;
 		}
 		
-	} else {
-		pending_region_position = 0;
-	}
-	
-	if (pending_region_position > max_frames - _primary->region()->length()) {
-		pending_region_position = _last_frame_position;
 	}
 	
-	bool x_move_allowed;
-		
-	if (Config->get_edit_mode() == Lock) {
-		if (_copy) {
-			x_move_allowed = !_x_constrained;
-		} else {
-			/* in locked edit mode, reverse the usual meaning of _x_constrained */
-			x_move_allowed = _x_constrained;
-		}
-	} else {
-		x_move_allowed = !_x_constrained;
+	if (*pending_region_position > max_frames - _primary->region()->length()) {
+		*pending_region_position = _last_frame_position;
 	}
+
+	double x_delta = 0;
 	
-	if (( pending_region_position != _last_frame_position) && x_move_allowed ) {
+	if ((*pending_region_position != _last_frame_position) && x_move_allowed ()) {
 		
 		/* now compute the canvas unit distance we need to move the regionview
 		   to make it appear at the new location.
 		*/
+
+		x_delta = (static_cast<double> (*pending_region_position) - _last_frame_position) / _editor->frames_per_unit;
 		
-		if (pending_region_position > _last_frame_position) {
-			x_delta = ((double) (pending_region_position - _last_frame_position) / _editor->frames_per_unit);
-		} else {
-			x_delta = -((double) (_last_frame_position - pending_region_position) / _editor->frames_per_unit);
+		if (*pending_region_position <= _last_frame_position) {
+			
 			for (list<RegionView*>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
 				
 				RegionView* rv = (*i);
@@ -525,20 +470,60 @@ RegionMoveDrag::motion (GdkEvent* event, bool first_move)
 				
 				if (-x_delta > ix1 + _editor->horizontal_adjustment.get_value()) {
 					x_delta = 0;
-					pending_region_position = _last_frame_position;
+					*pending_region_position = _last_frame_position;
 					break;
 				}
 			}
 			
 		}
 		
-		_last_frame_position = pending_region_position;
-		
-	} else {
-		x_delta = 0;
+		_last_frame_position = *pending_region_position;
 	}
 
+	return x_delta;
+}
+
+void
+RegionMotionDrag::motion (GdkEvent* event, bool first_move)
+{
+	double y_delta = 0;
+
+	TimeAxisViewSummary tavs = get_time_axis_view_summary ();
+
+	vector<int32_t>::iterator j;
+
+	/* *pointer* variables reflect things about the pointer; as we may be moving
+	   multiple regions, much detail must be computed per-region */
+
+	/* current_pointer_view will become the TimeAxisView that we're currently pointing at, and
+	   current_pointer_layer the current layer on that TimeAxisView */
+	RouteTimeAxisView* current_pointer_view;
+	layer_t current_pointer_layer;
+	if (!check_possible (&current_pointer_view, &current_pointer_layer)) {
+		return;
+	}
+
+	/* TimeAxisView that we were pointing at last time we entered this method */
+	TimeAxisView const * const last_pointer_view = _dest_trackview;
+	/* the order of the track that we were pointing at last time we entered this method */
+	int32_t const last_pointer_order = last_pointer_view->order ();
+	/* the layer that we were pointing at last time we entered this method */
+	layer_t const last_pointer_layer = _dest_layer;
+
+	int32_t pointer_order_span;
+	int32_t pointer_layer_span;
+	int32_t canvas_pointer_order_span;
 	
+	bool const clamp_y_axis = compute_y_delta (
+		last_pointer_view, current_pointer_view,
+		last_pointer_layer, current_pointer_layer, tavs,
+		&pointer_order_span, &pointer_layer_span,
+		&canvas_pointer_order_span
+		);
+
+	nframes64_t pending_region_position;
+	double const x_delta = compute_x_delta (event, &pending_region_position);
+
 	/*************************************************************
 	    PREPARE TO MOVE
 	************************************************************/
@@ -614,9 +599,9 @@ RegionMoveDrag::motion (GdkEvent* event, bool first_move)
 			/* INTER-TRACK MOVEMENT */
 			
 			/* move through the height list to the track that the region is currently on */
-			vector<int32_t>::iterator j = height_list.begin ();
+			vector<int32_t>::iterator j = tavs.height_list.begin ();
 			int32_t x = 0;
-			while (j != height_list.end () && x != rtv->order ()) {
+			while (j != tavs.height_list.end () && x != rtv->order ()) {
 				++x;
 				++j;
 			}
@@ -624,7 +609,7 @@ RegionMoveDrag::motion (GdkEvent* event, bool first_move)
 			y_delta = 0;
 			int32_t temp_pointer_order_span = canvas_pointer_order_span;
 			
-			if (j != height_list.end ()) {
+			if (j != tavs.height_list.end ()) {
 				
 				/* Account for layers in the original and
 				   destination tracks.  If we're moving around in layers we assume
@@ -654,7 +639,7 @@ RegionMoveDrag::motion (GdkEvent* event, bool first_move)
 					/* we're moving up canvas-wise,
 					   so we need to find the next track height
 					*/
-					if (j != height_list.begin()) {		  
+					if (j != tavs.height_list.begin()) {		  
 						j--;
 					}
 					
@@ -678,7 +663,7 @@ RegionMoveDrag::motion (GdkEvent* event, bool first_move)
 						}
 					}
 					
-					if (j != height_list.end()) {		      
+					if (j != tavs.height_list.end()) {		      
 						j++;
 					}
 					
@@ -724,7 +709,17 @@ RegionMoveDrag::motion (GdkEvent* event, bool first_move)
 	if (x_delta != 0 && !_brushing) {
 		_editor->show_verbose_time_cursor (_last_frame_position, 10);
 	}
-} 
+}
+
+void
+RegionMoveDrag::motion (GdkEvent* event, bool first_move)
+{
+	if (_copy && first_move) {
+		copy_regions (event);
+	}
+
+	RegionMotionDrag::motion (event, first_move);
+}
 
 void
 RegionMoveDrag::finished (GdkEvent* event, bool movement_occurred)
@@ -769,8 +764,6 @@ RegionMoveDrag::finished (GdkEvent* event, bool movement_occurred)
 		goto out;
 	}
 
-	char* op_string;
-
 	/* reverse this here so that we have the correct logic to finalize
 	   the drag.
 	*/
@@ -781,19 +774,18 @@ RegionMoveDrag::finished (GdkEvent* event, bool movement_occurred)
 
 	if (_copy) {
 		if (_x_constrained) {
-			op_string = _("fixed time region copy");
+			_editor->begin_reversible_command (_("fixed time region copy"));
 		} else {
-			op_string = _("region copy");
+			_editor->begin_reversible_command (_("region copy"));
 		} 
 	} else {
 		if (_x_constrained) {
-			op_string = _("fixed time region drag");
+			_editor->begin_reversible_command (_("fixed time region drag"));
 		} else {
-			op_string = _("region drag");
+			_editor->begin_reversible_command (_("region drag"));
 		}
 	}
 
-	_editor->begin_reversible_command (op_string);
 	changed_position = (_last_frame_position != (nframes64_t) (_primary->region()->position()));
 	tvp = _editor->trackview_by_y_position (_current_pointer_y);
 	changed_tracks = (tvp.first != &_primary->get_time_axis_view());
@@ -803,16 +795,7 @@ RegionMoveDrag::finished (GdkEvent* event, bool movement_occurred)
 	_editor->track_canvas->update_now ();
 
 	/* make a list of where each region ended up */
-	for (list<RegionView*>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
-
-		double ix1, ix2, iy1, iy2;
-		(*i)->get_canvas_frame()->get_bounds (ix1, iy1, ix2, iy2);
-		(*i)->get_canvas_frame()->i2w (ix1, iy1);
-		iy1 += _editor->vertical_adjustment.get_value() - _editor->canvas_timebars_vsize;
-
-		pair<TimeAxisView*, int> tv = _editor->trackview_by_y_position (iy1);
-		final[*i] = dynamic_cast<RouteTimeAxisView*> (tv.first);
-	}
+	final = find_time_axis_views ();
 
 	for (list<RegionView*>::const_iterator i = _views.begin(); i != _views.end(); ) {
 
@@ -999,10 +982,35 @@ RegionMoveDrag::finished (GdkEvent* event, bool movement_occurred)
 		delete *x;
 	}
 }
+
+
+bool
+RegionMoveDrag::x_move_allowed () const
+{
+	if (Config->get_edit_mode() == Lock) {
+		if (_copy) {
+			return !_x_constrained;
+		} else {
+			/* in locked edit mode, reverse the usual meaning of _x_constrained */
+			return _x_constrained;
+		}
+	}
 	
+	return !_x_constrained;
+}
+
+bool
+RegionInsertDrag::x_move_allowed () const
+{
+	if (Config->get_edit_mode() == Lock) {
+		return _x_constrained;
+	}
+
+	return !_x_constrained;
+}
 
 void
-RegionMoveDrag::copy_regions (GdkEvent* event)
+RegionMotionDrag::copy_regions (GdkEvent* event)
 {
 	/* duplicate the regionview(s) and region(s) */
 
@@ -1043,7 +1051,8 @@ RegionMoveDrag::copy_regions (GdkEvent* event)
 	_primary = new_regionviews.front();
 	_views = new_regionviews;
 		
-	swap_grab (new_regionviews.front()->get_canvas_group (), 0, event->motion.time);
+	swap_grab (new_regionviews.front()->get_canvas_group (), 0, event ? event->motion.time : 0);
+	
 	/* 
 	   sync the canvas to what we think is its current state 
 	   without it, the canvas seems to 
@@ -1055,7 +1064,7 @@ RegionMoveDrag::copy_regions (GdkEvent* event)
 }
 
 bool
-RegionMoveDrag::check_possible (RouteTimeAxisView** tv, layer_t* layer)
+RegionMotionDrag::check_possible (RouteTimeAxisView** tv, layer_t* layer)
 {
 	/* Which trackview is this ? */
 
@@ -1081,16 +1090,10 @@ RegionMoveDrag::check_possible (RouteTimeAxisView** tv, layer_t* layer)
 /** @param new_order New track order.
  *  @param old_order Old track order.
  *  @param visible_y_low Lowest visible order.
- *  @param visible_y_high Highest visible order.
- *  @param tracks Bitset of tracks indexed by order; 0 means a audio/MIDI track, 1 means something else.
- *  @param heigh_list Heights of tracks indexed by order.
  *  @return true if y movement should not happen, otherwise false.
  */
 bool
-RegionMoveDrag::y_movement_disallowed (
-	int new_order, int old_order, int y_span, int visible_y_low, int visible_y_high,
-	bitset<512> const & tracks, vector<int32_t> const & height_list
-	) const
+RegionMotionDrag::y_movement_disallowed (int new_order, int old_order, int y_span, TimeAxisViewSummary const & tavs) const
 {
 	if (new_order != old_order) {
 
@@ -1099,7 +1102,7 @@ RegionMoveDrag::y_movement_disallowed (
 		if (y_span > 0) {
 
 			/* moving up the canvas */
-			if ( (new_order - y_span) >= visible_y_low) {
+			if ( (new_order - y_span) >= tavs.visible_y_low) {
 
 				int32_t n = 0;
 
@@ -1107,13 +1110,13 @@ RegionMoveDrag::y_movement_disallowed (
 				int32_t visible_tracks = 0;
 				while (visible_tracks < y_span ) {
 					visible_tracks++;
-					while (height_list[new_order - (visible_tracks - n)] == 0) {
+					while (tavs.height_list[new_order - (visible_tracks - n)] == 0) {
 						/* passing through a hidden track */
 						n--;
 					}		  
 				}
 		 
-				if (tracks[new_order - (y_span - n)] != 0x00) {
+				if (tavs.tracks[new_order - (y_span - n)] != 0x00) {
 					/* moving to a non-track; disallow */
 					return true;
 				}
@@ -1127,20 +1130,20 @@ RegionMoveDrag::y_movement_disallowed (
 		} else if (y_span < 0) {
 
 			/* moving down the canvas */
-			if ((new_order - y_span) <= visible_y_high) {
+			if ((new_order - y_span) <= tavs.visible_y_high) {
 
 				int32_t visible_tracks = 0;
 				int32_t n = 0;
 				while (visible_tracks > y_span ) {
 					visible_tracks--;
 		      
-					while (height_list[new_order - (visible_tracks - n)] == 0) {
+					while (tavs.height_list[new_order - (visible_tracks - n)] == 0) {
 						/* passing through a hidden track */
 						n++;
 					}		 
 				}
 						
-				if (tracks[new_order - (y_span - n)] != 0x00) {
+				if (tavs.tracks[new_order - (y_span - n)] != 0x00) {
 					/* moving to a non-track; disallow */
 					return true;
 				}
@@ -1157,10 +1160,10 @@ RegionMoveDrag::y_movement_disallowed (
 		
 		/* this is the pointer's track */
 		
-		if ((new_order - y_span) > visible_y_high) {
+		if ((new_order - y_span) > tavs.visible_y_high) {
 			/* we will overflow */
 			return true;
-		} else if ((new_order - y_span) < visible_y_low) {
+		} else if ((new_order - y_span) < tavs.visible_y_low) {
 			/* we will overflow */
 			return true;
 		}
@@ -1169,6 +1172,97 @@ RegionMoveDrag::y_movement_disallowed (
 	return false;
 }
 
+
+RegionMoveDrag::RegionMoveDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v, bool b, bool c)
+	: RegionMotionDrag (e, i, p, v, b),
+	  _copy (c)
+{
+	TimeAxisView* const tv = &_primary->get_time_axis_view ();
+	
+	_dest_trackview = tv;
+	_dest_layer = _primary->region()->layer ();
+
+	double speed = 1;
+	RouteTimeAxisView* rtv = dynamic_cast<RouteTimeAxisView*> (tv);
+	if (rtv && rtv->is_track()) {
+		speed = rtv->get_diskstream()->speed ();
+	}
+
+	_last_frame_position = static_cast<nframes64_t> (_primary->region()->position() / speed);
+}
+
+void
+RegionMoveDrag::start_grab (GdkEvent* event, Gdk::Cursor* c)
+{
+	RegionMotionDrag::start_grab (event, c);
+	
+	_pointer_frame_offset = _grab_frame - _last_frame_position;
+}
+
+RegionInsertDrag::RegionInsertDrag (Editor* e, boost::shared_ptr<Region> r, RouteTimeAxisView* v, nframes64_t pos)
+	: RegionMotionDrag (e, 0, 0, list<RegionView*> (), false)
+{
+	assert ((boost::dynamic_pointer_cast<AudioRegion> (r) && dynamic_cast<AudioTimeAxisView*> (v)) ||
+		(boost::dynamic_pointer_cast<MidiRegion> (r) && dynamic_cast<MidiTimeAxisView*> (v)));
+
+	_primary = v->view()->create_region_view (r, false, false);
+	
+	_primary->get_canvas_group()->show ();
+	_primary->set_position (pos, 0);
+	_views.push_back (_primary);
+
+	_last_frame_position = pos;
+
+	_item = _primary->get_canvas_group ();
+	_dest_trackview = v;
+	_dest_layer = _primary->region()->layer ();
+}
+
+map<RegionView*, RouteTimeAxisView*>
+RegionMotionDrag::find_time_axis_views ()
+{
+	map<RegionView*, RouteTimeAxisView*> tav;
+	
+	for (list<RegionView*>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
+
+		double ix1, ix2, iy1, iy2;
+		(*i)->get_canvas_frame()->get_bounds (ix1, iy1, ix2, iy2);
+		(*i)->get_canvas_frame()->i2w (ix1, iy1);
+		iy1 += _editor->vertical_adjustment.get_value() - _editor->canvas_timebars_vsize;
+
+		pair<TimeAxisView*, int> tv = _editor->trackview_by_y_position (iy1);
+		tav[*i] = dynamic_cast<RouteTimeAxisView*> (tv.first);
+	}
+
+	return tav;
+}
+
+
+void
+RegionInsertDrag::finished (GdkEvent* event, bool movement_occurred)
+{
+	_editor->track_canvas->update_now ();
+
+	map<RegionView*, RouteTimeAxisView*> final = find_time_axis_views ();
+	
+	RouteTimeAxisView* dest_rtv = final[_primary];
+
+	_primary->get_canvas_group()->reparent (*dest_rtv->view()->canvas_item());
+	_primary->get_canvas_group()->property_y() = 0;
+
+	boost::shared_ptr<Playlist> playlist = dest_rtv->playlist();
+
+	_editor->begin_reversible_command (_("insert region"));
+	XMLNode& before = playlist->get_state ();
+	playlist->add_region (_primary->region (), _last_frame_position);
+	_editor->session->add_command (new MementoCommand<Playlist> (*playlist, &before, &playlist->get_state()));
+	_editor->commit_reversible_command ();
+
+	delete _primary;
+	_primary = 0;
+	_views.clear ();
+}
+
 RegionSpliceDrag::RegionSpliceDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
 	: RegionMoveDrag (e, i, p, v, false, false)
 {
@@ -1550,10 +1644,9 @@ TrimDrag::finished (GdkEvent* event, bool movement_occurred)
 }
 
 MeterMarkerDrag::MeterMarkerDrag (Editor* e, ArdourCanvas::Item* i, bool c)
-	: Drag (e, i)
+	: Drag (e, i),
+	  _copy (c)
 {
-	_copy = c;
-
 	_marker = reinterpret_cast<MeterMarker*> (_item->get_data ("marker"));
 	assert (_marker);
 }
@@ -1645,10 +1738,9 @@ MeterMarkerDrag::finished (GdkEvent* event, bool movement_occurred)
 }
 
 TempoMarkerDrag::TempoMarkerDrag (Editor* e, ArdourCanvas::Item* i, bool c)
-	: Drag (e, i)
+	: Drag (e, i),
+	  _copy (c)
 {
-	_copy = c;
-
 	TempoMarker* _marker = reinterpret_cast<TempoMarker*> (_item->get_data ("marker"));
 	assert (_marker);
 }
@@ -2731,7 +2823,8 @@ TimeFXDrag::finished (GdkEvent* event, bool movement_occurred)
 
 SelectionDrag::SelectionDrag (Editor* e, ArdourCanvas::Item* i, Operation o)
 	: Drag (e, i),
-	  _operation (o)
+	  _operation (o),
+	  _copy (false)
 {
 
 }
@@ -2944,7 +3037,8 @@ SelectionDrag::finished (GdkEvent* event, bool movement_occurred)
 
 RangeMarkerBarDrag::RangeMarkerBarDrag (Editor* e, ArdourCanvas::Item* i, Operation o)
 	: Drag (e, i),
-	  _operation (o)
+	  _operation (o),
+	  _copy (false)
 {
 	_drag_rect = new ArdourCanvas::SimpleRect (*_editor->time_line_group, 0.0, 0.0, 0.0, _editor->physical_screen_height);
 	_drag_rect->hide ();