rework snap

snap now fills in a struct (MusicFrame) which contins a snapped frame
along with a music divisor.
this gives useful information wrt magnetic snap which may or may not
have rounded to an exact musical position.

region position may now be set musically (using quarter notes for now).

this patch fixes several problems in the current code:

	- dragging a list of music-locked regions now maintains correct
	  musical offsets within the list.

	- splitting regions using magnetic snap works correctly (#7192)

	- cut drag should now work correctly with magnetic snap.

	- musical length of split midi regions is no longer frame based.

17 files changed, 425 insertions, 413 deletions

diff --git a/gtk2_ardour/audio_region_view.cc b/gtk2_ardour/audio_region_view.cc
index 177d0d92e0..ed5665ddb1 100644
--- a/gtk2_ardour/audio_region_view.cc
+++ b/gtk2_ardour/audio_region_view.cc
@@ -1347,11 +1347,10 @@ AudioRegionView::add_gain_point_event (ArdourCanvas::Item *item, GdkEvent *ev, b
 	/* don't create points that can't be seen */
 
 	update_envelope_visibility ();
-
 	framepos_t rpos = region ()->position ();
-	framepos_t fx = trackview.editor().pixel_to_sample (mx) + rpos;
-	trackview.editor ().snap_to_with_modifier (fx, ev);
-	fx -= rpos;
+	MusicFrame snap_pos (trackview.editor().pixel_to_sample (mx) + rpos, 0);
+	trackview.editor ().snap_to_with_modifier (snap_pos, ev);
+	framepos_t fx = snap_pos.frame - rpos;
 
 	if (fx > _region->length()) {
 		return;
diff --git a/gtk2_ardour/automation_time_axis.cc b/gtk2_ardour/automation_time_axis.cc
index 24d4c13903..2634b87891 100644
--- a/gtk2_ardour/automation_time_axis.cc
+++ b/gtk2_ardour/automation_time_axis.cc
@@ -605,7 +605,7 @@ AutomationTimeAxisView::build_display_menu ()
 }
 
 void
-AutomationTimeAxisView::add_automation_event (GdkEvent* event, framepos_t when, double y, bool with_guard_points)
+AutomationTimeAxisView::add_automation_event (GdkEvent* event, framepos_t frame, double y, bool with_guard_points)
 {
 	if (!_line) {
 		return;
@@ -632,16 +632,18 @@ AutomationTimeAxisView::add_automation_event (GdkEvent* event, framepos_t when,
 
 	_line->view_to_model_coord (x, y);
 
+	MusicFrame when (frame, 0);
 	_editor.snap_to_with_modifier (when, event);
 
 	XMLNode& before = list->get_state();
 	std::list<Selectable*> results;
-	if (list->editor_add (when, y, with_guard_points)) {
+
+	if (list->editor_add (when.frame, y, with_guard_points)) {
 		XMLNode& after = list->get_state();
 		_editor.begin_reversible_command (_("add automation event"));
 		_session->add_command (new MementoCommand<ARDOUR::AutomationList> (*list.get (), &before, &after));
 
-		_line->get_selectables (when, when, 0.0, 1.0, results);
+		_line->get_selectables (when.frame, when.frame, 0.0, 1.0, results);
 		_editor.get_selection ().set (results);
 
 		_editor.commit_reversible_command ();
@@ -650,7 +652,7 @@ AutomationTimeAxisView::add_automation_event (GdkEvent* event, framepos_t when,
 }
 
 bool
-AutomationTimeAxisView::paste (framepos_t pos, const Selection& selection, PasteContext& ctx, const int32_t sub_num)
+AutomationTimeAxisView::paste (framepos_t pos, const Selection& selection, PasteContext& ctx, const int32_t divisions)
 {
 	if (_line) {
 		return paste_one (pos, ctx.count, ctx.times, selection, ctx.counts, ctx.greedy);
diff --git a/gtk2_ardour/editor.cc b/gtk2_ardour/editor.cc
index 62ad00a1d9..3ff2d710d0 100644
--- a/gtk2_ardour/editor.cc
+++ b/gtk2_ardour/editor.cc
@@ -2734,7 +2734,7 @@ Editor::trackview_by_y_position (double y, bool trackview_relative_offset) const
  *  @param event Event to get current key modifier information from, or 0.
  */
 void
-Editor::snap_to_with_modifier (framepos_t& start, GdkEvent const * event, RoundMode direction, bool for_mark)
+Editor::snap_to_with_modifier (MusicFrame& start, GdkEvent const * event, RoundMode direction, bool for_mark)
 {
 	if (!_session || !event) {
 		return;
@@ -2743,6 +2743,8 @@ Editor::snap_to_with_modifier (framepos_t& start, GdkEvent const * event, RoundM
 	if (ArdourKeyboard::indicates_snap (event->button.state)) {
 		if (_snap_mode == SnapOff) {
 			snap_to_internal (start, direction, for_mark);
+		} else {
+			start.set (start.frame, 0);
 		}
 	} else {
 		if (_snap_mode != SnapOff) {
@@ -2750,14 +2752,17 @@ Editor::snap_to_with_modifier (framepos_t& start, GdkEvent const * event, RoundM
 		} else if (ArdourKeyboard::indicates_snap_delta (event->button.state)) {
 			/* SnapOff, but we pressed the snap_delta modifier */
 			snap_to_internal (start, direction, for_mark);
+		} else {
+			start.set (start.frame, 0);
 		}
 	}
 }
 
 void
-Editor::snap_to (framepos_t& start, RoundMode direction, bool for_mark, bool ensure_snap)
+Editor::snap_to (MusicFrame& start, RoundMode direction, bool for_mark, bool ensure_snap)
 {
 	if (!_session || (_snap_mode == SnapOff && !ensure_snap)) {
+		start.set (start.frame, 0);
 		return;
 	}
 
@@ -2765,8 +2770,9 @@ Editor::snap_to (framepos_t& start, RoundMode direction, bool for_mark, bool ens
 }
 
 void
-Editor::timecode_snap_to_internal (framepos_t& start, RoundMode direction, bool /*for_mark*/)
+Editor::timecode_snap_to_internal (MusicFrame& pos, RoundMode direction, bool /*for_mark*/)
 {
+	framepos_t start = pos.frame;
 	const framepos_t one_timecode_second = (framepos_t)(rint(_session->timecode_frames_per_second()) * _session->samples_per_timecode_frame());
 	framepos_t one_timecode_minute = (framepos_t)(rint(_session->timecode_frames_per_second()) * _session->samples_per_timecode_frame() * 60);
 
@@ -2828,14 +2834,16 @@ Editor::timecode_snap_to_internal (framepos_t& start, RoundMode direction, bool
 		fatal << "Editor::smpte_snap_to_internal() called with non-timecode snap type!" << endmsg;
 		abort(); /*NOTREACHED*/
 	}
+
+	pos.set (start, 0);
 }
 
 void
-Editor::snap_to_internal (framepos_t& start, RoundMode direction, bool for_mark, bool ensure_snap)
+Editor::snap_to_internal (MusicFrame& start, RoundMode direction, bool for_mark, bool ensure_snap)
 {
 	const framepos_t one_second = _session->frame_rate();
 	const framepos_t one_minute = _session->frame_rate() * 60;
-	framepos_t presnap = start;
+	framepos_t presnap = start.frame;
 	framepos_t before;
 	framepos_t after;
 
@@ -2847,95 +2855,104 @@ Editor::snap_to_internal (framepos_t& start, RoundMode direction, bool for_mark,
 
 	case SnapToCDFrame:
 		if ((direction == RoundUpMaybe || direction == RoundDownMaybe) &&
-		    start % (one_second/75) == 0) {
+		    start.frame % (one_second/75) == 0) {
 			/* start is already on a whole CD frame, do nothing */
-		} else if (((direction == 0) && (start % (one_second/75) > (one_second/75) / 2)) || (direction > 0)) {
-			start = (framepos_t) ceil ((double) start / (one_second / 75)) * (one_second / 75);
+		} else if (((direction == 0) && (start.frame % (one_second/75) > (one_second/75) / 2)) || (direction > 0)) {
+			start.frame = (framepos_t) ceil ((double) start.frame / (one_second / 75)) * (one_second / 75);
 		} else {
-			start = (framepos_t) floor ((double) start / (one_second / 75)) * (one_second / 75);
+			start.frame = (framepos_t) floor ((double) start.frame / (one_second / 75)) * (one_second / 75);
 		}
+
+		start.set (start.frame, 0);
+
 		break;
 
 	case SnapToSeconds:
 		if ((direction == RoundUpMaybe || direction == RoundDownMaybe) &&
-		    start % one_second == 0) {
+		    start.frame % one_second == 0) {
 			/* start is already on a whole second, do nothing */
-		} else if (((direction == 0) && (start % one_second > one_second / 2)) || (direction > 0)) {
-			start = (framepos_t) ceil ((double) start / one_second) * one_second;
+		} else if (((direction == 0) && (start.frame % one_second > one_second / 2)) || (direction > 0)) {
+			start.frame = (framepos_t) ceil ((double) start.frame / one_second) * one_second;
 		} else {
-			start = (framepos_t) floor ((double) start / one_second) * one_second;
+			start.frame = (framepos_t) floor ((double) start.frame / one_second) * one_second;
 		}
+
+		start.set (start.frame, 0);
+
 		break;
 
 	case SnapToMinutes:
 		if ((direction == RoundUpMaybe || direction == RoundDownMaybe) &&
-		    start % one_minute == 0) {
+		    start.frame % one_minute == 0) {
 			/* start is already on a whole minute, do nothing */
-		} else if (((direction == 0) && (start % one_minute > one_minute / 2)) || (direction > 0)) {
-			start = (framepos_t) ceil ((double) start / one_minute) * one_minute;
+		} else if (((direction == 0) && (start.frame % one_minute > one_minute / 2)) || (direction > 0)) {
+			start.frame = (framepos_t) ceil ((double) start.frame / one_minute) * one_minute;
 		} else {
-			start = (framepos_t) floor ((double) start / one_minute) * one_minute;
+			start.frame = (framepos_t) floor ((double) start.frame / one_minute) * one_minute;
 		}
+
+		start.set (start.frame, 0);
+
 		break;
 
 	case SnapToBar:
-		start = _session->tempo_map().round_to_bar (start, direction);
+		start = _session->tempo_map().round_to_bar (start.frame, direction);
 		break;
 
 	case SnapToBeat:
-		start = _session->tempo_map().round_to_beat (start, direction);
+		start = _session->tempo_map().round_to_beat (start.frame, direction);
 		break;
 
 	case SnapToBeatDiv128:
-		start = _session->tempo_map().round_to_quarter_note_subdivision (start, 128, direction);
+		start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 128, direction);
 		break;
 	case SnapToBeatDiv64:
-		start = _session->tempo_map().round_to_quarter_note_subdivision (start, 64, direction);
+		start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 64, direction);
 		break;
 	case SnapToBeatDiv32:
-		start = _session->tempo_map().round_to_quarter_note_subdivision (start, 32, direction);
+		start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 32, direction);
 		break;
 	case SnapToBeatDiv28:
-		start = _session->tempo_map().round_to_quarter_note_subdivision (start, 28, direction);
+		start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 28, direction);
 		break;
 	case SnapToBeatDiv24:
-		start = _session->tempo_map().round_to_quarter_note_subdivision (start, 24, direction);
+		start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 24, direction);
 		break;
 	case SnapToBeatDiv20:
-		start = _session->tempo_map().round_to_quarter_note_subdivision (start, 20, direction);
+		start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 20, direction);
 		break;
 	case SnapToBeatDiv16:
-		start = _session->tempo_map().round_to_quarter_note_subdivision (start, 16, direction);
+		start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 16, direction);
 		break;
 	case SnapToBeatDiv14:
-		start = _session->tempo_map().round_to_quarter_note_subdivision (start, 14, direction);
+		start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 14, direction);
 		break;
 	case SnapToBeatDiv12:
-		start = _session->tempo_map().round_to_quarter_note_subdivision (start, 12, direction);
+		start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 12, direction);
 		break;
 	case SnapToBeatDiv10:
-		start = _session->tempo_map().round_to_quarter_note_subdivision (start, 10, direction);
+		start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 10, direction);
 		break;
 	case SnapToBeatDiv8:
-		start = _session->tempo_map().round_to_quarter_note_subdivision (start, 8, direction);
+		start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 8, direction);
 		break;
 	case SnapToBeatDiv7:
-		start = _session->tempo_map().round_to_quarter_note_subdivision (start, 7, direction);
+		start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 7, direction);
 		break;
 	case SnapToBeatDiv6:
-		start = _session->tempo_map().round_to_quarter_note_subdivision (start, 6, direction);
+		start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 6, direction);
 		break;
 	case SnapToBeatDiv5:
-		start = _session->tempo_map().round_to_quarter_note_subdivision (start, 5, direction);
+		start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 5, direction);
 		break;
 	case SnapToBeatDiv4:
-		start = _session->tempo_map().round_to_quarter_note_subdivision (start, 4, direction);
+		start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 4, direction);
 		break;
 	case SnapToBeatDiv3:
-		start = _session->tempo_map().round_to_quarter_note_subdivision (start, 3, direction);
+		start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 3, direction);
 		break;
 	case SnapToBeatDiv2:
-		start = _session->tempo_map().round_to_quarter_note_subdivision (start, 2, direction);
+		start = _session->tempo_map().round_to_quarter_note_subdivision (start.frame, 2, direction);
 		break;
 
 	case SnapToMark:
@@ -2943,29 +2960,31 @@ Editor::snap_to_internal (framepos_t& start, RoundMode direction, bool for_mark,
 			return;
 		}
 
-		_session->locations()->marks_either_side (start, before, after);
+		_session->locations()->marks_either_side (start.frame, before, after);
 
 		if (before == max_framepos && after == max_framepos) {
 			/* No marks to snap to, so just don't snap */
 			return;
 		} else if (before == max_framepos) {
-			start = after;
+			start.frame = after;
 		} else if (after == max_framepos) {
-			start = before;
+			start.frame = before;
 		} else if (before != max_framepos && after != max_framepos) {
 			if ((direction == RoundUpMaybe || direction == RoundUpAlways))
-				start = after;
+				start.frame = after;
 			else if ((direction == RoundDownMaybe || direction == RoundDownAlways))
-				start = before;
+				start.frame = before;
 			else if (direction ==  0 ) {
-				if ((start - before) < (after - start)) {
-					start = before;
+				if ((start.frame - before) < (after - start.frame)) {
+					start.frame = before;
 				} else {
-					start = after;
+					start.frame = after;
 				}
 			}
 		}
 
+		start.set (start.frame, 0);
+
 		break;
 
 	case SnapToRegionStart:
@@ -2978,9 +2997,9 @@ Editor::snap_to_internal (framepos_t& start, RoundMode direction, bool for_mark,
 			vector<framepos_t>::iterator next = region_boundary_cache.end ();
 
 			if (direction > 0) {
-				next = std::upper_bound (region_boundary_cache.begin(), region_boundary_cache.end(), start);
+				next = std::upper_bound (region_boundary_cache.begin(), region_boundary_cache.end(), start.frame);
 			} else {
-				next = std::lower_bound (region_boundary_cache.begin(), region_boundary_cache.end(), start);
+				next = std::lower_bound (region_boundary_cache.begin(), region_boundary_cache.end(), start.frame);
 			}
 
 			if (next != region_boundary_cache.begin ()) {
@@ -2991,12 +3010,15 @@ Editor::snap_to_internal (framepos_t& start, RoundMode direction, bool for_mark,
 			framepos_t const p = (prev == region_boundary_cache.end()) ? region_boundary_cache.front () : *prev;
 			framepos_t const n = (next == region_boundary_cache.end()) ? region_boundary_cache.back () : *next;
 
-			if (start > (p + n) / 2) {
-				start = n;
+			if (start.frame > (p + n) / 2) {
+				start.frame = n;
 			} else {
-				start = p;
+				start.frame = p;
 			}
 		}
+
+		start.set (start.frame, 0);
+
 		break;
 	}
 
@@ -3010,21 +3032,20 @@ Editor::snap_to_internal (framepos_t& start, RoundMode direction, bool for_mark,
 			return;
 		}
 
-		if (presnap > start) {
-			if (presnap > (start + pixel_to_sample(snap_threshold))) {
-				start = presnap;
+		if (presnap > start.frame) {
+			if (presnap > (start.frame + pixel_to_sample(snap_threshold))) {
+				start.set (presnap, 0);
 			}
 
-		} else if (presnap < start) {
-			if (presnap < (start - pixel_to_sample(snap_threshold))) {
-				start = presnap;
+		} else if (presnap < start.frame) {
+			if (presnap < (start.frame - pixel_to_sample(snap_threshold))) {
+				start.set (presnap, 0);
 			}
 		}
 
 	default:
 		/* handled at entry */
 		return;
-
 	}
 }
 
@@ -4067,9 +4088,9 @@ Editor::get_paste_offset (framepos_t pos, unsigned paste_count, framecnt_t durat
 	framecnt_t offset = paste_count * duration;
 
 	/* snap offset so pos + offset is aligned to the grid */
-	framepos_t offset_pos = pos + offset;
+	MusicFrame offset_pos (pos + offset, 0);
 	snap_to(offset_pos, RoundUpMaybe);
-	offset = offset_pos - pos;
+	offset = offset_pos.frame - pos;
 
 	return offset;
 }
@@ -4740,6 +4761,8 @@ Editor::get_preferred_edit_position (EditIgnoreOption ignore, bool from_context_
 		ep = EditAtPlayhead;
 	}
 
+	MusicFrame snap_mf (0, 0);
+
 	switch (ep) {
 	case EditAtPlayhead:
 		if (_dragging_playhead) {
@@ -4772,7 +4795,9 @@ Editor::get_preferred_edit_position (EditIgnoreOption ignore, bool from_context_
 			/* XXX not right but what can we do ? */
 			return 0;
 		}
-		snap_to (where);
+		snap_mf.frame = where;
+		snap_to (snap_mf);
+		where = snap_mf.frame;
                 DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("GPEP: use mouse @ %1\n", where));
 		break;
 	}
diff --git a/gtk2_ardour/editor.h b/gtk2_ardour/editor.h
index 8ff19580c6..fa5ed9057a 100644
--- a/gtk2_ardour/editor.h
+++ b/gtk2_ardour/editor.h
@@ -452,20 +452,20 @@ class Editor : public PublicEditor, public PBD::ScopedConnectionList, public ARD
 
 	TrackViewList axis_views_from_routes (boost::shared_ptr<ARDOUR::RouteList>) const;
 
-	void snap_to (framepos_t&       first,
-	              ARDOUR::RoundMode direction = ARDOUR::RoundNearest,
-	              bool              for_mark  = false,
-		      bool              ensure_snap = false);
+	void snap_to (ARDOUR::MusicFrame& first,
+	              ARDOUR::RoundMode   direction = ARDOUR::RoundNearest,
+	              bool                for_mark  = false,
+		      bool                ensure_snap = false);
 
-	void snap_to_with_modifier (framepos_t&       first,
-	                            GdkEvent const *  ev,
-	                            ARDOUR::RoundMode direction = ARDOUR::RoundNearest,
-	                            bool              for_mark  = false);
+	void snap_to_with_modifier (ARDOUR::MusicFrame& first,
+	                            GdkEvent const *    ev,
+	                            ARDOUR::RoundMode   direction = ARDOUR::RoundNearest,
+	                            bool                for_mark  = false);
 
-	void snap_to (framepos_t&       first,
-	              framepos_t&       last,
-	              ARDOUR::RoundMode direction = ARDOUR::RoundNearest,
-	              bool              for_mark  = false);
+	void snap_to (ARDOUR::MusicFrame& first,
+	              ARDOUR::MusicFrame& last,
+	              ARDOUR::RoundMode   direction = ARDOUR::RoundNearest,
+	              bool                for_mark  = false);
 
 	void begin_selection_op_history ();
 	void begin_reversible_selection_op (std::string cmd_name);
@@ -542,7 +542,7 @@ class Editor : public PublicEditor, public PBD::ScopedConnectionList, public ARD
 
 	/* editing operations that need to be public */
 	void mouse_add_new_marker (framepos_t where, bool is_cd=false);
-	void split_regions_at (framepos_t, RegionSelection&, const int32_t sub_num, bool snap = true);
+	void split_regions_at (ARDOUR::MusicFrame, RegionSelection&, bool snap = true);
 	void split_region_at_points (boost::shared_ptr<ARDOUR::Region>, ARDOUR::AnalysisFeatureList&, bool can_ferret, bool select_new = false);
 	RegionSelection get_regions_from_selection_and_mouse (framepos_t);
 
@@ -2152,14 +2152,14 @@ class Editor : public PublicEditor, public PBD::ScopedConnectionList, public ARD
 	void select_next_route ();
 	void select_prev_route ();
 
-	void snap_to_internal (framepos_t&       first,
-	                       ARDOUR::RoundMode direction = ARDOUR::RoundNearest,
-	                       bool              for_mark  = false,
-			       bool              ensure_snap = false);
+	void snap_to_internal (ARDOUR::MusicFrame& first,
+	                       ARDOUR::RoundMode   direction = ARDOUR::RoundNearest,
+	                       bool                for_mark  = false,
+			       bool                ensure_snap = false);
 
-	void timecode_snap_to_internal (framepos_t&       first,
-	                                ARDOUR::RoundMode direction = ARDOUR::RoundNearest,
-	                                bool              for_mark  = false);
+	void timecode_snap_to_internal (ARDOUR::MusicFrame& first,
+	                                ARDOUR::RoundMode   direction = ARDOUR::RoundNearest,
+	                                bool                for_mark  = false);
 
 	RhythmFerret* rhythm_ferret;
 
diff --git a/gtk2_ardour/editor_canvas.cc b/gtk2_ardour/editor_canvas.cc
index bc457453bc..f847a3f707 100644
--- a/gtk2_ardour/editor_canvas.cc
+++ b/gtk2_ardour/editor_canvas.cc
@@ -449,7 +449,6 @@ Editor::drop_paths (const RefPtr<Gdk::DragContext>& context,
 {
 	vector<string> paths;
 	GdkEvent ev;
-	framepos_t frame;
 	double cy;
 
 	if (convert_drop_to_paths (paths, context, x, y, data, info, time) == 0) {
@@ -461,9 +460,8 @@ Editor::drop_paths (const RefPtr<Gdk::DragContext>& context,
 		ev.button.x = x;
 		ev.button.y = y;
 
-		frame = window_event_sample (&ev, 0, &cy);
-
-		snap_to (frame);
+		MusicFrame when (window_event_sample (&ev, 0, &cy), 0);
+		snap_to (when);
 
 		bool copy = ((context->get_actions() & (Gdk::ACTION_COPY | Gdk::ACTION_LINK | Gdk::ACTION_MOVE)) == Gdk::ACTION_COPY);
 #ifdef __APPLE__
@@ -471,9 +469,9 @@ Editor::drop_paths (const RefPtr<Gdk::DragContext>& context,
 		   the main event loop with GTK/Quartz. Since import/embed wants
 		   to push up a progress dialog, defer all this till we go idle.
 		*/
-		Glib::signal_idle().connect (sigc::bind (sigc::mem_fun (*this, &Editor::idle_drop_paths), paths, frame, cy, copy));
+		Glib::signal_idle().connect (sigc::bind (sigc::mem_fun (*this, &Editor::idle_drop_paths), paths, when.frame, cy, copy));
 #else
-		drop_paths_part_two (paths, frame, cy, copy);
+		drop_paths_part_two (paths, when.frame, cy, copy);
 #endif
 	}
 
diff --git a/gtk2_ardour/editor_drag.cc b/gtk2_ardour/editor_drag.cc
index 9e763ff264..de3be07c8d 100644
--- a/gtk2_ardour/editor_drag.cc
+++ b/gtk2_ardour/editor_drag.cc
@@ -237,7 +237,7 @@ Drag::Drag (Editor* e, ArdourCanvas::Item* i, bool trackview_only)
 	, _raw_grab_frame (0)
 	, _grab_frame (0)
 	, _last_pointer_frame (0)
-	, _snap_delta (0)
+	, _snap_delta (0, 0)
 	, _constraint_pressed (false)
 {
 
@@ -268,7 +268,7 @@ Drag::start_grab (GdkEvent* event, Gdk::Cursor *cursor)
 	_raw_grab_frame = _editor->canvas_event_sample (event, &_grab_x, &_grab_y);
 
 	setup_pointer_frame_offset ();
-	_grab_frame = adjusted_frame (_raw_grab_frame, event);
+	_grab_frame = adjusted_frame (_raw_grab_frame, event).frame;
 	_last_pointer_frame = _grab_frame;
 	_last_pointer_x = _grab_x;
 
@@ -324,13 +324,13 @@ Drag::end_grab (GdkEvent* event)
 	return _move_threshold_passed;
 }
 
-framepos_t
+MusicFrame
 Drag::adjusted_frame (framepos_t f, GdkEvent const * event, bool snap) const
 {
-	framepos_t pos = 0;
+	MusicFrame pos (f, 0);
 
 	if (f > _pointer_frame_offset) {
-		pos = f - _pointer_frame_offset;
+		pos.frame = f - _pointer_frame_offset;
 	}
 
 	if (snap) {
@@ -343,14 +343,14 @@ Drag::adjusted_frame (framepos_t f, GdkEvent const * event, bool snap) const
 framepos_t
 Drag::adjusted_current_frame (GdkEvent const * event, bool snap) const
 {
-	return adjusted_frame (_drags->current_pointer_frame (), event, snap);
+	return adjusted_frame (_drags->current_pointer_frame (), event, snap).frame;
 }
 
 frameoffset_t
 Drag::snap_delta (guint state) const
 {
 	if (ArdourKeyboard::indicates_snap_delta (state)) {
-		return _snap_delta;
+		return _snap_delta.frame;
 	}
 
 	return 0;
@@ -373,11 +373,11 @@ Drag::current_pointer_y () const
 }
 
 void
-Drag::setup_snap_delta (framepos_t pos)
+Drag::setup_snap_delta (MusicFrame pos)
 {
-	framepos_t temp = pos;
-	_editor->snap_to (temp, ARDOUR::RoundNearest, false, true);
-	_snap_delta = temp - pos;
+	MusicFrame snap (pos);
+	_editor->snap_to (snap, ARDOUR::RoundNearest, false, true);
+	_snap_delta = snap - pos;
 }
 
 bool
@@ -513,7 +513,7 @@ Drag::show_verbose_cursor_text (string const & text)
 }
 
 boost::shared_ptr<Region>
-Drag::add_midi_region (MidiTimeAxisView* view, bool commit, const int32_t sub_num)
+Drag::add_midi_region (MidiTimeAxisView* view, bool commit)
 {
 	if (_editor->session()) {
 		const TempoMap& map (_editor->session()->tempo_map());
@@ -522,7 +522,7 @@ Drag::add_midi_region (MidiTimeAxisView* view, bool commit, const int32_t sub_nu
 		   might be wrong.
 		*/
 		framecnt_t len = map.frame_at_beat (max (0.0, map.beat_at_frame (pos)) + 1.0) - pos;
-		return view->add_region (grab_frame(), len, commit, sub_num);
+		return view->add_region (grab_frame(), len, commit);
 	}
 
 	return boost::shared_ptr<Region>();
@@ -599,33 +599,11 @@ RegionDrag::find_time_axis_view (TimeAxisView* t) const
 	return i;
 }
 
-/** determines if @pos is the closest frame to an exact musical division when using SnapMagnetic.
- *  (SnapMagnetic may snap to an exact division or no division at all).
- *  this is a hotfix for musical region position/trim. we should really
- *  deliver musical divisors when snapping magnetically to avoid this.
-*/
-int32_t
-RegionDrag::current_music_divisor (framepos_t pos, int32_t button_state)
-{
-	int32_t divisions = _editor->get_grid_music_divisions (button_state);
-
-	if (_editor->snap_mode() == Editing::SnapMagnetic && !ArdourKeyboard::indicates_snap (button_state)) {
-		TempoMap& tmap (_editor->session()->tempo_map());
-		const framepos_t exact_qn_pos = tmap.frame_at_quarter_note (tmap.exact_qn_at_frame (pos, divisions));
-
-		if (pos != exact_qn_pos) {
-			/* magnetic has not snapped */
-			divisions = 0;
-		}
-	}
-
-	return divisions;
-}
-
 RegionMotionDrag::RegionMotionDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v, bool b)
 	: RegionDrag (e, i, p, v)
 	, _brushing (b)
 	, _ignore_video_lock (false)
+	, _last_position (0, 0)
 	, _total_x_delta (0)
 	, _last_pointer_time_axis_view (0)
 	, _last_pointer_layer (0)
@@ -640,9 +618,9 @@ void
 RegionMotionDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 {
 	Drag::start_grab (event, cursor);
-	setup_snap_delta (_last_frame_position);
+	setup_snap_delta (_last_position);
 
-	show_verbose_cursor_time (_last_frame_position);
+	show_verbose_cursor_time (_last_position.frame);
 
 	pair<TimeAxisView*, double> const tv = _editor->trackview_by_y_position (current_pointer_y ());
 	if (tv.first) {
@@ -662,14 +640,13 @@ RegionMotionDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 }
 
 double
-RegionMotionDrag::compute_x_delta (GdkEvent const * event, framepos_t* pending_region_position)
+RegionMotionDrag::compute_x_delta (GdkEvent const * event, MusicFrame* pending_region_position)
 {
 	/* compute the amount of pointer motion in frames, and where
 	   the region would be if we moved it by that much.
 	*/
 	*pending_region_position = adjusted_frame (_drags->current_pointer_frame (), event, false);
 
-	framepos_t sync_frame;
 	framecnt_t sync_offset;
 	int32_t sync_dir;
 
@@ -677,34 +654,35 @@ RegionMotionDrag::compute_x_delta (GdkEvent const * event, framepos_t* pending_r
 
 	/* we don't handle a sync point that lies before zero.
 	 */
-	if (sync_dir >= 0 || (sync_dir < 0 && *pending_region_position >= sync_offset)) {
+	if (sync_dir >= 0 || (sync_dir < 0 && pending_region_position->frame >= sync_offset)) {
 
 		framecnt_t const sd = snap_delta (event->button.state);
-		sync_frame = *pending_region_position + (sync_dir * sync_offset) + sd;
-
-		_editor->snap_to_with_modifier (sync_frame, event);
-
-		*pending_region_position = _primary->region()->adjust_to_sync (sync_frame) - sd;
-
+		MusicFrame sync_snap (pending_region_position->frame + (sync_dir * sync_offset) + sd, 0);
+		_editor->snap_to_with_modifier (sync_snap, event);
+		if (sync_offset == 0 && sd == 0) {
+			*pending_region_position = sync_snap;
+		} else {
+			pending_region_position->set (_primary->region()->adjust_to_sync (sync_snap.frame) - sd, 0);
+		}
 	} else {
-		*pending_region_position = _last_frame_position;
+		*pending_region_position = _last_position;
 	}
 
-	if (*pending_region_position > max_framepos - _primary->region()->length()) {
-		*pending_region_position = _last_frame_position;
+	if (pending_region_position->frame > max_framepos - _primary->region()->length()) {
+		*pending_region_position = _last_position;
 	}
 
 	double dx = 0;
 
 	bool const x_move_allowed = !_x_constrained;
 
-	if ((*pending_region_position != _last_frame_position) && x_move_allowed) {
+	if ((pending_region_position->frame != _last_position.frame) && x_move_allowed) {
 
 		/* x movement since last time (in pixels) */
-		dx = (static_cast<double> (*pending_region_position) - _last_frame_position) / _editor->samples_per_pixel;
+		dx = (static_cast<double> (pending_region_position->frame) - _last_position.frame) / _editor->samples_per_pixel;
 
 		/* total x movement */
-		framecnt_t total_dx = *pending_region_position;
+		framecnt_t total_dx = pending_region_position->frame;
 		if (regions_came_from_canvas()) {
 			total_dx = total_dx - grab_frame ();
 		}
@@ -713,7 +691,7 @@ RegionMotionDrag::compute_x_delta (GdkEvent const * event, framepos_t* pending_r
 		for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
 			if ((i->view->region()->position() + total_dx) < 0) {
 				dx = 0;
-				*pending_region_position = _last_frame_position;
+				*pending_region_position = _last_position;
 				break;
 			}
 		}
@@ -954,9 +932,9 @@ RegionMotionDrag::motion (GdkEvent* event, bool first_move)
 	}
 
 	/* Work out the change in x */
-	framepos_t pending_region_position;
+	MusicFrame pending_region_position (0, 0);
 	double const x_delta = compute_x_delta (event, &pending_region_position);
-	_last_frame_position = pending_region_position;
+	_last_position = pending_region_position;
 
 	/* calculate hidden tracks in current y-axis delta */
 	int delta_skip = 0;
@@ -1159,7 +1137,7 @@ RegionMotionDrag::motion (GdkEvent* event, bool first_move)
 			i->layer += this_delta_layer;
 
 			if (_brushing) {
-				_editor->mouse_brush_insert_region (rv, pending_region_position);
+				_editor->mouse_brush_insert_region (rv, pending_region_position.frame);
 			} else {
 				Duple track_origin;
 
@@ -1206,7 +1184,7 @@ RegionMotionDrag::motion (GdkEvent* event, bool first_move)
 	_total_x_delta += x_delta;
 
 	if (x_delta != 0 && !_brushing) {
-		show_verbose_cursor_time (_last_frame_position);
+		show_verbose_cursor_time (_last_position.frame);
 	}
 
 	/* keep track of pointer movement */
@@ -1296,12 +1274,7 @@ RegionMoveDrag::motion (GdkEvent* event, bool first_move)
 			const boost::shared_ptr<const Region> original = rv->region();
 			boost::shared_ptr<Region> region_copy;
 
-			if (rv == _primary) {
-				region_copy = RegionFactory::create (original, true
-								     , current_music_divisor (original->position(), event->button.state));
-			} else {
-				region_copy = RegionFactory::create (original, true, 0);
-			}
+			region_copy = RegionFactory::create (original, true);
 
 			/* need to set this so that the drop zone code can work. This doesn't
 			   actually put the region into the playlist, but just sets a weak pointer
@@ -1399,16 +1372,15 @@ RegionMoveDrag::finished (GdkEvent* ev, bool movement_occurred)
 		i->view->get_canvas_group()->show ();
 	}
 
-	bool const changed_position = (_last_frame_position != _primary->region()->position());
+	bool const changed_position = (_last_position.frame != _primary->region()->position());
 	bool const changed_tracks = (_time_axis_views[_views.front().time_axis_view] != &_views.front().view->get_time_axis_view());
-	framecnt_t const drag_delta = _primary->region()->position() - _last_frame_position;
 
 	if (_copy) {
 
 		finished_copy (
 			changed_position,
 			changed_tracks,
-			drag_delta,
+			_last_position,
 			ev->button.state
 			);
 
@@ -1417,7 +1389,7 @@ RegionMoveDrag::finished (GdkEvent* ev, bool movement_occurred)
 		finished_no_copy (
 			changed_position,
 			changed_tracks,
-			drag_delta,
+			_last_position,
 			ev->button.state
 			);
 
@@ -1462,15 +1434,16 @@ RegionMoveDrag::create_destination_time_axis (boost::shared_ptr<Region> region,
 }
 
 void
-RegionMoveDrag::finished_copy (bool const changed_position, bool const /*changed_tracks*/, framecnt_t const drag_delta, int32_t const ev_state)
+RegionMoveDrag::finished_copy (bool const changed_position, bool const /*changed_tracks*/, MusicFrame last_position, int32_t const ev_state)
 {
 	RegionSelection new_views;
 	PlaylistSet modified_playlists;
 	RouteTimeAxisView* new_time_axis_view = 0;
+	framecnt_t const drag_delta = _primary->region()->position() - _last_position.frame;
 
-	int32_t divisor = current_music_divisor (_primary->region()->position() - drag_delta, ev_state);
 	TempoMap& tmap (_editor->session()->tempo_map());
-	double qn_delta = _primary->region()->quarter_note() - tmap.exact_qn_at_frame (_primary->region()->position() - drag_delta, divisor);
+	const double last_pos_qn = tmap.exact_qn_at_frame (last_position.frame, last_position.division);
+	const double qn_delta = _primary->region()->quarter_note() - last_pos_qn;
 
 	if (_brushing) {
 		/* all changes were made during motion event handlers */
@@ -1495,12 +1468,16 @@ RegionMoveDrag::finished_copy (bool const changed_position, bool const /*changed
 			continue;
 		}
 
-		framepos_t where;
+		MusicFrame where (0, 0);
+		double quarter_note;
 
 		if (changed_position && !_x_constrained) {
-			where = i->view->region()->position() - drag_delta;
+			where.set (i->view->region()->position() - drag_delta, 0);
+			quarter_note = i->view->region()->quarter_note() - qn_delta;
 		} else {
-			where = i->view->region()->position();
+			/* region has not moved - divisor will not affect musical pos */
+			where.set (i->view->region()->position(), 0);
+			quarter_note = i->view->region()->quarter_note();
 		}
 
 		if (i->time_axis_view < 0 || i->time_axis_view >= (int)_time_axis_views.size()) {
@@ -1528,17 +1505,16 @@ RegionMoveDrag::finished_copy (bool const changed_position, bool const /*changed
 
 		if (dest_rtv != 0) {
 			RegionView* new_view;
-			if (i->view == _primary) {
-				new_view = insert_region_into_playlist (i->view->region(), dest_rtv, i->layer, where,
-									modified_playlists, current_music_divisor (where, ev_state));
+			if (i->view == _primary && !_x_constrained) {
+				new_view = insert_region_into_playlist (i->view->region(), dest_rtv, i->layer, last_position, last_pos_qn,
+									modified_playlists, true);
 			} else {
 				if (i->view->region()->position_lock_style() == AudioTime) {
-					new_view = insert_region_into_playlist (i->view->region(), dest_rtv, i->layer, where,
-										modified_playlists, 0);
+					new_view = insert_region_into_playlist (i->view->region(), dest_rtv, i->layer, where, quarter_note,
+										modified_playlists);
 				} else {
-					where = tmap.frame_at_quarter_note (i->view->region()->quarter_note() - qn_delta);
-					new_view = insert_region_into_playlist (i->view->region(), dest_rtv, i->layer, where,
-										modified_playlists, 0);
+					new_view = insert_region_into_playlist (i->view->region(), dest_rtv, i->layer, where, quarter_note,
+										modified_playlists, true);
 				}
 			}
 
@@ -1575,7 +1551,7 @@ void
 RegionMoveDrag::finished_no_copy (
 	bool const changed_position,
 	bool const changed_tracks,
-	framecnt_t const drag_delta,
+	MusicFrame last_position,
 	int32_t const ev_state
 	)
 {
@@ -1584,13 +1560,14 @@ RegionMoveDrag::finished_no_copy (
 	PlaylistSet frozen_playlists;
 	set<RouteTimeAxisView*> views_to_update;
 	RouteTimeAxisView* new_time_axis_view = 0;
+	framecnt_t const drag_delta = _primary->region()->position() - _last_position.frame;
 
 	typedef map<boost::shared_ptr<Playlist>, RouteTimeAxisView*> PlaylistMapping;
 	PlaylistMapping playlist_mapping;
 
-	int32_t divisor = current_music_divisor (_primary->region()->position() - drag_delta, ev_state);
 	TempoMap& tmap (_editor->session()->tempo_map());
-	double qn_delta = _primary->region()->quarter_note() - tmap.exact_qn_at_frame (_primary->region()->position() - drag_delta, divisor);
+	const double last_pos_qn = tmap.exact_qn_at_frame (last_position.frame, last_position.division);
+	const double qn_delta = _primary->region()->quarter_note() - last_pos_qn;
 
 	std::set<boost::shared_ptr<const Region> > uniq;
 	for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ) {
@@ -1640,12 +1617,15 @@ RegionMoveDrag::finished_no_copy (
 
 		views_to_update.insert (dest_rtv);
 
-		framepos_t where;
+		MusicFrame where (0, 0);
+		double quarter_note;
 
 		if (changed_position && !_x_constrained) {
-			where = rv->region()->position() - drag_delta;
+			where.set (rv->region()->position() - drag_delta, 0);
+			quarter_note = i->view->region()->quarter_note() - qn_delta;
 		} else {
-			where = rv->region()->position();
+			where.set (rv->region()->position(), 0);
+			quarter_note = i->view->region()->quarter_note();
 		}
 
 		if (changed_tracks) {
@@ -1654,21 +1634,20 @@ RegionMoveDrag::finished_no_copy (
 			RegionView* new_view;
 			if (rv == _primary) {
 				new_view = insert_region_into_playlist (
-					RegionFactory::create (rv->region (), true), dest_rtv, dest_layer, where,
-					modified_playlists, current_music_divisor (where, ev_state)
+					RegionFactory::create (rv->region (), true), dest_rtv, dest_layer, last_position, last_pos_qn,
+					modified_playlists, true
 					);
 			} else {
 				if (rv->region()->position_lock_style() == AudioTime) {
 
 					new_view = insert_region_into_playlist (
-						RegionFactory::create (rv->region (), true), dest_rtv, dest_layer, where,
-						modified_playlists, 0
+						RegionFactory::create (rv->region (), true), dest_rtv, dest_layer, where, quarter_note,
+						modified_playlists
 						);
 				} else {
-					where = tmap.frame_at_quarter_note (rv->region()->quarter_note() - qn_delta);
 					new_view = insert_region_into_playlist (
-						RegionFactory::create (rv->region (), true), dest_rtv, dest_layer, where,
-						modified_playlists, 0
+						RegionFactory::create (rv->region (), true), dest_rtv, dest_layer, where, quarter_note,
+						modified_playlists, true
 						);
 				}
 			}
@@ -1730,13 +1709,14 @@ RegionMoveDrag::finished_no_copy (
 				playlist->freeze ();
 			}
 			if (rv == _primary) {
-				rv->region()->set_position (where, current_music_divisor (where, ev_state));
+				rv->region()->set_position (where.frame, last_position.division);
 			} else {
 				if (rv->region()->position_lock_style() == AudioTime) {
-					rv->region()->set_position (where, 0);
+					/* move by frame offset */
+					rv->region()->set_position (where.frame, 0);
 				} else {
-					rv->region()->set_position (tmap.frame_at_quarter_note (rv->region()->quarter_note() - qn_delta), 0);
-
+					/* move by music offset */
+					rv->region()->set_position_music (rv->region()->quarter_note() - qn_delta);
 				}
 			}
 			_editor->session()->add_command (new StatefulDiffCommand (rv->region()));
@@ -1838,11 +1818,12 @@ RegionMoveDrag::remove_region_from_playlist (
 RegionView *
 RegionMoveDrag::insert_region_into_playlist (
 	boost::shared_ptr<Region> region,
-	RouteTimeAxisView* dest_rtv,
-	layer_t dest_layer,
-	framecnt_t where,
-	PlaylistSet& modified_playlists,
-	const int32_t sub_num
+	RouteTimeAxisView*        dest_rtv,
+	layer_t                   dest_layer,
+	MusicFrame                where,
+	double                    quarter_note,
+	PlaylistSet&              modified_playlists,
+	bool                      for_music
 	)
 {
 	boost::shared_ptr<Playlist> dest_playlist = dest_rtv->playlist ();
@@ -1859,7 +1840,11 @@ RegionMoveDrag::insert_region_into_playlist (
 	if (r.second) {
 		dest_playlist->clear_changes ();
 	}
-	dest_playlist->add_region (region, where, 1.0, false, sub_num);
+	if (for_music) {
+		dest_playlist->add_region (region, where.frame, 1.0, false, where.division, quarter_note, true);
+	} else {
+		dest_playlist->add_region (region, where.frame, 1.0, false, where.division);
+	}
 
 	if (dest_rtv->view()->layer_display() == Stacked || dest_rtv->view()->layer_display() == Expanded) {
 		dest_playlist->set_layer (region, dest_layer);
@@ -1954,13 +1939,13 @@ RegionMoveDrag::RegionMoveDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p,
 		speed = rtv->track()->speed ();
 	}
 
-	_last_frame_position = static_cast<framepos_t> (_primary->region()->position() / speed);
+	_last_position = MusicFrame (static_cast<framepos_t> (_primary->region()->position() / speed), 0);
 }
 
 void
 RegionMoveDrag::setup_pointer_frame_offset ()
 {
-	_pointer_frame_offset = raw_grab_frame() - _last_frame_position;
+	_pointer_frame_offset = raw_grab_frame() - _last_position.frame;
 }
 
 RegionInsertDrag::RegionInsertDrag (Editor* e, boost::shared_ptr<Region> r, RouteTimeAxisView* v, framepos_t pos)
@@ -1977,7 +1962,7 @@ RegionInsertDrag::RegionInsertDrag (Editor* e, boost::shared_ptr<Region> r, Rout
 	_primary->set_position (pos, 0);
 	_views.push_back (DraggingView (_primary, this, v));
 
-	_last_frame_position = pos;
+	_last_position = MusicFrame (pos, 0);
 
 	_item = _primary->get_canvas_group ();
 }
@@ -1997,11 +1982,11 @@ RegionInsertDrag::finished (GdkEvent * event, bool)
 
 	_editor->begin_reversible_command (Operations::insert_region);
 	playlist->clear_changes ();
-	playlist->add_region (_primary->region (), _last_frame_position);
+	playlist->add_region (_primary->region (), _last_position.frame, _editor->get_grid_music_divisions (event->button.state));
 
 	// Mixbus doesn't seem to ripple when inserting regions from the list: should we? yes, probably
 	if (Config->get_edit_mode() == Ripple) {
-		playlist->ripple (_last_frame_position, _primary->region()->length(), _primary->region());
+		playlist->ripple (_last_position.frame, _primary->region()->length(), _primary->region());
 	}
 
 	_editor->session()->add_command (new StatefulDiffCommand (playlist));
@@ -2278,7 +2263,7 @@ RegionRippleDrag::motion (GdkEvent* event, bool first_move)
 
 	framepos_t where = adjusted_current_frame (event);
 	assert (where >= 0);
-	framepos_t after;
+	MusicFrame after (0, 0);
 	double delta = compute_x_delta (event, &after);
 
 	framecnt_t amount = _editor->pixel_to_sample (delta);
@@ -2328,7 +2313,7 @@ RegionRippleDrag::motion (GdkEvent* event, bool first_move)
 		prev_amount += amount;
 	}
 
-	_last_frame_position = after;
+	_last_position = after;
 }
 
 void
@@ -2409,7 +2394,7 @@ RegionCreateDrag::motion (GdkEvent* event, bool first_move)
 {
 	if (first_move) {
 		_editor->begin_reversible_command (_("create region"));
-		_region = add_midi_region (_view, false, _editor->get_grid_music_divisions (event->button.state));
+		_region = add_midi_region (_view, false);
 		_view->playlist()->freeze ();
 	} else {
 		if (_region) {
@@ -2435,7 +2420,7 @@ void
 RegionCreateDrag::finished (GdkEvent* event, bool movement_occurred)
 {
 	if (!movement_occurred) {
-		add_midi_region (_view, true, _editor->get_grid_music_divisions (event->button.state));
+		add_midi_region (_view, true);
 	} else {
 		_view->playlist()->thaw ();
 		_editor->commit_reversible_command();
@@ -2867,7 +2852,7 @@ TrimDrag::start_grab (GdkEvent* event, Gdk::Cursor*)
 	framecnt_t const region_length = (framecnt_t) (_primary->region()->length() / speed);
 
 	framepos_t const pf = adjusted_current_frame (event);
-	setup_snap_delta (region_start);
+	setup_snap_delta (MusicFrame (region_start, 0));
 
 	if (Keyboard::modifier_state_equals (event->button.state, ArdourKeyboard::trim_contents_modifier ())) {
 		/* Move the contents of the region around without changing the region bounds */
@@ -2930,8 +2915,8 @@ TrimDrag::motion (GdkEvent* event, bool first_move)
 	if (tv && tv->is_track()) {
 		speed = tv->track()->speed();
 	}
-	framecnt_t adj_frame = adjusted_frame (_drags->current_pointer_frame () + snap_delta (event->button.state), event, true);
-	framecnt_t dt = adj_frame - raw_grab_frame () + _pointer_frame_offset - snap_delta (event->button.state);
+	MusicFrame adj_frame = adjusted_frame (_drags->current_pointer_frame () + snap_delta (event->button.state), event, true);
+	framecnt_t dt = adj_frame.frame - raw_grab_frame () + _pointer_frame_offset - snap_delta (event->button.state);
 
 	if (first_move) {
 
@@ -3012,13 +2997,11 @@ TrimDrag::motion (GdkEvent* event, bool first_move)
 		}
 	}
 
-	int32_t divisions = current_music_divisor (adj_frame, event->button.state);
-
 	switch (_operation) {
 	case StartTrim:
 		for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
 			bool changed = i->view->trim_front (i->initial_position + dt, non_overlap_trim
-							    , divisions);
+							    , adj_frame.division);
 
 			if (changed && _preserve_fade_anchor) {
 				AudioRegionView* arv = dynamic_cast<AudioRegionView*> (i->view);
@@ -3037,7 +3020,7 @@ TrimDrag::motion (GdkEvent* event, bool first_move)
 
 	case EndTrim:
 		for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
-			bool changed = i->view->trim_end (i->initial_end + dt, non_overlap_trim, divisions);
+			bool changed = i->view->trim_end (i->initial_end + dt, non_overlap_trim, adj_frame.division);
 			if (changed && _preserve_fade_anchor) {
 				AudioRegionView* arv = dynamic_cast<AudioRegionView*> (i->view);
 				if (arv) {
@@ -3156,7 +3139,7 @@ TrimDrag::finished (GdkEvent* event, bool movement_occurred)
 
 	} else {
 		/* no mouse movement */
-		if (adjusted_current_frame (event) != adjusted_frame (_drags->current_pointer_frame(), event, false)) {
+		if (adjusted_current_frame (event) != adjusted_frame (_drags->current_pointer_frame(), event, false).frame) {
 			_editor->point_trim (event, adjusted_current_frame (event));
 		}
 	}
@@ -3648,14 +3631,14 @@ void
 CursorDrag::start_grab (GdkEvent* event, Gdk::Cursor* c)
 {
 	Drag::start_grab (event, c);
-	setup_snap_delta (_editor->playhead_cursor->current_frame ());
+	const framepos_t current_frame = _editor->playhead_cursor->current_frame();
+	setup_snap_delta (MusicFrame (current_frame, 0));
 
 	_grab_zoom = _editor->samples_per_pixel;
 
-	framepos_t where = _editor->canvas_event_sample (event) + snap_delta (event->button.state);
+	MusicFrame where (_editor->canvas_event_sample (event) + snap_delta (event->button.state), 0);
 
 	_editor->snap_to_with_modifier (where, event);
-
 	_editor->_dragging_playhead = true;
 
 	Session* s = _editor->session ();
@@ -3690,16 +3673,18 @@ CursorDrag::start_grab (GdkEvent* event, Gdk::Cursor* c)
 		}
 	}
 
-	fake_locate (where - snap_delta (event->button.state));
+	fake_locate (where.frame - snap_delta (event->button.state));
 }
 
 void
 CursorDrag::motion (GdkEvent* event, bool)
 {
-	framepos_t where = _editor->canvas_event_sample (event) + snap_delta (event->button.state);
+	MusicFrame where (_editor->canvas_event_sample (event) + snap_delta (event->button.state), 0);
+
 	_editor->snap_to_with_modifier (where, event);
-	if (where != last_pointer_frame()) {
-		fake_locate (where - snap_delta (event->button.state));
+
+	if (where.frame != last_pointer_frame()) {
+		fake_locate (where.frame - snap_delta (event->button.state));
 	}
 }
 
@@ -3734,7 +3719,7 @@ CursorDrag::aborted (bool)
 		_editor->_dragging_playhead = false;
 	}
 
-	_editor->playhead_cursor->set_position (adjusted_frame (grab_frame (), 0, false));
+	_editor->playhead_cursor->set_position (adjusted_frame (grab_frame (), 0, false).frame);
 }
 
 FadeInDrag::FadeInDrag (Editor* e, ArdourCanvas::Item* i, RegionView* p, list<RegionView*> const & v)
@@ -3750,7 +3735,8 @@ FadeInDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 
 	AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
 	boost::shared_ptr<AudioRegion> const r = arv->audio_region ();
-	setup_snap_delta (r->position ());
+	const int32_t division = _editor->get_grid_music_divisions (event->button.state);
+	setup_snap_delta (MusicFrame (r->position(), division));
 
 	show_verbose_cursor_duration (r->position(), r->position() + r->fade_in()->back()->when, 32);
 }
@@ -3768,18 +3754,19 @@ FadeInDrag::motion (GdkEvent* event, bool)
 {
 	framecnt_t fade_length;
 
-	framepos_t pos = _editor->canvas_event_sample (event) + snap_delta (event->button.state);
+	MusicFrame pos (_editor->canvas_event_sample (event) + snap_delta (event->button.state), 0);
 	_editor->snap_to_with_modifier (pos, event);
-	pos -= snap_delta (event->button.state);
+
+	pos.frame -= snap_delta (event->button.state);
 
 	boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (_primary->region ());
 
-	if (pos < (region->position() + 64)) {
+	if (pos.frame < (region->position() + 64)) {
 		fade_length = 64; // this should be a minimum defined somewhere
-	} else if (pos > region->position() + region->length() - region->fade_out()->back()->when) {
+	} else if (pos.frame > region->position() + region->length() - region->fade_out()->back()->when) {
 		fade_length = region->length() - region->fade_out()->back()->when - 1;
 	} else {
-		fade_length = pos - region->position();
+		fade_length = pos.frame - region->position();
 	}
 
 	for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
@@ -3804,18 +3791,19 @@ FadeInDrag::finished (GdkEvent* event, bool movement_occurred)
 	}
 
 	framecnt_t fade_length;
-	framepos_t pos = _editor->canvas_event_sample (event) + snap_delta (event->button.state);
+	MusicFrame pos (_editor->canvas_event_sample (event) + snap_delta (event->button.state), 0);
+
 	_editor->snap_to_with_modifier (pos, event);
-	pos -= snap_delta (event->button.state);
+	pos.frame -= snap_delta (event->button.state);
 
 	boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (_primary->region ());
 
-	if (pos < (region->position() + 64)) {
+	if (pos.frame < (region->position() + 64)) {
 		fade_length = 64; // this should be a minimum defined somewhere
-	} else if (pos >= region->position() + region->length() - region->fade_out()->back()->when) {
+	} else if (pos.frame >= region->position() + region->length() - region->fade_out()->back()->when) {
 		fade_length = region->length() - region->fade_out()->back()->when - 1;
 	} else {
-		fade_length = pos - region->position();
+		fade_length = pos.frame - region->position();
 	}
 
 	bool in_command = false;
@@ -3874,7 +3862,8 @@ FadeOutDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 
 	AudioRegionView* arv = dynamic_cast<AudioRegionView*> (_primary);
 	boost::shared_ptr<AudioRegion> r = arv->audio_region ();
-	setup_snap_delta (r->last_frame ());
+	const int32_t division = _editor->get_grid_music_divisions (event->button.state);
+	setup_snap_delta (MusicFrame (r->last_frame(), division));
 
 	show_verbose_cursor_duration (r->last_frame() - r->fade_out()->back()->when, r->last_frame());
 }
@@ -3891,19 +3880,19 @@ void
 FadeOutDrag::motion (GdkEvent* event, bool)
 {
 	framecnt_t fade_length;
+	MusicFrame pos (_editor->canvas_event_sample (event) + snap_delta (event->button.state), 0);
 
-	framepos_t pos = _editor->canvas_event_sample (event) + snap_delta (event->button.state);
 	_editor->snap_to_with_modifier (pos, event);
-	pos -= snap_delta (event->button.state);
+	pos.frame -= snap_delta (event->button.state);
 
 	boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (_primary->region ());
 
-	if (pos > (region->last_frame() - 64)) {
+	if (pos.frame > (region->last_frame() - 64)) {
 		fade_length = 64; // this should really be a minimum fade defined somewhere
-	} else if (pos <= region->position() + region->fade_in()->back()->when) {
+	} else if (pos.frame <= region->position() + region->fade_in()->back()->when) {
 		fade_length = region->length() - region->fade_in()->back()->when - 1;
 	} else {
-		fade_length = region->last_frame() - pos;
+		fade_length = region->last_frame() - pos.frame;
 	}
 
 	for (list<DraggingView>::iterator i = _views.begin(); i != _views.end(); ++i) {
@@ -3928,19 +3917,19 @@ FadeOutDrag::finished (GdkEvent* event, bool movement_occurred)
 	}
 
 	framecnt_t fade_length;
+	MusicFrame pos (_editor->canvas_event_sample (event) + snap_delta (event->button.state), 0);
 
-	framepos_t pos = _editor->canvas_event_sample (event) + snap_delta (event->button.state);
 	_editor->snap_to_with_modifier (pos, event);
-	pos -= snap_delta (event->button.state);
+	pos.frame -= snap_delta (event->button.state);
 
 	boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (_primary->region ());
 
-	if (pos > (region->last_frame() - 64)) {
+	if (pos.frame > (region->last_frame() - 64)) {
 		fade_length = 64; // this should really be a minimum fade defined somewhere
-	} else if (pos <= region->position() + region->fade_in()->back()->when) {
+	} else if (pos.frame <= region->position() + region->fade_in()->back()->when) {
 		fade_length = region->length() - region->fade_in()->back()->when - 1;
 	} else {
-		fade_length = region->last_frame() - pos;
+		fade_length = region->last_frame() - pos.frame;
 	}
 
 	bool in_command = false;
@@ -4035,7 +4024,9 @@ MarkerDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 	} else {
 		show_verbose_cursor_time (location->end());
 	}
-	setup_snap_delta (is_start ? location->start() : location->end());
+	const int32_t division = _editor->get_grid_music_divisions (event->button.state);
+	const framepos_t pos = is_start ? location->start() : location->end();
+	setup_snap_delta (MusicFrame (pos, division));
 
 	Selection::Operation op = ArdourKeyboard::selection_type (event->button.state);
 
@@ -4139,7 +4130,7 @@ MarkerDrag::motion (GdkEvent* event, bool)
 	Location *copy_location = 0;
 	framecnt_t const sd = snap_delta (event->button.state);
 
-	framecnt_t const newframe = adjusted_frame (_drags->current_pointer_frame () + sd, event, true) - sd;
+	framecnt_t const newframe = adjusted_frame (_drags->current_pointer_frame () + sd, event, true).frame - sd;
 	framepos_t next = newframe;
 
 	if (Keyboard::modifier_state_contains (event->button.state, ArdourKeyboard::push_points_modifier ())) {
@@ -4422,8 +4413,9 @@ ControlPointDrag::start_grab (GdkEvent* event, Gdk::Cursor* /*cursor*/)
 	_fixed_grab_x = _point->get_x() + _editor->sample_to_pixel_unrounded (_point->line().offset());
 	_fixed_grab_y = _point->get_y();
 
-	framepos_t pos = _editor->pixel_to_sample (_fixed_grab_x);
-	setup_snap_delta (pos);
+	const framepos_t pos = _editor->pixel_to_sample (_fixed_grab_x);
+	const int32_t division = _editor->get_grid_music_divisions (event->button.state);
+	setup_snap_delta (MusicFrame (pos, division));
 
 	float const fraction = 1 - (_point->get_y() / _point->line().height());
 	show_verbose_cursor_text (_point->line().get_verbose_cursor_string (fraction));
@@ -4476,13 +4468,14 @@ ControlPointDrag::motion (GdkEvent* event, bool first_motion)
 		cy = zero_gain_y;
 	}
 
-	framepos_t cx_frames = _editor->pixel_to_sample (cx) + snap_delta (event->button.state);
+	MusicFrame cx_mf (_editor->pixel_to_sample (cx) + snap_delta (event->button.state), 0);
+
 	if (!_x_constrained && need_snap) {
-		_editor->snap_to_with_modifier (cx_frames, event);
+		_editor->snap_to_with_modifier (cx_mf, event);
 	}
 
-	cx_frames -= snap_delta (event->button.state);
-	cx_frames = min (cx_frames, _point->line().maximum_time() + _point->line().offset());
+	cx_mf.frame -= snap_delta (event->button.state);
+	cx_mf.frame = min (cx_mf.frame, _point->line().maximum_time() + _point->line().offset());
 
 	float const fraction = 1.0 - (cy / _point->line().height());
 
@@ -4492,7 +4485,7 @@ ControlPointDrag::motion (GdkEvent* event, bool first_motion)
 		_point->line().start_drag_single (_point, _fixed_grab_x, initial_fraction);
 	}
 	pair<double, float> result;
-	result = _point->line().drag_motion (_editor->sample_to_pixel_unrounded (cx_frames), fraction, false, _pushing, _final_index);
+	result = _point->line().drag_motion (_editor->sample_to_pixel_unrounded (cx_mf.frame), fraction, false, _pushing, _final_index);
 
 	show_verbose_cursor_text (_point->line().get_verbose_cursor_string (result.second));
 }
@@ -4755,24 +4748,23 @@ RubberbandSelectDrag::motion (GdkEvent* event, bool)
 	framepos_t end;
 	double y1;
 	double y2;
-
 	framepos_t const pf = adjusted_current_frame (event, UIConfiguration::instance().get_rubberbanding_snaps_to_grid());
+	MusicFrame grab (grab_frame (), 0);
 
-	framepos_t grab = grab_frame ();
 	if (UIConfiguration::instance().get_rubberbanding_snaps_to_grid ()) {
 		_editor->snap_to_with_modifier (grab, event);
 	} else {
-		grab = raw_grab_frame ();
+		grab.frame = raw_grab_frame ();
 	}
 
 	/* base start and end on initial click position */
 
-	if (pf < grab) {
+	if (pf < grab.frame) {
 		start = pf;
-		end = grab;
+		end = grab.frame;
 	} else {
 		end = pf;
-		start = grab;
+		start = grab.frame;
 	}
 
 	if (current_pointer_y() < grab_y()) {
@@ -4882,7 +4874,7 @@ RubberbandSelectDrag::finished (GdkEvent* event, bool movement_occurred)
 			/* MIDI track */
 			if (_editor->selection->empty() && _editor->mouse_mode == MouseDraw) {
 				/* nothing selected */
-				add_midi_region (mtv, true, _editor->get_grid_music_divisions(event->button.state));
+				add_midi_region (mtv, true);
 				do_deselect = false;
 			}
 		}
@@ -4922,7 +4914,8 @@ TimeFXDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
 	_editor->get_selection().add (_primary);
 
 	framepos_t where = _primary->region()->position();
-	setup_snap_delta (where);
+	const int32_t division = _editor->get_grid_music_divisions (event->button.state);
+	setup_snap_delta (MusicFrame (where, division));
 
 	show_verbose_cursor_duration (where, adjusted_current_frame (event), 0);
 }
@@ -4932,19 +4925,19 @@ TimeFXDrag::motion (GdkEvent* event, bool)
 {
 	RegionView* rv = _primary;
 	StreamView* cv = rv->get_time_axis_view().view ();
-
 	pair<TimeAxisView*, double> const tv = _editor->trackview_by_y_position (grab_y());
 	int layer = tv.first->layer_display() == Overlaid ? 0 : tv.second;
 	int layers = tv.first->layer_display() == Overlaid ? 1 : cv->layers();
-	framepos_t pf = _editor->canvas_event_sample (event) + snap_delta (event->button.state);
+	MusicFrame pf (_editor->canvas_event_sample (event) + snap_delta (event->button.state), 0);
+
 	_editor->snap_to_with_modifier (pf, event);
-	pf -= snap_delta (event->button.state);
+	pf.frame -= snap_delta (event->button.state);
 
-	if (pf > rv->region()->position()) {
-		rv->get_time_axis_view().show_timestretch (rv->region()->position(), pf, layers, layer);
+	if (pf.frame > rv->region()->position()) {
+		rv->get_time_axis_view().show_timestretch (rv->region()->position(), pf.frame, layers, layer);
 	}
 
-	show_verbose_cursor_duration (_primary->region()->position(), pf, 0);
+	show_verbose_cursor_duration (_primary->region()->position(), pf.frame, 0);
 }
 
 void
@@ -5128,7 +5121,7 @@ SelectionDrag::motion (GdkEvent* event, bool first_move)
 	framepos_t end = 0;
 	framecnt_t length = 0;
 	framecnt_t distance = 0;
-
+	MusicFrame start_mf (0, 0);
 	framepos_t const pending_position = adjusted_current_frame (event);
 
 	if (_operation != CreateSelection && pending_position == last_pointer_frame()) {
@@ -5142,23 +5135,22 @@ SelectionDrag::motion (GdkEvent* event, bool first_move)
 	switch (_operation) {
 	case CreateSelection:
 	{
-		framepos_t grab = grab_frame ();
-
+		MusicFrame grab (grab_frame (), 0);
 		if (first_move) {
-			grab = adjusted_current_frame (event, false);
-			if (grab < pending_position) {
+			grab.frame = adjusted_current_frame (event, false);
+			if (grab.frame < pending_position) {
 				_editor->snap_to (grab, RoundDownMaybe);
 			}  else {
 				_editor->snap_to (grab, RoundUpMaybe);
 			}
 		}
 
-		if (pending_position < grab) {
+		if (pending_position < grab.frame) {
 			start = pending_position;
-			end = grab;
+			end = grab.frame;
 		} else {
 			end = pending_position;
-			start = grab;
+			start = grab.frame;
 		}
 
 		/* first drag: Either add to the selection
@@ -5269,9 +5261,11 @@ SelectionDrag::motion (GdkEvent* event, bool first_move)
 		length = end - start;
 		distance = pending_position - start;
 		start = pending_position;
-		_editor->snap_to (start);
 
-		end = start + length;
+		start_mf.frame = start;
+		_editor->snap_to (start_mf);
+
+		end = start_mf.frame + length;
 
 		break;
 
@@ -5466,15 +5460,15 @@ RangeMarkerBarDrag::motion (GdkEvent* event, bool first_move)
 	framepos_t const pf = adjusted_current_frame (event);
 
 	if (_operation == CreateSkipMarker || _operation == CreateRangeMarker || _operation == CreateTransportMarker || _operation == CreateCDMarker) {
-		framepos_t grab = grab_frame ();
+		MusicFrame grab (grab_frame (), 0);
 		_editor->snap_to (grab);
 
 		if (pf < grab_frame()) {
 			start = pf;
-			end = grab;
+			end = grab.frame;
 		} else {
 			end = pf;
-			start = grab;
+			start = grab.frame;
 		}
 
 		/* first drag: Either add to the selection
@@ -5653,7 +5647,7 @@ NoteDrag::start_grab (GdkEvent* event, Gdk::Cursor *)
 		_copy = false;
 	}
 
-	setup_snap_delta (_region->source_beats_to_absolute_frames (_primary->note()->time ()));
+	setup_snap_delta (MusicFrame (_region->source_beats_to_absolute_frames (_primary->note()->time ()), 0));
 
 	if (!(_was_selected = _primary->selected())) {
 
@@ -6616,10 +6610,10 @@ RegionCutDrag::start_grab (GdkEvent* event, Gdk::Cursor* c)
 void
 RegionCutDrag::motion (GdkEvent* event, bool)
 {
-	framepos_t pos = _drags->current_pointer_frame();
+	MusicFrame pos (_drags->current_pointer_frame(), 0);
 	_editor->snap_to_with_modifier (pos, event);
 
-	line->set_position (pos);
+	line->set_position (pos.frame);
 }
 
 void
@@ -6627,19 +6621,18 @@ RegionCutDrag::finished (GdkEvent* event, bool)
 {
 	_editor->get_track_canvas()->canvas()->re_enter();
 
-	framepos_t pos = _drags->current_pointer_frame();
-	_editor->snap_to_with_modifier (pos, event);
 
+	MusicFrame pos (_drags->current_pointer_frame(), 0);
+	_editor->snap_to_with_modifier (pos, event);
 	line->hide ();
 
-	RegionSelection rs = _editor->get_regions_from_selection_and_mouse (pos);
+	RegionSelection rs = _editor->get_regions_from_selection_and_mouse (pos.frame);
 
 	if (rs.empty()) {
 		return;
 	}
 
-	_editor->split_regions_at (pos, rs, _editor->get_grid_music_divisions (event->button.state),
-	                           false);
+	_editor->split_regions_at (pos, rs, false);
 }
 
 void
diff --git a/gtk2_ardour/editor_drag.h b/gtk2_ardour/editor_drag.h
index b5ebc3b39d..e5a02743fc 100644
--- a/gtk2_ardour/editor_drag.h
+++ b/gtk2_ardour/editor_drag.h
@@ -144,7 +144,7 @@ public:
 	bool motion_handler (GdkEvent*, bool);
 	void abort ();
 
-	ARDOUR::framepos_t adjusted_frame (ARDOUR::framepos_t, GdkEvent const *, bool snap = true) const;
+	ARDOUR::MusicFrame adjusted_frame (ARDOUR::framepos_t, GdkEvent const *, bool snap = true) const;
 	ARDOUR::framepos_t adjusted_current_frame (GdkEvent const *, bool snap = true) const;
 
         bool was_double_click() const { return _was_double_click; }
@@ -247,9 +247,9 @@ protected:
 	double current_pointer_y () const;
 
 	/* sets snap delta from unsnapped pos */
-	void setup_snap_delta (framepos_t pos);
+	void setup_snap_delta (ARDOUR::MusicFrame pos);
 
-	boost::shared_ptr<ARDOUR::Region> add_midi_region (MidiTimeAxisView*, bool commit, const int32_t sub_num);
+	boost::shared_ptr<ARDOUR::Region> add_midi_region (MidiTimeAxisView*, bool commit);
 
 	void show_verbose_cursor_time (framepos_t);
 	void show_verbose_cursor_duration (framepos_t, framepos_t, double xoffset = 0);
@@ -281,7 +281,7 @@ private:
 	/* difference between some key position's snapped and unsnapped
 	 *  framepos. used for relative snap.
 	 */
-	ARDOUR::frameoffset_t _snap_delta;
+	ARDOUR::MusicFrame _snap_delta;
 	CursorContext::Handle _cursor_ctx; ///< cursor change context
 	bool _constraint_pressed; ///< if the keyboard indicated constraint modifier was pressed on start_grab()
 };
@@ -328,7 +328,6 @@ protected:
 	std::vector<TimeAxisView*> _time_axis_views;
 	int find_time_axis_view (TimeAxisView *) const;
 	int apply_track_delta (const int start, const int delta, const int skip, const bool distance_only = false) const;
-	int32_t current_music_divisor (framepos_t pos, int32_t button_state);
 
 	int _visible_y_low;
 	int _visible_y_high;
@@ -363,12 +362,12 @@ public:
 
 protected:
 
-	double compute_x_delta (GdkEvent const *, ARDOUR::framepos_t *);
+	double compute_x_delta (GdkEvent const *, ARDOUR::MusicFrame *);
 	virtual bool y_movement_allowed (int, double, int skip_invisible = 0) const;
 
 	bool _brushing;
 	bool _ignore_video_lock;
-	ARDOUR::framepos_t _last_frame_position; ///< last position of the thing being dragged
+	ARDOUR::MusicFrame _last_position; ///< last position of the thing being dragged
 	double _total_x_delta;
 	int _last_pointer_time_axis_view;
 	double _last_pointer_layer;
@@ -410,14 +409,14 @@ private:
 	void finished_no_copy (
 		bool const,
 		bool const,
-		ARDOUR::framecnt_t const,
+		ARDOUR::MusicFrame,
 		int32_t const ev_state
 		);
 
 	void finished_copy (
 		bool const,
 		bool const,
-		ARDOUR::framecnt_t const,
+		ARDOUR::MusicFrame,
 		int32_t const ev_state
 		);
 
@@ -425,9 +424,10 @@ private:
 		boost::shared_ptr<ARDOUR::Region>,
 		RouteTimeAxisView*,
 		ARDOUR::layer_t,
-		ARDOUR::framecnt_t,
+		ARDOUR::MusicFrame,
+		double quarter_note,
 		PlaylistSet&,
-		const int32_t sub_num
+		bool for_music = false
 		);
 
 	void remove_region_from_playlist (
diff --git a/gtk2_ardour/editor_keys.cc b/gtk2_ardour/editor_keys.cc
index fba52014bc..2c64d6f4f3 100644
--- a/gtk2_ardour/editor_keys.cc
+++ b/gtk2_ardour/editor_keys.cc
@@ -43,9 +43,8 @@ Editor::keyboard_selection_finish (bool /*add*/, Editing::EditIgnoreOption ign)
 {
 	if (_session) {
 
-		framepos_t start = selection->time.start();
+		MusicFrame start (selection->time.start(), 0);
 		framepos_t end;
-
 		if ((_edit_point == EditAtPlayhead) && _session->transport_rolling()) {
 			end = _session->audible_frame();
 		} else {
@@ -53,13 +52,13 @@ Editor::keyboard_selection_finish (bool /*add*/, Editing::EditIgnoreOption ign)
 		}
 
 		//snap the selection start/end
-		snap_to(start);
+		snap_to (start);
 
 		//if no tracks are selected and we're working from the keyboard, enable all tracks (_something_ has to be selected for any range selection)
 		if ( (_edit_point == EditAtPlayhead) && selection->tracks.empty() )
 			select_all_tracks();
 
-		selection->set (start, end);
+		selection->set (start.frame, end);
 
 		//if session is playing a range, cancel that
 		if (_session->get_play_range())
@@ -73,26 +72,25 @@ Editor::keyboard_selection_begin (Editing::EditIgnoreOption ign)
 {
 	if (_session) {
 
-		framepos_t start;
-		framepos_t end = selection->time.end_frame();
-
+		MusicFrame start (0, 0);
+		MusicFrame end (selection->time.end_frame(), 0);
 		if ((_edit_point == EditAtPlayhead) && _session->transport_rolling()) {
-			start = _session->audible_frame();
+			start.frame = _session->audible_frame();
 		} else {
-			start = get_preferred_edit_position(ign);
+			start.frame = get_preferred_edit_position(ign);
 		}
 
 		//snap the selection start/end
 		snap_to(start);
 
 		//if there's not already a sensible selection endpoint, go "forever"
-		if (start > end) {
+		if (start.frame > end.frame) {
 #ifdef MIXBUS
 			// 4hours at most.
 			// This works around a visual glitch in red-bordered selection rect.
-			end = start + _session->nominal_frame_rate() * 60 * 60 * 4;
+			end.frame = start.frame + _session->nominal_frame_rate() * 60 * 60 * 4;
 #else
-			end = max_framepos;
+			end.frame = max_framepos;
 #endif
 		}
 
@@ -100,7 +98,7 @@ Editor::keyboard_selection_begin (Editing::EditIgnoreOption ign)
 		if ( selection->tracks.empty() )
 			select_all_tracks();
 
-		selection->set (start, end);
+		selection->set (start.frame, end.frame);
 
 		//if session is playing a range, cancel that
 		if (_session->get_play_range())
diff --git a/gtk2_ardour/editor_mouse.cc b/gtk2_ardour/editor_mouse.cc
index 8e1ef327ab..d5bf07bd78 100644
--- a/gtk2_ardour/editor_mouse.cc
+++ b/gtk2_ardour/editor_mouse.cc
@@ -1269,9 +1269,9 @@ Editor::button_press_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemTyp
 	    UIConfiguration::instance().get_follow_edits() && 
 	    !_session->config.get_external_sync()) {
 
-		framepos_t where = canvas_event_sample (event);
-		snap_to(where);
-		_session->request_locate (where, false);
+		MusicFrame where (canvas_event_sample (event), 0);
+		snap_to (where);
+		_session->request_locate (where.frame, false);
 	}
 
 	switch (event->button.button) {
@@ -1318,7 +1318,7 @@ Editor::button_release_dispatch (GdkEventButton* ev)
 bool
 Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
 {
-	framepos_t where = canvas_event_sample (event);
+	MusicFrame where (canvas_event_sample (event), 0);
 	AutomationTimeAxisView* atv = 0;
 
 	_press_cursor_ctx.reset();
@@ -1466,7 +1466,7 @@ Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemT
 			case SamplesRulerItem:
 			case MinsecRulerItem:
 			case BBTRulerItem:
-				popup_ruler_menu (where, item_type);
+				popup_ruler_menu (where.frame, item_type);
 				break;
 
 			case MarkerItem:
@@ -1558,7 +1558,7 @@ Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemT
 		case MarkerBarItem:
 			if (!_dragging_playhead) {
 				snap_to_with_modifier (where, event, RoundNearest, true);
-				mouse_add_new_marker (where);
+				mouse_add_new_marker (where.frame);
 			}
 			return true;
 
@@ -1566,14 +1566,14 @@ Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemT
 			if (!_dragging_playhead) {
 				// if we get here then a dragged range wasn't done
 				snap_to_with_modifier (where, event, RoundNearest, true);
-				mouse_add_new_marker (where, true);
+				mouse_add_new_marker (where.frame, true);
 			}
 			return true;
 		case TempoBarItem:
 		case TempoCurveItem:
 			if (!_dragging_playhead) {
 				snap_to_with_modifier (where, event);
-				mouse_add_new_tempo_event (where);
+				mouse_add_new_tempo_event (where.frame);
 			}
 			return true;
 
@@ -1617,7 +1617,7 @@ Editor::button_release_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemT
 				bool with_guard_points = Keyboard::modifier_state_equals (event->button.state, Keyboard::PrimaryModifier);
 				atv = dynamic_cast<AutomationTimeAxisView*>(clicked_axisview);
 				if (atv) {
-					atv->add_automation_event (event, where, event->button.y, with_guard_points);
+					atv->add_automation_event (event, where.frame, event->button.y, with_guard_points);
 				}
 				return true;
 				break;
diff --git a/gtk2_ardour/editor_ops.cc b/gtk2_ardour/editor_ops.cc
index 4df88b9025..288d12219f 100644
--- a/gtk2_ardour/editor_ops.cc
+++ b/gtk2_ardour/editor_ops.cc
@@ -166,8 +166,7 @@ Editor::redo (uint32_t n)
 }
 
 void
-Editor::split_regions_at (framepos_t where, RegionSelection& regions, const int32_t sub_num,
-                          bool snap_frame)
+Editor::split_regions_at (MusicFrame where, RegionSelection& regions, bool snap_frame)
 {
 	bool frozen = false;
 
@@ -214,7 +213,7 @@ Editor::split_regions_at (framepos_t where, RegionSelection& regions, const int3
 		   have something to split.
 		*/
 
-		if (!(*a)->region()->covers (where)) {
+		if (!(*a)->region()->covers (where.frame)) {
 			++a;
 			continue;
 		}
@@ -246,7 +245,7 @@ Editor::split_regions_at (framepos_t where, RegionSelection& regions, const int3
 
 		if (pl) {
 			pl->clear_changes ();
-			pl->split_region ((*a)->region(), where, sub_num);
+			pl->split_region ((*a)->region(), where);
 			_session->add_command (new StatefulDiffCommand (pl));
 		}
 
@@ -292,7 +291,7 @@ Editor::split_regions_at (framepos_t where, RegionSelection& regions, const int3
 		}
 
 		for (RegionSelection::iterator ri = latest_regionviews.begin(); ri != latest_regionviews.end(); ri++) {
-			if ((*ri)->region()->position() < where) {
+			if ((*ri)->region()->position() < where.frame) {
 				// new regions created before the split
 				if (rsas & NewlyCreatedLeft) {
 					selection->add (*ri);
@@ -4260,7 +4259,7 @@ Editor::cut_copy_points (Editing::CutCopyOp op, Evoral::Beats earliest, bool mid
 		}
 
 		/* Add all selected points to the relevant copy ControlLists */
-		framepos_t start = std::numeric_limits<framepos_t>::max();
+		MusicFrame start (std::numeric_limits<framepos_t>::max(), 0);
 		for (PointSelection::iterator sel_point = selection->points.begin(); sel_point != selection->points.end(); ++sel_point) {
 			boost::shared_ptr<AutomationList>    al = (*sel_point)->line().the_list();
 			AutomationList::const_iterator ctrl_evt = (*sel_point)->model ();
@@ -4271,7 +4270,7 @@ Editor::cut_copy_points (Editing::CutCopyOp op, Evoral::Beats earliest, bool mid
 				earliest = std::min(earliest, Evoral::Beats((*ctrl_evt)->when));
 			} else {
 				/* Update earliest session start time in frames */
-				start = std::min(start, (*sel_point)->line().session_position(ctrl_evt));
+				start.frame = std::min(start.frame, (*sel_point)->line().session_position(ctrl_evt));
 			}
 		}
 
@@ -4282,13 +4281,13 @@ Editor::cut_copy_points (Editing::CutCopyOp op, Evoral::Beats earliest, bool mid
 			}
 			earliest.round_down_to_beat();
 		} else {
-			if (start == std::numeric_limits<double>::max()) {
-				start = 0;  // Weird... don't offset
+			if (start.frame == std::numeric_limits<double>::max()) {
+				start.frame = 0;  // Weird... don't offset
 			}
 			snap_to(start, RoundDownMaybe);
 		}
 
-		const double line_offset = midi ? earliest.to_double() : start;
+		const double line_offset = midi ? earliest.to_double() : start.frame;
 		for (Lists::iterator i = lists.begin(); i != lists.end(); ++i) {
 			/* Correct this copy list so that it is relative to the earliest
 			   start time, so relative ordering between points is preserved
@@ -4691,22 +4690,21 @@ void
 Editor::paste (float times, bool from_context)
 {
         DEBUG_TRACE (DEBUG::CutNPaste, "paste to preferred edit pos\n");
-
-	paste_internal (get_preferred_edit_position (EDIT_IGNORE_NONE, from_context), times, get_grid_music_divisions (0));
+	MusicFrame where (get_preferred_edit_position (EDIT_IGNORE_NONE, from_context), 0);
+	paste_internal (where.frame, times, 0);
 }
 
 void
 Editor::mouse_paste ()
 {
-	framepos_t where;
+	MusicFrame where (0, 0);
 	bool ignored;
-
-	if (!mouse_frame (where, ignored)) {
+	if (!mouse_frame (where.frame, ignored)) {
 		return;
 	}
 
 	snap_to (where);
-	paste_internal (where, 1, get_grid_music_divisions (0));
+	paste_internal (where.frame, 1, where.division);
 }
 
 void
@@ -6171,10 +6169,10 @@ Editor::update_region_fade_visibility ()
 void
 Editor::set_edit_point ()
 {
-	framepos_t where;
 	bool ignored;
+	MusicFrame where (0, 0);
 
-	if (!mouse_frame (where, ignored)) {
+	if (!mouse_frame (where.frame, ignored)) {
 		return;
 	}
 
@@ -6182,7 +6180,7 @@ Editor::set_edit_point ()
 
 	if (selection->markers.empty()) {
 
-		mouse_add_new_marker (where);
+		mouse_add_new_marker (where.frame);
 
 	} else {
 		bool ignored;
@@ -6190,7 +6188,7 @@ Editor::set_edit_point ()
 		Location* loc = find_location_from_marker (selection->markers.front(), ignored);
 
 		if (loc) {
-			loc->move_to (where, get_grid_music_divisions(0));
+			loc->move_to (where.frame, where.division);
 		}
 	}
 }
@@ -6201,17 +6199,17 @@ Editor::set_playhead_cursor ()
 	if (entered_marker) {
 		_session->request_locate (entered_marker->position(), _session->transport_rolling());
 	} else {
-		framepos_t where;
+		MusicFrame where (0, 0);
 		bool ignored;
 
-		if (!mouse_frame (where, ignored)) {
+		if (!mouse_frame (where.frame, ignored)) {
 			return;
 		}
 
 		snap_to (where);
 
 		if (_session) {
-			_session->request_locate (where, _session->transport_rolling());
+			_session->request_locate (where.frame, _session->transport_rolling());
 		}
 	}
 
@@ -6239,18 +6237,16 @@ Editor::split_region ()
 	if (current_mouse_mode() == MouseObject) {  //don't try this for Internal Edit, Stretch, Draw, etc.
 
 		RegionSelection rs = get_regions_from_selection_and_edit_point ();
-
-		framepos_t where = get_preferred_edit_position ();
+		const framepos_t pos = get_preferred_edit_position();
+		const int32_t division = get_grid_music_divisions (0);
+		MusicFrame where (pos, division);
 
 		if (rs.empty()) {
 			return;
 		}
 
-		if (snap_musical()) {
-			split_regions_at (where, rs, get_grid_music_divisions (0));
-		} else {
-			split_regions_at (where, rs, 0);
-		}
+		split_regions_at (where, rs);
+
 	}
 }
 
@@ -6458,7 +6454,7 @@ Editor::set_punch_start_from_edit_point ()
 {
 	if (_session) {
 
-		framepos_t start = 0;
+		MusicFrame start (0, 0);
 		framepos_t end = max_framepos;
 
 		//use the existing punch end, if any
@@ -6468,20 +6464,20 @@ Editor::set_punch_start_from_edit_point ()
 		}
 
 		if ((_edit_point == EditAtPlayhead) && _session->transport_rolling()) {
-			start = _session->audible_frame();
+			start.frame = _session->audible_frame();
 		} else {
-			start = get_preferred_edit_position();
+			start.frame = get_preferred_edit_position();
 		}
 
 		//snap the selection start/end
 		snap_to(start);
 
 		//if there's not already a sensible selection endpoint, go "forever"
-		if ( start > end ) {
+		if (start.frame > end ) {
 			end = max_framepos;
 		}
 
-		set_punch_range (start, end, _("set punch start from EP"));
+		set_punch_range (start.frame, end, _("set punch start from EP"));
 	}
 
 }
@@ -6492,7 +6488,7 @@ Editor::set_punch_end_from_edit_point ()
 	if (_session) {
 
 		framepos_t start = 0;
-		framepos_t end = max_framepos;
+		MusicFrame end (max_framepos, 0);
 
 		//use the existing punch start, if any
 		Location* tpl = transport_punch_location();
@@ -6501,15 +6497,15 @@ Editor::set_punch_end_from_edit_point ()
 		}
 
 		if ((_edit_point == EditAtPlayhead) && _session->transport_rolling()) {
-			end = _session->audible_frame();
+			end.frame = _session->audible_frame();
 		} else {
-			end = get_preferred_edit_position();
+			end.frame = get_preferred_edit_position();
 		}
 
 		//snap the selection start/end
-		snap_to(end);
+		snap_to (end);
 
-		set_punch_range (start, end, _("set punch end from EP"));
+		set_punch_range (start, end.frame, _("set punch end from EP"));
 
 	}
 }
@@ -6519,7 +6515,7 @@ Editor::set_loop_start_from_edit_point ()
 {
 	if (_session) {
 
-		framepos_t start = 0;
+		MusicFrame start (0, 0);
 		framepos_t end = max_framepos;
 
 		//use the existing loop end, if any
@@ -6529,20 +6525,20 @@ Editor::set_loop_start_from_edit_point ()
 		}
 
 		if ((_edit_point == EditAtPlayhead) && _session->transport_rolling()) {
-			start = _session->audible_frame();
+			start.frame = _session->audible_frame();
 		} else {
-			start = get_preferred_edit_position();
+			start.frame = get_preferred_edit_position();
 		}
 
 		//snap the selection start/end
-		snap_to(start);
+		snap_to (start);
 
 		//if there's not already a sensible selection endpoint, go "forever"
-		if ( start > end ) {
+		if (start.frame > end ) {
 			end = max_framepos;
 		}
 
-		set_loop_range (start, end, _("set loop start from EP"));
+		set_loop_range (start.frame, end, _("set loop start from EP"));
 	}
 
 }
@@ -6553,7 +6549,7 @@ Editor::set_loop_end_from_edit_point ()
 	if (_session) {
 
 		framepos_t start = 0;
-		framepos_t end = max_framepos;
+		MusicFrame end (max_framepos, 0);
 
 		//use the existing loop start, if any
 		Location* tpl = transport_loop_location();
@@ -6562,15 +6558,15 @@ Editor::set_loop_end_from_edit_point ()
 		}
 
 		if ((_edit_point == EditAtPlayhead) && _session->transport_rolling()) {
-			end = _session->audible_frame();
+			end.frame = _session->audible_frame();
 		} else {
-			end = get_preferred_edit_position();
+			end.frame = get_preferred_edit_position();
 		}
 
 		//snap the selection start/end
 		snap_to(end);
 
-		set_loop_range (start, end, _("set loop end from EP"));
+		set_loop_range (start, end.frame, _("set loop end from EP"));
 	}
 }
 
@@ -6985,9 +6981,9 @@ Editor::snap_regions_to_grid ()
 			pl->freeze();
 		}
 
-		framepos_t start_frame = (*r)->region()->first_frame ();
-		snap_to (start_frame);
-		(*r)->region()->set_position (start_frame);
+		MusicFrame start ((*r)->region()->first_frame (), 0);
+		snap_to (start);
+		(*r)->region()->set_position (start.frame, start.division);
 	}
 
 	while (used_playlists.size() > 0) {
@@ -7187,11 +7183,12 @@ Editor::playhead_forward_to_grid ()
 		return;
 	}
 
-	framepos_t pos = playhead_cursor->current_frame ();
-	if (pos < max_framepos - 1) {
-		pos += 2;
+	MusicFrame pos (playhead_cursor->current_frame (), 0);
+
+	if (pos.frame < max_framepos - 1) {
+		pos.frame += 2;
 		snap_to_internal (pos, RoundUpAlways, false);
-		_session->request_locate (pos);
+		_session->request_locate (pos.frame);
 	}
 }
 
@@ -7203,11 +7200,12 @@ Editor::playhead_backward_to_grid ()
 		return;
 	}
 
-	framepos_t pos = playhead_cursor->current_frame ();
-	if (pos > 2) {
-		pos -= 2;
+	MusicFrame pos  (playhead_cursor->current_frame (), 0);
+
+	if (pos.frame > 2) {
+		pos.frame -= 2;
 		snap_to_internal (pos, RoundDownAlways, false);
-		_session->request_locate (pos);
+		_session->request_locate (pos.frame);
 	}
 }
 
@@ -7472,7 +7470,7 @@ Editor::insert_time (
 
 			if (opt == SplitIntersected) {
 				/* non musical split */
-				(*i)->split (pos, 0);
+				(*i)->split (MusicFrame (pos, 0));
 			}
 
 			(*i)->shift (pos, frames, (opt == MoveIntersected), ignore_music_glue);
diff --git a/gtk2_ardour/midi_region_view.cc b/gtk2_ardour/midi_region_view.cc
index 397ee66cf5..195cc6f828 100644
--- a/gtk2_ardour/midi_region_view.cc
+++ b/gtk2_ardour/midi_region_view.cc
@@ -3426,21 +3426,20 @@ MidiRegionView::nudge_notes (bool forward, bool fine)
 
 		/* use grid */
 
-		framepos_t next_pos = ref_point;
-
+		MusicFrame next_pos (ref_point, 0);
 		if (forward) {
-			if (max_framepos - 1 < next_pos) {
-				next_pos += 1;
+			if (max_framepos - 1 < next_pos.frame) {
+				next_pos.frame += 1;
 			}
 		} else {
-			if (next_pos == 0) {
+			if (next_pos.frame == 0) {
 				return;
 			}
-			next_pos -= 1;
+			next_pos.frame -= 1;
 		}
 
 		trackview.editor().snap_to (next_pos, (forward ? RoundUpAlways : RoundDownAlways), false);
-		const framecnt_t distance = ref_point - next_pos;
+		const framecnt_t distance = ref_point - next_pos.frame;
 		delta = region_frames_to_region_beats (fabs ((double)distance));
 	}
 
diff --git a/gtk2_ardour/midi_time_axis.cc b/gtk2_ardour/midi_time_axis.cc
index 6bbc813eb2..00764d0b78 100644
--- a/gtk2_ardour/midi_time_axis.cc
+++ b/gtk2_ardour/midi_time_axis.cc
@@ -1646,9 +1646,11 @@ MidiTimeAxisView::automation_child_menu_item (Evoral::Parameter param)
 }
 
 boost::shared_ptr<MidiRegion>
-MidiTimeAxisView::add_region (framepos_t pos, framecnt_t length, bool commit, const int32_t sub_num)
+MidiTimeAxisView::add_region (framepos_t f, framecnt_t length, bool commit)
 {
 	Editor* real_editor = dynamic_cast<Editor*> (&_editor);
+	MusicFrame pos (f, 0);
+
 	if (commit) {
 		real_editor->begin_reversible_command (Operations::create_region);
 	}
@@ -1665,8 +1667,8 @@ MidiTimeAxisView::add_region (framepos_t pos, framecnt_t length, bool commit, co
 
 	boost::shared_ptr<Region> region = (RegionFactory::create (src, plist));
 	/* sets beat position */
-	region->set_position (pos, sub_num);
-	playlist()->add_region (region, pos, 1.0, false, sub_num);
+	region->set_position (pos.frame, pos.division);
+	playlist()->add_region (region, pos.frame, 1.0, false, pos.division);
 	_session->add_command (new StatefulDiffCommand (playlist()));
 
 	if (commit) {
diff --git a/gtk2_ardour/midi_time_axis.h b/gtk2_ardour/midi_time_axis.h
index a75c965413..ac953c8f96 100644
--- a/gtk2_ardour/midi_time_axis.h
+++ b/gtk2_ardour/midi_time_axis.h
@@ -83,7 +83,7 @@ public:
 
 	void set_height (uint32_t, TrackHeightMode m = OnlySelf);
 
-	boost::shared_ptr<ARDOUR::MidiRegion> add_region (ARDOUR::framepos_t, ARDOUR::framecnt_t, bool, const int32_t sub_num);
+	boost::shared_ptr<ARDOUR::MidiRegion> add_region (ARDOUR::framepos_t, ARDOUR::framecnt_t, bool);
 
 	void show_all_automation (bool apply_to_selection = false);
 	void show_existing_automation (bool apply_to_selection = false);
diff --git a/gtk2_ardour/public_editor.h b/gtk2_ardour/public_editor.h
index a63cd049b3..7516d48099 100644
--- a/gtk2_ardour/public_editor.h
+++ b/gtk2_ardour/public_editor.h
@@ -148,10 +148,10 @@ class PublicEditor : public Gtkmm2ext::Tabbable {
 	 * Snap a value according to the current snap setting.
 	 * ensure_snap overrides SnapOff and magnetic snap
 	 */
-	virtual void snap_to (framepos_t&       first,
-	                      ARDOUR::RoundMode direction = ARDOUR::RoundNearest,
-	                      bool              for_mark  = false,
-			      bool              ensure_snap = false) = 0;
+	virtual void snap_to (ARDOUR::MusicFrame& first,
+	                      ARDOUR::RoundMode   direction = ARDOUR::RoundNearest,
+	                      bool                for_mark  = false,
+			      bool                ensure_snap = false) = 0;
 
 	/** Undo some transactions.
 	 * @param n Number of transactions to undo.
@@ -320,7 +320,7 @@ class PublicEditor : public Gtkmm2ext::Tabbable {
 	virtual void restore_editing_space () = 0;
 	virtual framepos_t get_preferred_edit_position (Editing::EditIgnoreOption = Editing::EDIT_IGNORE_NONE, bool from_context_menu = false, bool from_outside_canvas = false) = 0;
 	virtual void toggle_meter_updating() = 0;
-	virtual void split_regions_at (framepos_t, RegionSelection&, const int32_t sub_num, bool snap) = 0;
+	virtual void split_regions_at (ARDOUR::MusicFrame, RegionSelection&, bool snap) = 0;
 	virtual void split_region_at_points (boost::shared_ptr<ARDOUR::Region>, ARDOUR::AnalysisFeatureList&, bool can_ferret, bool select_new = false) = 0;
 	virtual void mouse_add_new_marker (framepos_t where, bool is_cd=false) = 0;
 	virtual void foreach_time_axis_view (sigc::slot<void,TimeAxisView&>) = 0;
@@ -435,10 +435,10 @@ class PublicEditor : public Gtkmm2ext::Tabbable {
 	virtual ARDOUR::Location* find_location_from_marker (ArdourMarker *, bool &) const = 0;
 	virtual ArdourMarker* find_marker_from_location_id (PBD::ID const &, bool) const = 0;
 
-	virtual void snap_to_with_modifier (framepos_t &      first,
-	                                    GdkEvent const *  ev,
-	                                    ARDOUR::RoundMode direction = ARDOUR::RoundNearest,
-	                                    bool              for_mark  = false) = 0;
+	virtual void snap_to_with_modifier (ARDOUR::MusicFrame& first,
+	                                    GdkEvent const *    ev,
+	                                    ARDOUR::RoundMode   direction = ARDOUR::RoundNearest,
+	                                    bool                for_mark  = false) = 0;
 
 	virtual void get_regions_at (RegionSelection &, framepos_t where, TrackViewList const &) const = 0;
 	virtual void get_regions_after (RegionSelection&, framepos_t where, const TrackViewList& ts) const = 0;
diff --git a/gtk2_ardour/region_view.cc b/gtk2_ardour/region_view.cc
index cc9a5b61ce..9f6ff645ce 100644
--- a/gtk2_ardour/region_view.cc
+++ b/gtk2_ardour/region_view.cc
@@ -947,20 +947,19 @@ frameoffset_t
 RegionView::snap_frame_to_frame (frameoffset_t x, bool ensure_snap) const
 {
 	PublicEditor& editor = trackview.editor();
-
 	/* x is region relative, convert it to global absolute frames */
 	framepos_t const session_frame = x + _region->position();
 
 	/* try a snap in either direction */
-	framepos_t frame = session_frame;
+	MusicFrame frame (session_frame, 0);
 	editor.snap_to (frame, RoundNearest, false, ensure_snap);
 
 	/* if we went off the beginning of the region, snap forwards */
-	if (frame < _region->position ()) {
-		frame = session_frame;
+	if (frame.frame < _region->position ()) {
+		frame.frame = session_frame;
 		editor.snap_to (frame, RoundUpAlways, false, ensure_snap);
 	}
 
 	/* back to region relative */
-	return frame - _region->position();
+	return frame.frame - _region->position();
 }
diff --git a/gtk2_ardour/step_editor.cc b/gtk2_ardour/step_editor.cc
index c45c0f4461..ac51076a46 100644
--- a/gtk2_ardour/step_editor.cc
+++ b/gtk2_ardour/step_editor.cc
@@ -116,13 +116,12 @@ StepEditor::prepare_step_edit_region ()
 	} else {
 
 		const Meter& m = _mtv.session()->tempo_map().meter_at_frame (step_edit_insert_position);
-
 		double baf = max (0.0, _mtv.session()->tempo_map().beat_at_frame (step_edit_insert_position));
 		double next_bar_in_beats =  baf + m.divisions_per_bar();
 		framecnt_t next_bar_pos = _mtv.session()->tempo_map().frame_at_beat (next_bar_in_beats);
 		framecnt_t len = next_bar_pos - step_edit_insert_position;
 
-		step_edit_region = _mtv.add_region (step_edit_insert_position, len, true, _editor.get_grid_music_divisions (0));
+		step_edit_region = _mtv.add_region (step_edit_insert_position, len, true);
 
 		RegionView* rv = _mtv.midi_view()->find_view (step_edit_region);
 		step_edit_region_view = dynamic_cast<MidiRegionView*>(rv);
@@ -411,7 +410,7 @@ StepEditor::step_edit_bar_sync ()
 	}
 
 	framepos_t fpos = step_edit_region_view->region_beats_to_absolute_frames (step_edit_beat_pos);
-	fpos = _session->tempo_map().round_to_bar (fpos, RoundUpAlways);
+	fpos = _session->tempo_map().round_to_bar (fpos, RoundUpAlways).frame;
 	step_edit_beat_pos = step_edit_region_view->region_frames_to_region_beats (fpos - step_edit_region->position()).round_up_to_beat();
 	step_edit_region_view->move_step_edit_cursor (step_edit_beat_pos);
 }
diff --git a/gtk2_ardour/tempo_dialog.cc b/gtk2_ardour/tempo_dialog.cc
index f08fb10dda..0b9a071d7d 100644
--- a/gtk2_ardour/tempo_dialog.cc
+++ b/gtk2_ardour/tempo_dialog.cc
@@ -423,7 +423,7 @@ TempoDialog::tap_tempo_focus_out (GdkEventFocus* )
 MeterDialog::MeterDialog (TempoMap& map, framepos_t frame, const string&)
 	: ArdourDialog (_("New Meter"))
 {
-	frame = map.round_to_bar(frame, RoundNearest);
+	frame = map.round_to_bar(frame, RoundNearest).frame;
 	Timecode::BBT_Time when (map.bbt_at_frame (frame));
 	Meter meter (map.meter_at_frame (frame));