decouple midi region note range and height from midi streamview.

	- this allows a midi region drag to update the visible notes
	  correctly while crossing MIDI streamviews with a differing
	  note range.
	  as a side effect, fixes a bug where changing
	  note range on a track did not draw some notes
	  (apply_note_range redisplays the model).

diff --git a/gtk2_ardour/editor_drag.cc b/gtk2_ardour/editor_drag.cc
index 6f5723086ed0e95fc09fcbeea4b299e81fc7fae3..018c8c1f382f740506a5b3d566f278988dc6bdf7 100644 (file)
--- a/gtk2_ardour/editor_drag.cc
+++ b/gtk2_ardour/editor_drag.cc
@@ -1122,6 +1122,10 @@ RegionMotionDrag::motion (GdkEvent* event, bool first_move)
                                y_delta = yposition - rv->get_canvas_group()->canvas_origin().y;
                        }
 
+                       MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(rv);
+                       if (mrv) {
+                               mrv->apply_note_range (60, 71, true);
+                       }
                } else {
 
                        /* The TimeAxisView that this region is now over */
@@ -1183,6 +1187,14 @@ RegionMotionDrag::motion (GdkEvent* event, bool first_move)
                                y_delta = track_origin.y - rv->get_canvas_group()->canvas_origin().y;
 
                        }
+
+                       MidiRegionView* mrv = dynamic_cast<MidiRegionView*>(rv);
+                       if (mrv) {
+                               MidiStreamView* msv;
+                               if ((msv = dynamic_cast <MidiStreamView*> (current_tv->view())) != 0) {
+                                       mrv->apply_note_range (msv->lowest_note(), msv->highest_note(), true);
+                               }
+                       }
                }
 
                /* Now move the region view */
@@ -5664,15 +5676,15 @@ NoteDrag::total_dy () const
                return 0;
        }
 
-       MidiStreamView* msv = _region->midi_stream_view ();
        double const y = _region->midi_view()->y_position ();
        /* new current note */
-       uint8_t n = msv->y_to_note (current_pointer_y () - y);
+       uint8_t n = _region->y_to_note (current_pointer_y () - y);
        /* clamp */
+       MidiStreamView* msv = _region->midi_stream_view ();
        n = max (msv->lowest_note(), n);
        n = min (msv->highest_note(), n);
        /* and work out delta */
-       return n - msv->y_to_note (grab_y() - y);
+       return n - _region->y_to_note (grab_y() - y);
 }
 
 void
@@ -6244,10 +6256,9 @@ NoteCreateDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
        /* minimum initial length is grid beats */
        _note[1] = map.frame_at_quarter_note (eqaf + grid_beats.to_double()) - _region_view->region()->position();
 
-       MidiStreamView* sv = _region_view->midi_stream_view ();
        double const x0 = _editor->sample_to_pixel (_note[0]);
        double const x1 = _editor->sample_to_pixel (_note[1]);
-       double const y = sv->note_to_y (sv->y_to_note (y_to_region (event->button.y)));
+       double const y = _region_view->note_to_y (_region_view->y_to_note (y_to_region (event->button.y)));
 
        _drag_rect->set (ArdourCanvas::Rect (x0, y, x1, y + floor (_region_view->midi_stream_view()->note_height ())));
        _drag_rect->set_outline_all ();
@@ -6352,9 +6363,7 @@ HitCreateDrag::start_grab (GdkEvent* event, Gdk::Cursor* cursor)
        }
 
        const framepos_t start = map.frame_at_quarter_note (eqaf) - _region_view->region()->position();
-
-       MidiStreamView* sv = _region_view->midi_stream_view ();
-       const double y = sv->note_to_y (sv->y_to_note (y_to_region (event->button.y)));
+       const double y = _region_view->note_to_y (_region_view->y_to_note (y_to_region (event->button.y)));
 
        Evoral::Beats length = _region_view->get_grid_beats (pf);
 
@@ -6378,9 +6387,7 @@ HitCreateDrag::motion (GdkEvent* event, bool)
 
        const double eqaf = map.exact_qn_at_frame (pf, divisions);
        const framepos_t start = map.frame_at_quarter_note (eqaf) - _region_view->region()->position ();
-
-       MidiStreamView* sv = _region_view->midi_stream_view ();
-       const double y = sv->note_to_y (sv->y_to_note (y_to_region (event->button.y)));
+       const double y = _region_view->note_to_y (_region_view->y_to_note (y_to_region (event->button.y)));
 
        if (_last_pos == start && y == _last_y) {
                return;

diff --git a/gtk2_ardour/midi_region_view.cc b/gtk2_ardour/midi_region_view.cc
index fdd5f1b744e6ed9b8c3c6f8c5555d632bdf4eafd..43e2ad3f84eb2c10f8492778b36e90e1491d3d11 100644 (file)
--- a/gtk2_ardour/midi_region_view.cc
+++ b/gtk2_ardour/midi_region_view.cc
@@ -1480,44 +1480,7 @@ MidiRegionView::apply_note_range (uint8_t min, uint8_t max, bool force)
        _current_range_min = min;
        _current_range_max = max;
 
-       for (Events::const_iterator i = _events.begin(); i != _events.end(); ++i) {
-               NoteBase* event = *i;
-               boost::shared_ptr<NoteType> note (event->note());
-
-               if (note->note() < _current_range_min ||
-                   note->note() > _current_range_max) {
-                       event->hide();
-               } else {
-                       event->show();
-               }
-
-               if (Note* cnote = dynamic_cast<Note*>(event)) {
-
-                       const double y0 = 1. + floor (midi_stream_view()->note_to_y(note->note()));
-                       const double y1 = y0 + std::max(1., floor(midi_stream_view()->note_height()) - 1.);
-
-                       if (y0 < 0 || y1 >= _height) {
-                               /* During DnD, the region uses the 'old/current'
-                                * midi_stream_view()'s range and its position/height calculation.
-                                *
-                                * Ideally DnD would decouple the midi_stream_view() for the
-                                * region(s) being dragged and set it to the target's range
-                                * (or in case of the drop-zone, FullRange).
-                                * but I don't see how this can be done without major rework.
-                                *
-                                * For now, just prevent visual bleeding of events in case
-                                * the target-track is smaller.
-                                */
-                               event->hide();
-                               continue;
-                       }
-                       cnote->set_y0 (y0);
-                       cnote->set_y1 (y1);
-
-               } else if (Hit* chit = dynamic_cast<Hit*>(event)) {
-                       update_hit (chit);
-               }
-       }
+       redisplay_model ();
 }
 
 GhostRegion*
@@ -1677,8 +1640,8 @@ MidiRegionView::note_in_region_range (const boost::shared_ptr<NoteType> note, bo
        const bool outside = (note->time().to_double() < midi_reg->start_beats() ||
                              note->time().to_double() >= midi_reg->start_beats() + midi_reg->length_beats());
 
-       visible = (note->note() >= midi_stream_view()->lowest_note()) &&
-               (note->note() <= midi_stream_view()->highest_note());
+       visible = (note->note() >= _current_range_min) &&
+               (note->note() <= _current_range_max);
 
        return !outside;
 }
@@ -1711,7 +1674,7 @@ MidiRegionView::update_sustained (Note* ev, bool update_ghost_regions)
 
        const double x0 = trackview.editor().sample_to_pixel (note_start_frames);
        double x1;
-       const double y0 = 1 + floor(midi_stream_view()->note_to_y(note->note()));
+       const double y0 = 1 + floor(note_to_y(note->note()));
        double y1;
 
        /* trim note display to not overlap the end of its region */
@@ -1729,7 +1692,7 @@ MidiRegionView::update_sustained (Note* ev, bool update_ghost_regions)
                x1 = std::max(1., trackview.editor().sample_to_pixel (_region->length())) - 1;
        }
 
-       y1 = y0 + std::max(1., floor(midi_stream_view()->note_height()) - 1);
+       y1 = y0 + std::max(1., floor(note_height()) - 1);
 
        ev->set (ArdourCanvas::Rect (x0, y0, x1, y1));
 
@@ -1778,8 +1741,8 @@ MidiRegionView::update_hit (Hit* ev, bool update_ghost_regions)
        const framepos_t note_start_frames = trackview.session()->tempo_map().frame_at_quarter_note (note_time_qn) - _region->position();
 
        const double x = trackview.editor().sample_to_pixel(note_start_frames);
-       const double diamond_size = std::max(1., floor(midi_stream_view()->note_height()) - 2.);
-       const double y = 1.5 + floor(midi_stream_view()->note_to_y(note->note())) + diamond_size * .5;
+       const double diamond_size = std::max(1., floor(note_height()) - 2.);
+       const double y = 1.5 + floor(note_to_y(note->note())) + diamond_size * .5;
 
        // see DnD note in MidiRegionView::apply_note_range() above
        if (y <= 0 || y >= _height) {
@@ -1827,7 +1790,7 @@ MidiRegionView::add_note(const boost::shared_ptr<NoteType> note, bool visible)
 
        } else if (midi_view()->note_mode() == Percussive) {
 
-               const double diamond_size = std::max(1., floor(midi_stream_view()->note_height()) - 2.);
+               const double diamond_size = std::max(1., floor(note_height()) - 2.);
 
                Hit* ev_diamond = new Hit (*this, _note_group, diamond_size, note);
 
@@ -3776,7 +3739,7 @@ MidiRegionView::update_ghost_note (double x, double y, uint32_t state)
 
        _ghost_note->note()->set_time (snapped_beats);
        _ghost_note->note()->set_length (length);
-       _ghost_note->note()->set_note (midi_stream_view()->y_to_note (y));
+       _ghost_note->note()->set_note (y_to_note (y));
        _ghost_note->note()->set_channel (mtv->get_channel_for_add ());
        _ghost_note->note()->set_velocity (get_velocity_for_add (snapped_beats));
        /* the ghost note does not appear in ghost regions, so pass false in here */
@@ -3842,7 +3805,7 @@ MidiRegionView::maybe_select_by_position (GdkEventButton* ev, double /*x*/, doub
 {
        /* XXX: This is dead code.  What was it for? */
 
-       double note = midi_stream_view()->y_to_note(y);
+       double note = y_to_note(y);
        Events e;
        MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
 
@@ -4188,3 +4151,24 @@ MidiRegionView::get_grid_beats(framepos_t pos) const
        }
        return beats;
 }
+uint8_t
+MidiRegionView::y_to_note (double y) const
+{
+       int const n = ((contents_height() - y) / contents_height() * (double)(_current_range_max - _current_range_min + 1))
+               + _current_range_min;
+
+       if (n < 0) {
+               return 0;
+       } else if (n > 127) {
+               return 127;
+       }
+
+       /* min due to rounding and/or off-by-one errors */
+       return min ((uint8_t) n, _current_range_max);
+}
+
+double
+MidiRegionView::note_to_y(uint8_t note) const
+{
+       return contents_height() - (note + 1 - _current_range_min) * note_height() + 1;
+}

diff --git a/gtk2_ardour/midi_region_view.h b/gtk2_ardour/midi_region_view.h
index 9c85401593c7c121a99275341cc71fd10eeb1b3d..93ce1e5011e95caaba0bd3af9be58eec17f14aac 100644 (file)
--- a/gtk2_ardour/midi_region_view.h
+++ b/gtk2_ardour/midi_region_view.h
@@ -355,6 +355,7 @@ private:
 
        friend class MidiRubberbandSelectDrag;
        friend class MidiVerticalSelectDrag;
+       friend class NoteDrag;
        friend class NoteCreateDrag;
        friend class HitCreateDrag;
 
@@ -519,6 +520,13 @@ private:
 
         ARDOUR::ChannelMode get_channel_mode() const;
         uint16_t get_selected_channels () const;
+
+       inline double contents_height() const { return (_height - TimeAxisViewItem::NAME_HIGHLIGHT_SIZE - 2); }
+       inline double contents_note_range () const { return (double)(_current_range_max - _current_range_min + 1); }
+       inline double note_height() const { return contents_height() / contents_note_range(); }
+
+       double note_to_y (uint8_t note) const;
+       uint8_t y_to_note (double y) const;
 };