push2:small logic fix for destructor, mostly to ensure that the track_mix layout...

[ardour.git] / gtk2_ardour / editor_drag.cc

diff --git a/gtk2_ardour/editor_drag.cc b/gtk2_ardour/editor_drag.cc
index 98ccf4a6a28f05e2aae5d854847eda8af1546f18..f7b75a5855dee56e32f4991e194bba91b26ccebb 100644 (file)
--- a/gtk2_ardour/editor_drag.cc
+++ b/gtk2_ardour/editor_drag.cc
@@ -3087,10 +3087,11 @@ TrimDrag::aborted (bool movement_occurred)
           behind which may be slightly odd from the user's point of view.
        */
 
-       finished (0, true);
+       GdkEvent ev;
+       finished (&ev, true);
 
        if (movement_occurred) {
-               _editor->undo ();
+               _editor->session()->undo (1);
        }
 
        for (list<DraggingView>::const_iterator i = _views.begin(); i != _views.end(); ++i) {
@@ -3355,11 +3356,21 @@ TempoMarkerDrag::motion (GdkEvent* event, bool first_move)
                show_verbose_cursor_text (strs.str());
 
        } else if (_movable && !_real_section->locked_to_meter()) {
-               const framepos_t pf = adjusted_current_frame (event);
+               framepos_t pf;
+
+               if (_editor->snap_musical()) {
+                       /* we can't snap to a grid that we are about to move.
+                        * gui_move_tempo() will sort out snap using the supplied beat divisions.
+                       */
+                       pf = adjusted_current_frame (event, false);
+               } else {
+                       pf = adjusted_current_frame (event);
+               }
+
                TempoMap& map (_editor->session()->tempo_map());
 
                /* snap to beat is 1, snap to bar is -1 (sorry) */
-               int sub_num = _editor->get_grid_music_divisions (event->button.state);
+               const int sub_num = _editor->get_grid_music_divisions (event->button.state);
 
                map.gui_move_tempo (_real_section, pf, sub_num);
 
@@ -5567,12 +5578,14 @@ NoteDrag::total_dx (const guint state) const
        if (_x_constrained) {
                return 0;
        }
+       TempoMap& map (_editor->session()->tempo_map());
 
        /* dx in frames */
        frameoffset_t const dx = _editor->pixel_to_sample (_drags->current_pointer_x() - grab_x());
 
        /* primary note time */
-       frameoffset_t const n = _region->source_beats_to_absolute_frames (_primary->note()->time ());
+       double const quarter_note_start = map.quarter_note_at_beat (_region->region()->beat() - _region->midi_region()->start_beats().to_double());
+       frameoffset_t const n = map.frame_at_quarter_note (quarter_note_start + _primary->note()->time().to_double());
 
        /* new time of the primary note in session frames */
        frameoffset_t st = n + dx + snap_delta (state);
@@ -6172,18 +6185,33 @@ NoteCreateDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
        Drag::start_grab (event, cursor);
 
        _drag_rect = new ArdourCanvas::Rectangle (_region_view->get_canvas_group ());
+       TempoMap& map (_editor->session()->tempo_map());
 
-       framepos_t pf = _drags->current_pointer_frame ();
-       framecnt_t const g = grid_frames (pf);
+       const framepos_t pf = _drags->current_pointer_frame ();
+       const int32_t divisions = _editor->get_grid_music_divisions (event->button.state);
 
-       /* Hack so that we always snap to the note that we are over, instead of snapping
-          to the next one if we're more than halfway through the one we're over.
-       */
-       if (_editor->snap_mode() == SnapNormal && pf > g / 2) {
-               pf -= g / 2;
+       double eqaf = map.exact_qn_at_frame (pf, divisions);
+
+       if (divisions != 0) {
+               bool success = false;
+               Evoral::Beats grid_beats = _editor->get_grid_type_as_beats (success, pf);
+               if (!success) {
+                       grid_beats = Evoral::Beats(1);
+               }
+
+               const double qaf = map.quarter_note_at_frame (pf);
+
+               /* Hack so that we always snap to the note that we are over, instead of snapping
+                  to the next one if we're more than halfway through the one we're over.
+               */
+
+               const double rem = eqaf - qaf;
+               if (rem >= 0.0 && eqaf - grid_beats.to_double() > _region_view->region()->pulse() * 4.0) {
+                       eqaf -= grid_beats.to_double();
+               }
        }
 
-       _note[0] = adjusted_frame (pf, event) - _region_view->region()->position ();
+       _note[0] = map.frame_at_quarter_note (eqaf) - _region_view->region()->position();
        _note[1] = _note[0];
 
        MidiStreamView* sv = _region_view->midi_stream_view ();
@@ -6207,26 +6235,28 @@ NoteCreateDrag::motion (GdkEvent* event, bool)
 }
 
 void
-NoteCreateDrag::finished (GdkEvent*, bool had_movement)
+NoteCreateDrag::finished (GdkEvent* ev, bool had_movement)
 {
        if (!had_movement) {
                return;
        }
 
        framepos_t const start = min (_note[0], _note[1]);
+       framepos_t const start_sess_rel = start + _region_view->region()->position();
        framecnt_t length = (framecnt_t) fabs ((double)(_note[0] - _note[1]));
 
        framecnt_t const g = grid_frames (start);
        Evoral::Beats const one_tick = Evoral::Beats::ticks(1);
 
-       if (_editor->snap_mode() == SnapNormal && length < g) {
+       if (_editor->get_grid_music_divisions (ev->button.state) != 0 && length < g) {
                length = g;
        }
 
-       Evoral::Beats length_beats = max (
-               one_tick, _region_view->region_frames_to_region_beats (length) - one_tick);
+       TempoMap& map (_editor->session()->tempo_map());
+       const double qn_length = map.quarter_note_at_frame (start_sess_rel + length) - map.quarter_note_at_frame (start_sess_rel);
 
-       _region_view->create_note_at (start, _drag_rect->y0(), length_beats, false);
+       Evoral::Beats qn_length_beats = max (one_tick, Evoral::Beats (qn_length));
+       _region_view->create_note_at (start, _drag_rect->y0(), qn_length_beats, ev->button.state, false);
 }
 
 double