, _last_event_y (0)
, _grabbed_keyboard (false)
, _entered (false)
- , _note_entered (false)
+ , _entered_note (0)
, _mouse_changed_selection (false)
{
CANVAS_DEBUG_NAME (_note_group, string_compose ("note group for %1", get_item_name()));
, _last_event_y (0)
, _grabbed_keyboard (false)
, _entered (false)
- , _note_entered (false)
+ , _entered_note (0)
, _mouse_changed_selection (false)
{
CANVAS_DEBUG_NAME (_note_group, string_compose ("note group for %1", get_item_name()));
, _last_event_y (0)
, _grabbed_keyboard (false)
, _entered (false)
- , _note_entered (false)
+ , _entered_note (0)
, _mouse_changed_selection (false)
{
init (false);
, _last_event_y (0)
, _grabbed_keyboard (false)
, _entered (false)
- , _note_entered (false)
+ , _entered_note (0)
, _mouse_changed_selection (false)
{
init (true);
remove_ghost_note ();
/* XXX This is problematic as the function is executed for every region
- and only for one region _note_entered can be true. Still it's
+ and only for one region _entered_note can be true. Still it's
necessary as to hide the verbose cursor when we're changing from
draw mode to internal edit mode. These lines are the reason why
in some situations no verbose cursor is shown when we enter internal
edit mode over a note. */
- if (!_note_entered) {
+ if (!_entered_note) {
hide_verbose_cursor ();
}
}
{
hide_verbose_cursor ();
remove_ghost_note ();
- _note_entered = false;
+ _entered_note = 0;
if (_grabbed_keyboard) {
Keyboard::magic_widget_drop_focus();
if (_mouse_state != SelectTouchDragging) {
_pressed_button = ev->button;
- _mouse_state = Pressed;
+
+ if (m == MouseDraw || (m == MouseContent && Keyboard::modifier_state_contains (ev->state, Keyboard::insert_note_modifier()))) {
+
+ if (midi_view()->note_mode() == Percussive) {
+ editor->drags()->set (new HitCreateDrag (dynamic_cast<Editor *> (editor), group, this), (GdkEvent *) ev);
+ } else {
+ editor->drags()->set (new NoteCreateDrag (dynamic_cast<Editor *> (editor), group, this), (GdkEvent *) ev);
+ }
+
+ _mouse_state = AddDragging;
+ remove_ghost_note ();
+ hide_verbose_cursor ();
+ } else {
+ _mouse_state = Pressed;
+ }
return true;
}
case MouseTimeFX:
{
_mouse_changed_selection = true;
-
- if (Keyboard::is_insert_note_event(ev)) {
-
- double event_x, event_y;
-
- event_x = ev->x;
- event_y = ev->y;
- group->canvas_to_item (event_x, event_y);
-
- Evoral::Beats beats = get_grid_beats(editor.pixel_to_sample(event_x) + _region->position());
- create_note_at (editor.pixel_to_sample (event_x), event_y, beats, ev->state, true);
- } else {
- clear_editor_note_selection ();
- }
+ clear_editor_note_selection ();
break;
}
case MouseDraw:
- {
- Evoral::Beats beats = get_grid_beats(editor.pixel_to_sample(event_x) + _region->position());
- create_note_at (editor.pixel_to_sample (event_x), event_y, beats, ev->state, true);
- break;
- }
+ break;
+
default:
break;
}
break;
case AddDragging:
- /* Only create a ghost note when we added a note, not when we were drag-selecting. */
- create_ghost_note (ev->x, ev->y, ev->state);
+ /* Don't a ghost note when we added a note - wait until motion to avoid visual confusion.
+ we don't want one when we were drag-selecting either. */
case SelectRectDragging:
editor.drags()->end_grab ((GdkEvent *) ev);
_mouse_state = None;
{
PublicEditor& editor = trackview.editor ();
- if (!_note_entered) {
+ if (!_entered_note) {
if (_mouse_state == AddDragging) {
if (_ghost_note) {
MouseMode m = editor.current_mouse_mode();
- if (m == MouseDraw || (m == MouseContent && Keyboard::modifier_state_contains (ev->state, Keyboard::insert_note_modifier()))) {
- editor.drags()->set (new NoteCreateDrag (dynamic_cast<Editor *> (&editor), group, this), (GdkEvent *) ev);
- _mouse_state = AddDragging;
- remove_ghost_note ();
- hide_verbose_cursor ();
- return true;
- } else if (m == MouseContent) {
+ if (m == MouseContent && !Keyboard::modifier_state_contains (ev->state, Keyboard::insert_note_modifier())) {
editor.drags()->set (new MidiRubberbandSelectDrag (dynamic_cast<Editor *> (&editor), this), (GdkEvent *) ev);
if (!Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
clear_editor_note_selection ();
detectable auto-repeat is the name of the game and only sends
repeated presses, carry out key actions at key press, not release.
*/
-
bool unmodified = Keyboard::no_modifier_keys_pressed (ev);
if (unmodified && (ev->keyval == GDK_Alt_L || ev->keyval == GDK_Alt_R)) {
- _mouse_state = SelectTouchDragging;
+
+ if (_mouse_state != AddDragging) {
+ _mouse_state = SelectTouchDragging;
+ }
+
return true;
} else if (ev->keyval == GDK_Escape && unmodified) {
if (_active_notes) {
end_write();
}
-
- _selection.clear();
+ _entered_note = 0;
clear_events ();
delete _note_group;
_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*
/* must compare double explicitly as Beats::operator< rounds to ppqn */
const bool outside = (note->time().to_double() < midi_reg->start_beats() ||
- note->time().to_double() > midi_reg->start_beats() + midi_reg->length_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;
}
const boost::shared_ptr<ARDOUR::MidiRegion> mr = midi_region();
boost::shared_ptr<NoteType> note = ev->note();
- const double session_source_start = _region->pos_beats() - mr->start_beats();
+ const double session_source_start = _region->quarter_note() - mr->start_beats();
const framepos_t note_start_frames = map.frame_at_quarter_note (note->time().to_double() + session_source_start) - _region->position();
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 */
- if (note->length() > 0) {
+ if (note->length().to_double() > 0.0) {
double note_end_time = note->end_time().to_double();
if (note_end_time > mr->start_beats() + mr->length_beats()) {
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));
{
boost::shared_ptr<NoteType> note = ev->note();
- const double note_time_qn = note->time().to_double() + (_region->pos_beats() - midi_region()->start_beats());
+ const double note_time_qn = note->time().to_double() + (_region->quarter_note() - midi_region()->start_beats());
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) {
} 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);
void
MidiRegionView::note_deleted (NoteBase* cne)
{
+ if (_entered_note && cne == _entered_note) {
+ _entered_note = 0;
+ }
+
if (_selection.empty()) {
return;
}
_selection.clear();
apply_diff ();
+
hide_verbose_cursor ();
}
for (Selection::iterator i = _selection.begin(); i != _selection.end() ; ++i) {
- double const start_qn = _region->pos_beats() - midi_region()->start_beats();
+ double const start_qn = _region->quarter_note() - midi_region()->start_beats();
framepos_t new_frames = map.frame_at_quarter_note (start_qn + (*i)->note()->time().to_double()) + dt;
Evoral::Beats new_time = Evoral::Beats (map.quarter_note_at_frame (new_frames) - start_qn);
if (new_time < 0) {
/* and then to beats */
const double e_qaf = tmap.exact_qn_at_frame (current_fr + midi_region()->position(), divisions);
- const double quarter_note_start = _region->pos_beats() - midi_region()->start_beats();
+ const double quarter_note_start = _region->quarter_note() - midi_region()->start_beats();
const Evoral::Beats x_beats = Evoral::Beats (e_qaf - quarter_note_start);
if (at_front && x_beats < canvas_note->note()->end_time()) {
void
MidiRegionView::note_entered(NoteBase* ev)
{
- _note_entered = true;
+ _entered_note = ev;
Editor* editor = dynamic_cast<Editor*>(&trackview.editor());
void
MidiRegionView::note_left (NoteBase*)
{
- _note_entered = false;
+ _entered_note = 0;
for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
(*i)->hide_velocity ();
void
MidiRegionView::sysex_entered (SysEx* p)
{
- ostringstream s;
+ // ostringstream s;
// CAIROCANVAS
// need a way to extract text from p->_flag->_text
// s << p->text();
const Evoral::Beats duration = last_time - first_time;
const Evoral::Beats snap_duration = duration.snap_to(snap_beats);
const Evoral::Beats paste_offset = snap_duration * paste_count;
- const Evoral::Beats pos_beats = absolute_frames_to_source_beats(pos) + paste_offset;
+ const Evoral::Beats quarter_note = absolute_frames_to_source_beats(pos) + paste_offset;
Evoral::Beats end_point = Evoral::Beats();
DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("Paste data spans from %1 to %2 (%3) ; paste pos beats = %4 (based on %5 - %6)\n",
first_time,
last_time,
duration, pos, _region->position(),
- pos_beats));
+ quarter_note));
clear_editor_note_selection ();
for (Notes::const_iterator i = mcb.notes().begin(); i != mcb.notes().end(); ++i) {
boost::shared_ptr<NoteType> copied_note (new NoteType (*((*i).get())));
- copied_note->set_time (pos_beats + copied_note->time() - first_time);
+ copied_note->set_time (quarter_note + copied_note->time() - first_time);
copied_note->set_id (Evoral::next_event_id());
/* make all newly added notes selected */
framepos_t const unsnapped_frame = editor.pixel_to_sample (x);
const int32_t divisions = editor.get_grid_music_divisions (state);
- const Evoral::Beats snapped_beats = snap_frame_to_grid_underneath (unsnapped_frame, divisions, true);
+ const bool shift_snap = midi_view()->note_mode() != Percussive;
+ const Evoral::Beats snapped_beats = snap_frame_to_grid_underneath (unsnapped_frame, divisions, shift_snap);
+
+ /* prevent Percussive mode from displaying a ghost hit at region end */
+ if (!shift_snap && snapped_beats >= midi_region()->start_beats() + midi_region()->length_beats()) {
+ _ghost_note->hide();
+ hide_verbose_cursor ();
+ return;
+ }
/* ghost note may have been snapped before region */
if (_ghost_note && snapped_beats.to_double() < 0.0) {
_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 */
{
/* 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);
eqaf -= grid_beats.to_double();
}
}
- const double session_start_off = _region->pos_beats() - midi_region()->start_beats();
+ const double session_start_off = _region->quarter_note() - midi_region()->start_beats();
return Evoral::Beats (eqaf - session_start_off);
}
}
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;
+}
projects / ardour.git / blobdiff