#include <sigc++/signal.h>
+#include "midi++/midnam_patch.h"
+
#include "pbd/memento_command.h"
#include "pbd/stateful_diff_command.h"
#include "ardour/midi_model.h"
-#include "ardour/midi_patch_manager.h"
+#include "ardour/midi_playlist.h"
#include "ardour/midi_region.h"
#include "ardour/midi_source.h"
#include "ardour/midi_track.h"
+#include "ardour/operations.h"
#include "ardour/session.h"
#include "evoral/Parameter.hpp"
-#include "evoral/MIDIParameters.hpp"
#include "evoral/MIDIEvent.hpp"
#include "evoral/Control.hpp"
#include "evoral/midi_util.h"
#include "canvas/debug.h"
+#include "canvas/text.h"
#include "automation_region_view.h"
#include "automation_time_axis.h"
+#include "control_point.h"
#include "debug.h"
#include "editor.h"
#include "editor_drag.h"
#include "ghostregion.h"
#include "gui_thread.h"
+#include "item_counts.h"
#include "keyboard.h"
#include "midi_channel_dialog.h"
#include "midi_cut_buffer.h"
#include "midi_velocity_dialog.h"
#include "mouse_cursors.h"
#include "note_player.h"
+#include "paste_context.h"
#include "public_editor.h"
#include "route_time_axis.h"
#include "rgb_macros.h"
#include "selection.h"
#include "streamview.h"
-#include "utils.h"
#include "patch_change_dialog.h"
#include "verbose_cursor.h"
-#include "ardour_ui.h"
#include "note.h"
#include "hit.h"
#include "patch_change.h"
#include "sys_ex.h"
+#include "ui_config.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
using namespace ARDOUR;
using namespace PBD;
using namespace Editing;
+using namespace std;
using Gtkmm2ext::Keyboard;
-PBD::Signal1<void, MidiRegionView *> MidiRegionView::SelectionCleared;
-
#define MIDI_BP_ZERO ((Config->get_first_midi_bank_is_zero())?0:1)
-MidiRegionView::MidiRegionView (ArdourCanvas::Group *parent, RouteTimeAxisView &tv,
- boost::shared_ptr<MidiRegion> r, double spu, Gdk::Color const & basic_color)
+MidiRegionView::MidiRegionView (ArdourCanvas::Container* parent,
+ RouteTimeAxisView& tv,
+ boost::shared_ptr<MidiRegion> r,
+ double spu,
+ uint32_t basic_color)
: RegionView (parent, tv, r, spu, basic_color)
, _current_range_min(0)
, _current_range_max(0)
+ , _region_relative_time_converter(r->session().tempo_map(), r->position())
+ , _source_relative_time_converter(r->session().tempo_map(), r->position() - r->start())
+ , _region_relative_time_converter_double(r->session().tempo_map(), r->position())
, _active_notes(0)
- , _note_group (new ArdourCanvas::Group (group))
+ , _note_group (new ArdourCanvas::Container (group))
, _note_diff_command (0)
, _ghost_note(0)
, _step_edit_cursor (0)
, _step_edit_cursor_width (1.0)
, _step_edit_cursor_position (0.0)
, _channel_selection_scoped_note (0)
- , _temporary_note_group (0)
, _mouse_state(None)
, _pressed_button(0)
, _sort_needed (true)
, _optimization_iterator (_events.end())
, _list_editor (0)
, _no_sound_notes (false)
+ , _last_display_zoom (0)
, _last_event_x (0)
, _last_event_y (0)
- , pre_enter_cursor (0)
- , pre_press_cursor (0)
- , _note_player (0)
+ , _grabbed_keyboard (false)
+ , _entered (false)
+ , _note_entered (false)
+ , _mouse_changed_selection (false)
{
CANVAS_DEBUG_NAME (_note_group, string_compose ("note group for %1", get_item_name()));
_note_group->raise_to_top();
Config->ParameterChanged.connect (*this, invalidator (*this), boost::bind (&MidiRegionView::parameter_changed, this, _1), gui_context());
connect_to_diskstream ();
-
- SelectionCleared.connect (_selection_cleared_connection, invalidator (*this), boost::bind (&MidiRegionView::selection_cleared, this, _1), gui_context ());
}
-MidiRegionView::MidiRegionView (ArdourCanvas::Group *parent, RouteTimeAxisView &tv,
- boost::shared_ptr<MidiRegion> r, double spu, Gdk::Color& basic_color,
- TimeAxisViewItem::Visibility visibility)
- : RegionView (parent, tv, r, spu, basic_color, false, visibility)
+MidiRegionView::MidiRegionView (ArdourCanvas::Container* parent,
+ RouteTimeAxisView& tv,
+ boost::shared_ptr<MidiRegion> r,
+ double spu,
+ uint32_t basic_color,
+ bool recording,
+ TimeAxisViewItem::Visibility visibility)
+ : RegionView (parent, tv, r, spu, basic_color, recording, visibility)
, _current_range_min(0)
, _current_range_max(0)
+ , _region_relative_time_converter(r->session().tempo_map(), r->position())
+ , _source_relative_time_converter(r->session().tempo_map(), r->position() - r->start())
+ , _region_relative_time_converter_double(r->session().tempo_map(), r->position())
, _active_notes(0)
- , _note_group (new ArdourCanvas::Group (parent))
+ , _note_group (new ArdourCanvas::Container (group))
, _note_diff_command (0)
, _ghost_note(0)
, _step_edit_cursor (0)
, _step_edit_cursor_width (1.0)
, _step_edit_cursor_position (0.0)
, _channel_selection_scoped_note (0)
- , _temporary_note_group (0)
, _mouse_state(None)
, _pressed_button(0)
, _sort_needed (true)
, _optimization_iterator (_events.end())
, _list_editor (0)
, _no_sound_notes (false)
+ , _last_display_zoom (0)
, _last_event_x (0)
, _last_event_y (0)
- , pre_enter_cursor (0)
- , pre_press_cursor (0)
- , _note_player (0)
+ , _grabbed_keyboard (false)
+ , _entered (false)
+ , _note_entered (false)
+ , _mouse_changed_selection (false)
{
CANVAS_DEBUG_NAME (_note_group, string_compose ("note group for %1", get_item_name()));
_note_group->raise_to_top();
PublicEditor::DropDownKeys.connect (sigc::mem_fun (*this, &MidiRegionView::drop_down_keys));
connect_to_diskstream ();
-
- SelectionCleared.connect (_selection_cleared_connection, invalidator (*this), boost::bind (&MidiRegionView::selection_cleared, this, _1), gui_context ());
}
void
MidiRegionView::parameter_changed (std::string const & p)
{
- if (p == "diplay-first-midi-bank-as-zero") {
+ if (p == "display-first-midi-bank-as-zero") {
if (_enable_display) {
redisplay_model();
}
, RegionView (other)
, _current_range_min(0)
, _current_range_max(0)
+ , _region_relative_time_converter(other.region_relative_time_converter())
+ , _source_relative_time_converter(other.source_relative_time_converter())
+ , _region_relative_time_converter_double(other.region_relative_time_converter_double())
, _active_notes(0)
- , _note_group (new ArdourCanvas::Group (get_canvas_group()))
+ , _note_group (new ArdourCanvas::Container (get_canvas_group()))
, _note_diff_command (0)
, _ghost_note(0)
, _step_edit_cursor (0)
, _step_edit_cursor_width (1.0)
, _step_edit_cursor_position (0.0)
, _channel_selection_scoped_note (0)
- , _temporary_note_group (0)
, _mouse_state(None)
, _pressed_button(0)
, _sort_needed (true)
, _optimization_iterator (_events.end())
, _list_editor (0)
, _no_sound_notes (false)
+ , _last_display_zoom (0)
, _last_event_x (0)
, _last_event_y (0)
- , pre_enter_cursor (0)
- , pre_press_cursor (0)
- , _note_player (0)
+ , _grabbed_keyboard (false)
+ , _entered (false)
+ , _note_entered (false)
+ , _mouse_changed_selection (false)
{
- Gdk::Color c;
- int r,g,b,a;
-
- UINT_TO_RGBA (other.fill_color, &r, &g, &b, &a);
- c.set_rgb_p (r/255.0, g/255.0, b/255.0);
-
- init (c, false);
+ init (false);
}
MidiRegionView::MidiRegionView (const MidiRegionView& other, boost::shared_ptr<MidiRegion> region)
: RegionView (other, boost::shared_ptr<Region> (region))
, _current_range_min(0)
, _current_range_max(0)
+ , _region_relative_time_converter(other.region_relative_time_converter())
+ , _source_relative_time_converter(other.source_relative_time_converter())
+ , _region_relative_time_converter_double(other.region_relative_time_converter_double())
, _active_notes(0)
- , _note_group (new ArdourCanvas::Group (get_canvas_group()))
+ , _note_group (new ArdourCanvas::Container (get_canvas_group()))
, _note_diff_command (0)
, _ghost_note(0)
, _step_edit_cursor (0)
, _step_edit_cursor_width (1.0)
, _step_edit_cursor_position (0.0)
, _channel_selection_scoped_note (0)
- , _temporary_note_group (0)
, _mouse_state(None)
, _pressed_button(0)
, _sort_needed (true)
, _optimization_iterator (_events.end())
, _list_editor (0)
, _no_sound_notes (false)
+ , _last_display_zoom (0)
, _last_event_x (0)
, _last_event_y (0)
- , pre_enter_cursor (0)
- , pre_press_cursor (0)
- , _note_player (0)
+ , _grabbed_keyboard (false)
+ , _entered (false)
+ , _note_entered (false)
+ , _mouse_changed_selection (false)
{
- Gdk::Color c;
- int r,g,b,a;
-
- UINT_TO_RGBA (other.fill_color, &r, &g, &b, &a);
- c.set_rgb_p (r/255.0, g/255.0, b/255.0);
-
- init (c, true);
+ init (true);
}
void
-MidiRegionView::init (Gdk::Color const & basic_color, bool wfd)
+MidiRegionView::init (bool wfd)
{
PublicEditor::DropDownKeys.connect (sigc::mem_fun (*this, &MidiRegionView::drop_down_keys));
- NoteBase::NoteBaseDeleted.connect (note_delete_connection, MISSING_INVALIDATOR,
- boost::bind (&MidiRegionView::maybe_remove_deleted_note_from_selection, this, _1),
- gui_context());
-
if (wfd) {
- midi_region()->midi_source(0)->load_model();
+ Glib::Threads::Mutex::Lock lm(midi_region()->midi_source(0)->mutex());
+ midi_region()->midi_source(0)->load_model(lm);
}
_model = midi_region()->midi_source(0)->model();
_enable_display = false;
+ fill_color_name = "midi frame base";
- RegionView::init (basic_color, false);
+ RegionView::init (false);
- compute_colors (basic_color);
-
- set_height (trackview.current_height());
+ //set_height (trackview.current_height());
region_muted ();
region_sync_changed ();
region_resized (ARDOUR::bounds_change);
- region_locked ();
+ //region_locked ();
set_colors ();
group->raise_to_top();
- midi_view()->midi_track()->PlaybackChannelModeChanged.connect (_channel_mode_changed_connection, invalidator (*this),
+ midi_view()->midi_track()->playback_filter().ChannelModeChanged.connect (_channel_mode_changed_connection, invalidator (*this),
boost::bind (&MidiRegionView::midi_channel_mode_changed, this),
gui_context ());
boost::bind (&MidiRegionView::snap_changed, this),
gui_context());
+ trackview.editor().MouseModeChanged.connect(_mouse_mode_connection, invalidator (*this),
+ boost::bind (&MidiRegionView::mouse_mode_changed, this),
+ gui_context ());
+
Config->ParameterChanged.connect (*this, invalidator (*this), boost::bind (&MidiRegionView::parameter_changed, this, _1), gui_context());
connect_to_diskstream ();
-
- SelectionCleared.connect (_selection_cleared_connection, invalidator (*this), boost::bind (&MidiRegionView::selection_cleared, this, _1), gui_context ());
}
InstrumentInfo&
bool
MidiRegionView::canvas_group_event(GdkEvent* ev)
{
+ if (in_destructor || _recregion) {
+ return false;
+ }
+
+ if (!trackview.editor().internal_editing()) {
+ // not in internal edit mode, so just act like a normal region
+ return RegionView::canvas_group_event (ev);
+ }
+
bool r;
switch (ev->type) {
case GDK_ENTER_NOTIFY:
- case GDK_LEAVE_NOTIFY:
_last_event_x = ev->crossing.x;
_last_event_y = ev->crossing.y;
- break;
- case GDK_MOTION_NOTIFY:
- _last_event_x = ev->motion.x;
- _last_event_y = ev->motion.y;
- break;
- default:
- break;
- }
-
- if (ev->type == GDK_2BUTTON_PRESS) {
- // cannot use double-click to exit internal mode if single-click is being used
- MouseMode m = trackview.editor().current_mouse_mode();
-
- if ((m != MouseObject || !Keyboard::modifier_state_contains (ev->button.state, Keyboard::insert_note_modifier())) && (m != MouseDraw)) {
- return trackview.editor().toggle_internal_editing_from_double_click (ev);
- }
- }
+ enter_notify(&ev->crossing);
+ // set entered_regionview (among other things)
+ return RegionView::canvas_group_event (ev);
- if ((!trackview.editor().internal_editing() && trackview.editor().current_mouse_mode() != MouseGain) ||
- (trackview.editor().current_mouse_mode() == MouseTimeFX) ||
- (trackview.editor().current_mouse_mode() == MouseZoom)) {
- // handle non-internal-edit/non-draw modes elsewhere
+ case GDK_LEAVE_NOTIFY:
+ _last_event_x = ev->crossing.x;
+ _last_event_y = ev->crossing.y;
+ leave_notify(&ev->crossing);
+ // reset entered_regionview (among other things)
return RegionView::canvas_group_event (ev);
- }
- switch (ev->type) {
case GDK_SCROLL:
- return scroll (&ev->scroll);
+ if (scroll (&ev->scroll)) {
+ return true;
+ }
+ break;
case GDK_KEY_PRESS:
return key_press (&ev->key);
case GDK_BUTTON_RELEASE:
r = button_release (&ev->button);
- delete _note_player;
- _note_player = 0;
return r;
- case GDK_ENTER_NOTIFY:
- return enter_notify (&ev->crossing);
-
- case GDK_LEAVE_NOTIFY:
- return leave_notify (&ev->crossing);
-
case GDK_MOTION_NOTIFY:
+ _last_event_x = ev->motion.x;
+ _last_event_y = ev->motion.y;
return motion (&ev->motion);
default:
break;
}
- return trackview.editor().canvas_region_view_event (ev, group, this);
+ return RegionView::canvas_group_event (ev);
}
bool
MidiRegionView::enter_notify (GdkEventCrossing* ev)
{
- trackview.editor().MouseModeChanged.connect (
- _mouse_mode_connection, invalidator (*this), boost::bind (&MidiRegionView::mouse_mode_changed, this), gui_context ()
- );
-
- if (trackview.editor().current_mouse_mode() == MouseDraw && _mouse_state != AddDragging) {
- create_ghost_note (ev->x, ev->y);
- }
-
- if (!trackview.editor().internal_editing()) {
- Keyboard::magic_widget_drop_focus();
- } else {
- Keyboard::magic_widget_grab_focus();
- group->grab_focus();
- }
-
- // if current operation is non-operational in a midi region, change the cursor to so indicate
- if (trackview.editor().current_mouse_mode() == MouseGain) {
- Editor* editor = dynamic_cast<Editor *> (&trackview.editor());
- pre_enter_cursor = editor->get_canvas_cursor();
- editor->set_canvas_cursor(editor->cursors()->timebar);
- }
+ enter_internal();
+ _entered = true;
return false;
}
bool
MidiRegionView::leave_notify (GdkEventCrossing*)
{
- _mouse_mode_connection.disconnect ();
-
- trackview.editor().verbose_cursor()->hide ();
- remove_ghost_note ();
-
- if (pre_enter_cursor) {
- Editor* editor = dynamic_cast<Editor *> (&trackview.editor());
- editor->set_canvas_cursor(pre_enter_cursor);
- }
+ leave_internal();
+ _entered = false;
return false;
}
void
MidiRegionView::mouse_mode_changed ()
{
- if (trackview.editor().current_mouse_mode() == MouseDraw && trackview.editor().internal_editing()) {
- create_ghost_note (_last_event_x, _last_event_y);
- } else {
- remove_ghost_note ();
- trackview.editor().verbose_cursor()->hide ();
+ // Adjust frame colour (become more transparent for internal tools)
+ set_frame_color();
+
+ if (_entered) {
+ if (!trackview.editor().internal_editing()) {
+ /* Switched out of internal editing mode while entered.
+ Only necessary for leave as a mouse_mode_change over a region
+ automatically triggers an enter event. */
+ leave_internal();
+ }
+ else if (trackview.editor().current_mouse_mode() == MouseContent) {
+ // hide cursor and ghost note after changing to internal edit mode
+ 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
+ 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) {
+ hide_verbose_cursor ();
+ }
+ }
}
+}
- if (!trackview.editor().internal_editing()) {
- Keyboard::magic_widget_drop_focus();
- } else {
+void
+MidiRegionView::enter_internal()
+{
+ if (trackview.editor().current_mouse_mode() == MouseDraw && _mouse_state != AddDragging) {
+ // Show ghost note under pencil
+ create_ghost_note(_last_event_x, _last_event_y);
+ }
+
+ if (!_selection.empty()) {
+ // Grab keyboard for moving selected notes with arrow keys
Keyboard::magic_widget_grab_focus();
- group->grab_focus();
+ _grabbed_keyboard = true;
+ }
+
+ // Lower frame handles below notes so they don't steal events
+ if (frame_handle_start) {
+ frame_handle_start->lower_to_bottom();
+ }
+ if (frame_handle_end) {
+ frame_handle_end->lower_to_bottom();
+ }
+}
+
+void
+MidiRegionView::leave_internal()
+{
+ hide_verbose_cursor ();
+ remove_ghost_note ();
+ _note_entered = false;
+
+ if (_grabbed_keyboard) {
+ Keyboard::magic_widget_drop_focus();
+ _grabbed_keyboard = false;
+ }
+
+ // Raise frame handles above notes so they catch events
+ if (frame_handle_start) {
+ frame_handle_start->raise_to_top();
+ }
+ if (frame_handle_end) {
+ frame_handle_end->raise_to_top();
}
}
Editor* editor = dynamic_cast<Editor *> (&trackview.editor());
MouseMode m = editor->current_mouse_mode();
- if (m == MouseObject && Keyboard::modifier_state_contains (ev->state, Keyboard::insert_note_modifier())) {
- pre_press_cursor = editor->get_canvas_cursor ();
- editor->set_canvas_cursor (editor->cursors()->midi_pencil);
- }
+ if (m == MouseContent && Keyboard::modifier_state_contains (ev->state, Keyboard::insert_note_modifier())) {
+ _press_cursor_ctx = CursorContext::create(*editor, editor->cursors()->midi_pencil);
+ }
if (_mouse_state != SelectTouchDragging) {
-
+
_pressed_button = ev->button;
_mouse_state = Pressed;
-
+
return true;
}
_pressed_button = ev->button;
+ _mouse_changed_selection = false;
return true;
}
PublicEditor& editor = trackview.editor ();
- if (pre_press_cursor) {
- dynamic_cast<Editor*>(&editor)->set_canvas_cursor (pre_press_cursor, false);
- pre_press_cursor = 0;
- }
+ _press_cursor_ctx.reset();
switch (_mouse_state) {
case Pressed: // Clicked
switch (editor.current_mouse_mode()) {
case MouseRange:
- /* no motion occured - simple click */
- clear_selection ();
+ /* no motion occurred - simple click */
+ clear_editor_note_selection ();
+ _mouse_changed_selection = true;
break;
- case MouseObject:
+ case MouseContent:
case MouseTimeFX:
{
- clear_selection();
+ _mouse_changed_selection = true;
if (Keyboard::is_insert_note_event(ev)) {
event_y = ev->y;
group->canvas_to_item (event_x, event_y);
- bool success;
- Evoral::MusicalTime beats = editor.get_grid_type_as_beats (success, editor.pixel_to_sample (event_x));
-
- if (!success) {
- beats = 1;
- }
-
- /* Shorten the length by 1 tick so that we can add a new note at the next
- grid snap without it overlapping this one.
- */
- beats -= 1.0 / Timecode::BBT_Time::ticks_per_beat;
-
+ Evoral::Beats beats = get_grid_beats(editor.pixel_to_sample(event_x));
create_note_at (editor.pixel_to_sample (event_x), event_y, beats, true);
+ } else {
+ clear_editor_note_selection ();
}
break;
}
case MouseDraw:
{
- bool success;
- Evoral::MusicalTime beats = editor.get_grid_type_as_beats (success, editor.pixel_to_sample (event_x));
-
- if (!success) {
- beats = 1;
- }
-
- /* Shorten the length by 1 tick so that we can add a new note at the next
- grid snap without it overlapping this one.
- */
- beats -= 1.0 / Timecode::BBT_Time::ticks_per_beat;
-
+ Evoral::Beats beats = get_grid_beats(editor.pixel_to_sample(event_x));
create_note_at (editor.pixel_to_sample (event_x), event_y, beats, true);
-
break;
}
default:
_mouse_state = None;
break;
- case SelectRectDragging:
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);
+ case SelectRectDragging:
editor.drags()->end_grab ((GdkEvent *) ev);
_mouse_state = None;
- create_ghost_note (ev->x, ev->y);
break;
break;
}
+ if (_mouse_changed_selection) {
+ trackview.editor().begin_reversible_selection_op (X_("Mouse Selection Change"));
+ trackview.editor().commit_reversible_selection_op ();
+ }
+
return false;
}
{
PublicEditor& editor = trackview.editor ();
- if (!_ghost_note && editor.current_mouse_mode() == MouseObject &&
- Keyboard::modifier_state_contains (ev->state, Keyboard::insert_note_modifier()) &&
- _mouse_state != AddDragging) {
+ if (!_note_entered) {
- create_ghost_note (ev->x, ev->y);
+ if (!_ghost_note && editor.current_mouse_mode() == MouseContent &&
+ Keyboard::modifier_state_contains (ev->state, Keyboard::insert_note_modifier()) &&
+ _mouse_state != AddDragging) {
- } else if (_ghost_note && editor.current_mouse_mode() == MouseObject &&
- Keyboard::modifier_state_contains (ev->state, Keyboard::insert_note_modifier())) {
+ create_ghost_note (ev->x, ev->y);
- update_ghost_note (ev->x, ev->y);
+ } else if (_ghost_note && editor.current_mouse_mode() == MouseContent &&
+ Keyboard::modifier_state_contains (ev->state, Keyboard::insert_note_modifier())) {
- } else if (_ghost_note && editor.current_mouse_mode() == MouseObject) {
+ update_ghost_note (ev->x, ev->y);
- remove_ghost_note ();
- editor.verbose_cursor()->hide ();
+ } else if (_ghost_note && editor.current_mouse_mode() == MouseContent) {
+
+ remove_ghost_note ();
+ hide_verbose_cursor ();
- } else if (_ghost_note && editor.current_mouse_mode() == MouseDraw) {
+ } else if (editor.current_mouse_mode() == MouseDraw) {
- update_ghost_note (ev->x, ev->y);
+ if (_ghost_note) {
+ update_ghost_note (ev->x, ev->y);
+ }
+ else {
+ create_ghost_note (ev->x, ev->y);
+ }
+ }
}
/* any motion immediately hides velocity text that may have been visible */
case Pressed:
if (_pressed_button == 1) {
-
+
MouseMode m = editor.current_mouse_mode();
-
- if (m == MouseDraw || (m == MouseObject && Keyboard::modifier_state_contains (ev->state, Keyboard::insert_note_modifier()))) {
+
+ 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 ();
- editor.verbose_cursor()->hide ();
+ hide_verbose_cursor ();
return true;
- } else if (m == MouseObject) {
+ } else if (m == MouseContent) {
editor.drags()->set (new MidiRubberbandSelectDrag (dynamic_cast<Editor *> (&editor), this), (GdkEvent *) ev);
- clear_selection ();
+ if (!Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
+ clear_editor_note_selection ();
+ _mouse_changed_selection = true;
+ }
_mouse_state = SelectRectDragging;
return true;
} else if (m == MouseRange) {
case AddDragging:
editor.drags()->motion_handler ((GdkEvent *) ev, false);
break;
-
+
case SelectTouchDragging:
return false;
default:
break;
+
}
- return false;
+ /* we may be dragging some non-note object (eg. patch-change, sysex)
+ */
+
+ return editor.drags()->motion_handler ((GdkEvent *) ev, false);
}
return false;
}
- if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
- /* XXX: bit of a hack; allow PrimaryModifier scroll through so that
- it still works for zoom.
+ if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier) ||
+ Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
+ /* XXX: bit of a hack; allow PrimaryModifier and TertiaryModifier scroll
+ * through so that it still works for navigation.
*/
return false;
}
- trackview.editor().verbose_cursor()->hide ();
+ hide_verbose_cursor ();
bool fine = !Keyboard::modifier_state_contains (ev->state, Keyboard::SecondaryModifier);
- bool together = Keyboard::modifier_state_contains (ev->state, Keyboard::TertiaryModifier);
+ Keyboard::ModifierMask mask_together(Keyboard::PrimaryModifier|Keyboard::TertiaryModifier);
+ bool together = Keyboard::modifier_state_contains (ev->state, mask_together);
if (ev->direction == GDK_SCROLL_UP) {
change_velocities (true, fine, false, together);
*/
bool unmodified = Keyboard::no_modifier_keys_pressed (ev);
-
+
if (unmodified && (ev->keyval == GDK_Alt_L || ev->keyval == GDK_Alt_R)) {
_mouse_state = SelectTouchDragging;
return true;
} else if (ev->keyval == GDK_Escape && unmodified) {
- clear_selection();
+ clear_editor_note_selection ();
_mouse_state = None;
- } else if (unmodified && (ev->keyval == GDK_comma || ev->keyval == GDK_period)) {
+ } else if (ev->keyval == GDK_comma || ev->keyval == GDK_period) {
bool start = (ev->keyval == GDK_comma);
bool end = (ev->keyval == GDK_period);
bool shorter = Keyboard::modifier_state_contains (ev->state, Keyboard::PrimaryModifier);
bool fine = Keyboard::modifier_state_contains (ev->state, Keyboard::SecondaryModifier);
- change_note_lengths (fine, shorter, 0.0, start, end);
+ change_note_lengths (fine, shorter, Evoral::Beats(), start, end);
return true;
delete_selection();
return true;
- } else if (ev->keyval == GDK_Tab) {
-
- if (Keyboard::modifier_state_contains (ev->state, Keyboard::PrimaryModifier)) {
- goto_previous_note (Keyboard::modifier_state_contains (ev->state, Keyboard::TertiaryModifier));
- } else {
- goto_next_note (Keyboard::modifier_state_contains (ev->state, Keyboard::TertiaryModifier));
- }
- return true;
-
- } else if (ev->keyval == GDK_ISO_Left_Tab) {
+ } else if (ev->keyval == GDK_Tab || ev->keyval == GDK_ISO_Left_Tab) {
- /* Shift-TAB generates ISO Left Tab, for some reason */
+ trackview.editor().begin_reversible_selection_op (X_("Select Adjacent Note"));
if (Keyboard::modifier_state_contains (ev->state, Keyboard::PrimaryModifier)) {
goto_previous_note (Keyboard::modifier_state_contains (ev->state, Keyboard::TertiaryModifier));
} else {
goto_next_note (Keyboard::modifier_state_contains (ev->state, Keyboard::TertiaryModifier));
}
- return true;
+ trackview.editor().commit_reversible_selection_op();
+ return true;
} else if (ev->keyval == GDK_Up) {
}
return true;
- } else if (ev->keyval == GDK_Left && unmodified) {
+ } else if (ev->keyval == GDK_Left) {
- nudge_notes (false);
+ bool fine = !Keyboard::modifier_state_contains (ev->state, Keyboard::SecondaryModifier);
+ nudge_notes (false, fine);
return true;
- } else if (ev->keyval == GDK_Right && unmodified) {
+ } else if (ev->keyval == GDK_Right) {
- nudge_notes (true);
+ bool fine = !Keyboard::modifier_state_contains (ev->state, Keyboard::SecondaryModifier);
+ nudge_notes (true, fine);
return true;
} else if (ev->keyval == GDK_c && unmodified) {
if (_selection.empty()) {
return;
}
-
+
/* pick a note somewhat at random (since Selection is a set<>) to
* provide the "current" velocity for the dialog.
*/
* \param snap_t true to snap t to the grid, otherwise false.
*/
void
-MidiRegionView::create_note_at (framepos_t t, double y, double length, bool snap_t)
+MidiRegionView::create_note_at (framepos_t t, double y, Evoral::Beats length, bool snap_t)
{
if (length < 2 * DBL_EPSILON) {
return;
}
- MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
- MidiStreamView* const view = mtv->midi_view();
+ MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
+ MidiStreamView* const view = mtv->midi_view();
+ boost::shared_ptr<MidiRegion> mr = boost::dynamic_pointer_cast<MidiRegion> (_region);
- const double note = view->y_to_note(y);
+ if (!mr) {
+ return;
+ }
// Start of note in frames relative to region start
+ uint32_t divisions = 0;
+
if (snap_t) {
framecnt_t grid_frames;
t = snap_frame_to_grid_underneath (t, grid_frames);
+ divisions = trackview.editor().get_grid_music_divisions (0);
}
- const boost::shared_ptr<NoteType> new_note (
- new NoteType (mtv->get_channel_for_add (),
- region_frames_to_region_beats(t + _region->start()),
- length,
- (uint8_t)note, 0x40));
+
+ const MidiModel::TimeType beat_time = Evoral::Beats (trackview.session()->tempo_map().exact_beat_at_frame (_region->position() + t, divisions)
+ - (mr->beat() - mr->start_beats().to_double()));
+ const double note = view->y_to_note(y);
+ const uint8_t chan = mtv->get_channel_for_add();
+ const uint8_t velocity = get_velocity_for_add(beat_time);
+
+ const boost::shared_ptr<NoteType> new_note(
+ new NoteType (chan, beat_time, length, (uint8_t)note, velocity));
if (_model->contains (new_note)) {
return;
view->update_note_range(new_note->note());
- MidiModel::NoteDiffCommand* cmd = _model->new_note_diff_command(_("add note"));
- cmd->add (new_note);
- _model->apply_command(*trackview.session(), cmd);
+ start_note_diff_command(_("add note"));
+
+ clear_editor_note_selection ();
+ note_diff_add_note (new_note, true, false);
+
+ apply_diff();
play_midi_note (new_note);
}
void
-MidiRegionView::clear_events (bool with_selection_signal)
+MidiRegionView::clear_events ()
{
- clear_selection (with_selection_signal);
+ // clear selection without signaling
+ clear_selection_internal ();
MidiGhostRegion* gr;
for (std::vector<GhostRegion*>::iterator g = ghosts.begin(); g != ghosts.end(); ++g) {
content_connection.disconnect ();
_model->ContentsChanged.connect (content_connection, invalidator (*this), boost::bind (&MidiRegionView::redisplay_model, this), gui_context());
-
+ /* Don't signal as nobody else needs to know until selection has been altered. */
clear_events ();
if (_enable_display) {
MidiRegionView::start_note_diff_command (string name)
{
if (!_note_diff_command) {
+ trackview.editor().begin_reversible_command (name);
_note_diff_command = _model->new_note_diff_command (name);
}
}
void
MidiRegionView::note_diff_add_change (NoteBase* ev,
MidiModel::NoteDiffCommand::Property property,
- Evoral::MusicalTime val)
+ Evoral::Beats val)
{
if (_note_diff_command) {
_note_diff_command->change (ev->note(), property, val);
MidiRegionView::apply_diff (bool as_subcommand)
{
bool add_or_remove;
+ bool commit = false;
if (!_note_diff_command) {
return;
}
}
+ midi_view()->midi_track()->midi_playlist()->region_edited(
+ _region, _note_diff_command);
+
if (as_subcommand) {
_model->apply_command_as_subcommand (*trackview.session(), _note_diff_command);
} else {
_model->apply_command (*trackview.session(), _note_diff_command);
+ commit = true;
}
_note_diff_command = 0;
- midi_view()->midi_track()->playlist_modified();
if (add_or_remove) {
_marked_for_selection.clear();
}
_marked_for_velocity.clear();
+ if (commit) {
+ trackview.editor().commit_reversible_command ();
+ }
}
void
{
delete _note_diff_command;
_note_diff_command = 0;
- clear_selection();
+ clear_editor_note_selection();
}
NoteBase*
return 0;
}
+/** This version finds any canvas note matching the supplied note. */
+NoteBase*
+MidiRegionView::find_canvas_note (NoteType note)
+{
+ Events::iterator it;
+
+ for (it = _events.begin(); it != _events.end(); ++it) {
+ if (*((*it)->note()) == note) {
+ return *it;
+ }
+ }
+
+ return 0;
+}
+
void
-MidiRegionView::get_events (Events& e, Evoral::Sequence<Evoral::MusicalTime>::NoteOperator op, uint8_t val, int chan_mask)
+MidiRegionView::get_events (Events& e, Evoral::Sequence<Evoral::Beats>::NoteOperator op, uint8_t val, int chan_mask)
{
MidiModel::Notes notes;
_model->get_notes (notes, op, val, chan_mask);
void
MidiRegionView::redisplay_model()
{
- // Don't redisplay the model if we're currently recording and displaying that
if (_active_notes) {
+ // Currently recording
+ const framecnt_t zoom = trackview.editor().get_current_zoom();
+ if (zoom != _last_display_zoom) {
+ /* Update resolved canvas notes to reflect changes in zoom without
+ touching model. Leave active notes (with length 0) alone since
+ they are being extended. */
+ for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
+ if ((*i)->note()->length() > 0) {
+ update_note(*i);
+ }
+ }
+ _last_display_zoom = zoom;
+ }
return;
}
MidiModel::Notes& notes (_model->notes());
_optimization_iterator = _events.begin();
- bool empty_when_starting = !_events.empty();
+ bool empty_when_starting = _events.empty();
+ NoteBase* cne;
for (MidiModel::Notes::iterator n = notes.begin(); n != notes.end(); ++n) {
boost::shared_ptr<NoteType> note (*n);
- NoteBase* cne;
bool visible;
if (note_in_region_range (note, visible)) {
- if (empty_when_starting && (cne = find_canvas_note (note)) != 0) {
-
- cne->validate ();
-
- Note* cn;
- Hit* ch;
-
- if ((cn = dynamic_cast<Note*>(cne)) != 0) {
- update_note (cn);
- } else if ((ch = dynamic_cast<Hit*>(cne)) != 0) {
- update_hit (ch);
- }
+ if (!empty_when_starting && (cne = find_canvas_note (note)) != 0) {
if (visible) {
+ cne->validate ();
+ update_note (cne);
cne->show ();
} else {
cne->hide ();
} else {
- add_note (note, visible);
+ cne = add_note (note, visible);
+ }
+
+ set<boost::shared_ptr<NoteType> >::iterator it;
+ for (it = _pending_note_selection.begin(); it != _pending_note_selection.end(); ++it) {
+ if (*(*it) == *note) {
+ add_to_selection (cne);
+ }
}
} else {
- if (empty_when_starting && (cne = find_canvas_note (note)) != 0) {
+ if (!empty_when_starting && (cne = find_canvas_note (note)) != 0) {
cne->validate ();
cne->hide ();
}
}
}
-
/* remove note items that are no longer valid */
- if (empty_when_starting) {
+ if (!empty_when_starting) {
for (Events::iterator i = _events.begin(); i != _events.end(); ) {
if (!(*i)->valid ()) {
-
+
for (vector<GhostRegion*>::iterator j = ghosts.begin(); j != ghosts.end(); ++j) {
MidiGhostRegion* gr = dynamic_cast<MidiGhostRegion*> (*j);
if (gr) {
gr->remove_note (*i);
}
}
-
+
delete *i;
i = _events.erase (i);
-
+
} else {
++i;
}
_marked_for_selection.clear ();
_marked_for_velocity.clear ();
+ _pending_note_selection.clear ();
/* we may have caused _events to contain things out of order (e.g. if a note
moved earlier or later). we don't generally need them in time order, but
bool have_periodic_system_messages = false;
bool display_periodic_messages = true;
- if (!Config->get_never_display_periodic_midi()) {
+ if (!UIConfiguration::instance().get_never_display_periodic_midi()) {
for (MidiModel::SysExes::const_iterator i = _model->sysexes().begin(); i != _model->sysexes().end(); ++i) {
- const boost::shared_ptr<const Evoral::MIDIEvent<Evoral::MusicalTime> > mev =
- boost::static_pointer_cast<const Evoral::MIDIEvent<Evoral::MusicalTime> > (*i);
-
+ const boost::shared_ptr<const Evoral::MIDIEvent<Evoral::Beats> > mev =
+ boost::static_pointer_cast<const Evoral::MIDIEvent<Evoral::Beats> > (*i);
+
if (mev) {
if (mev->is_spp() || mev->is_mtc_quarter() || mev->is_mtc_full()) {
have_periodic_system_messages = true;
}
}
}
-
+
if (have_periodic_system_messages) {
double zoom = trackview.editor().get_current_zoom (); // frames per pixel
-
+
/* get an approximate value for the number of samples per video frame */
-
+
double video_frame = trackview.session()->frame_rate() * (1.0/30);
-
+
/* if we are zoomed out beyond than the cutoff (i.e. more
* frames per pixel than frames per 4 video frames), don't
* show periodic sysex messages.
*/
-
+
if (zoom > (video_frame*4)) {
display_periodic_messages = false;
- }
+ }
}
} else {
display_periodic_messages = false;
for (MidiModel::SysExes::const_iterator i = _model->sysexes().begin(); i != _model->sysexes().end(); ++i) {
- const boost::shared_ptr<const Evoral::MIDIEvent<Evoral::MusicalTime> > mev =
- boost::static_pointer_cast<const Evoral::MIDIEvent<Evoral::MusicalTime> > (*i);
+ const boost::shared_ptr<const Evoral::MIDIEvent<Evoral::Beats> > mev =
+ boost::static_pointer_cast<const Evoral::MIDIEvent<Evoral::Beats> > (*i);
- Evoral::MusicalTime time = (*i)->time();
+ Evoral::Beats time = (*i)->time();
if (mev) {
if (mev->is_spp() || mev->is_mtc_quarter() || mev->is_mtc_full()) {
{
in_destructor = true;
- trackview.editor().verbose_cursor()->hide ();
-
- note_delete_connection.disconnect ();
+ hide_verbose_cursor ();
delete _list_editor;
end_write();
}
- _selection_cleared_connection.disconnect ();
-
_selection.clear();
- clear_events (false);
+ clear_events ();
delete _note_group;
delete _note_diff_command;
delete _step_edit_cursor;
- delete _temporary_note_group;
}
void
MidiRegionView::region_resized (const PropertyChange& what_changed)
{
- RegionView::region_resized(what_changed);
+ RegionView::region_resized(what_changed); // calls RegionView::set_duration()
if (what_changed.contains (ARDOUR::Properties::position)) {
- set_duration(_region->length(), 0);
- if (_enable_display) {
- redisplay_model();
- }
+ _region_relative_time_converter.set_origin_b(_region->position());
+ _region_relative_time_converter_double.set_origin_b(_region->position());
+ /* reset_width dependent_items() redisplays model */
+
+ }
+
+ if (what_changed.contains (ARDOUR::Properties::start) ||
+ what_changed.contains (ARDOUR::Properties::position)) {
+ _source_relative_time_converter.set_origin_b (_region->position() - _region->start());
+ }
+ /* catch end and start trim so we can update the view*/
+ if (!what_changed.contains (ARDOUR::Properties::start) &&
+ what_changed.contains (ARDOUR::Properties::length)) {
+ enable_display (true);
+ } else if (what_changed.contains (ARDOUR::Properties::start) &&
+ what_changed.contains (ARDOUR::Properties::length)) {
+ enable_display (true);
}
}
void
MidiRegionView::set_height (double height)
{
- static const double FUDGE = 2.0;
- const double old_height = _height;
+ double old_height = _height;
RegionView::set_height(height);
- _height = height - FUDGE;
- apply_note_range(midi_stream_view()->lowest_note(),
- midi_stream_view()->highest_note(),
- height != old_height + FUDGE);
+ apply_note_range (midi_stream_view()->lowest_note(),
+ midi_stream_view()->highest_note(),
+ height != old_height);
if (name_text) {
name_text->raise_to_top();
if (Note* cnote = dynamic_cast<Note*>(event)) {
- const double y0 = midi_stream_view()->note_to_y(note->note());
- const double y1 = y0 + floor(midi_stream_view()->note_height());
-
+ 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)) {
-
- const double diamond_size = update_hit (chit);
-
- chit->set_height (diamond_size);
+ update_hit (chit);
}
}
}
GhostRegion*
MidiRegionView::add_ghost (TimeAxisView& tv)
{
- Note* note;
-
double unit_position = _region->position () / samples_per_pixel;
MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*>(&tv);
MidiGhostRegion* ghost;
/* if ghost is inserted into midi track, use a dedicated midi ghost canvas group
to allow having midi notes on top of note lines and waveforms.
*/
- ghost = new MidiGhostRegion (*mtv->midi_view(), trackview, unit_position);
+ ghost = new MidiGhostRegion (*this, *mtv->midi_view(), trackview, unit_position);
} else {
- ghost = new MidiGhostRegion (tv, trackview, unit_position);
+ ghost = new MidiGhostRegion (*this, tv, trackview, unit_position);
}
for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
- if ((note = dynamic_cast<Note*>(*i)) != 0) {
- ghost->add_note(note);
- }
+ ghost->add_note(*i);
}
ghost->set_height ();
ghost->set_duration (_region->length() / samples_per_pixel);
ghosts.push_back (ghost);
- GhostRegion::CatchDeletion.connect (*this, invalidator (*this), boost::bind (&RegionView::remove_ghost, this, _1), gui_context());
-
return ghost;
}
/** Resolve an active MIDI note (while recording).
*/
void
-MidiRegionView::resolve_note(uint8_t note, double end_time)
+MidiRegionView::resolve_note(uint8_t note, Evoral::Beats end_time)
{
if (midi_view()->note_mode() != Sustained) {
return;
}
if (_active_notes && _active_notes[note]) {
+ /* Set note length so update_note() works. Note this is a local note
+ for recording, not from a model, so we can safely mess with it. */
+ _active_notes[note]->note()->set_length(
+ end_time - _active_notes[note]->note()->time());
- /* XXX is end_time really region-centric? I think so, because
- this is a new region that we're recording, so source zero is
- the same as region zero
- */
+ /* End time is relative to the region being recorded. */
const framepos_t end_time_frames = region_beats_to_region_frames(end_time);
_active_notes[note]->set_x1 (trackview.editor().sample_to_pixel(end_time_frames));
- _active_notes[note]->set_outline_what (0xf);
+ _active_notes[note]->set_outline_all ();
_active_notes[note] = 0;
}
}
return;
}
- for (unsigned i=0; i < 128; ++i) {
+ for (unsigned i = 0; i < 128; ++i) {
if (_active_notes[i]) {
- _active_notes[i]->set_x1 (trackview.editor().sample_to_pixel(_region->length()));
+ _active_notes[i]->set_x1(
+ trackview.editor().sample_to_pixel(_region->length()));
}
}
}
-
void
MidiRegionView::play_midi_note(boost::shared_ptr<NoteType> note)
{
- if (_no_sound_notes || !Config->get_sound_midi_notes()) {
+ if (_no_sound_notes || !UIConfiguration::instance().get_sound_midi_notes()) {
return;
}
void
MidiRegionView::start_playing_midi_note(boost::shared_ptr<NoteType> note)
{
- if (_no_sound_notes || !Config->get_sound_midi_notes()) {
- return;
- }
-
- RouteUI* route_ui = dynamic_cast<RouteUI*> (&trackview);
-
- if (!route_ui || !route_ui->midi_track()) {
- return;
- }
-
- delete _note_player;
- _note_player = new NotePlayer (route_ui->midi_track ());
- _note_player->add (note);
- _note_player->on ();
+ const std::vector< boost::shared_ptr<NoteType> > notes(1, note);
+ start_playing_midi_chord(notes);
}
void
MidiRegionView::start_playing_midi_chord (vector<boost::shared_ptr<NoteType> > notes)
{
- if (_no_sound_notes || !Config->get_sound_midi_notes()) {
+ if (_no_sound_notes || !UIConfiguration::instance().get_sound_midi_notes()) {
return;
}
return;
}
- delete _note_player;
- _note_player = new NotePlayer (route_ui->midi_track());
+ NotePlayer* player = new NotePlayer (route_ui->midi_track());
for (vector<boost::shared_ptr<NoteType> >::iterator n = notes.begin(); n != notes.end(); ++n) {
- _note_player->add (*n);
+ player->add (*n);
}
- _note_player->on ();
+ player->play ();
}
bool
MidiRegionView::note_in_region_range (const boost::shared_ptr<NoteType> note, bool& visible) const
{
- const framepos_t note_start_frames = source_beats_to_region_frames (note->time());
- bool outside = (note_start_frames < 0) || (note_start_frames > _region->last_frame());
+ const boost::shared_ptr<ARDOUR::MidiRegion> midi_reg = midi_region();
+ const bool outside = (note->time() < midi_reg->start_beats() ||
+ note->time() > midi_reg->start_beats() + midi_reg->length_beats());
visible = (note->note() >= midi_stream_view()->lowest_note()) &&
(note->note() <= midi_stream_view()->highest_note());
return !outside;
}
+void
+MidiRegionView::update_note (NoteBase* note, bool update_ghost_regions)
+{
+ Note* sus = NULL;
+ Hit* hit = NULL;
+ if ((sus = dynamic_cast<Note*>(note))) {
+ update_sustained(sus, update_ghost_regions);
+ } else if ((hit = dynamic_cast<Hit*>(note))) {
+ update_hit(hit, update_ghost_regions);
+ }
+}
+
/** Update a canvas note's size from its model note.
* @param ev Canvas note to update.
* @param update_ghost_regions true to update the note in any ghost regions that we have, otherwise false.
*/
void
-MidiRegionView::update_note (Note* ev, bool update_ghost_regions)
+MidiRegionView::update_sustained (Note* ev, bool update_ghost_regions)
{
+ TempoMap& map (trackview.session()->tempo_map());
+ const boost::shared_ptr<ARDOUR::MidiRegion> mr = midi_region();
boost::shared_ptr<NoteType> note = ev->note();
- const double x = trackview.editor().sample_to_pixel (source_beats_to_region_frames (note->time()));
- const double y0 = midi_stream_view()->note_to_y(note->note());
-
- ev->set_x0 (x);
- ev->set_y0 (y0);
+ const framepos_t note_start_frames = map.frame_at_beat (_region->beat() - mr->start_beats().to_double()
+ + note->time().to_double()) - _region->position();
- /* trim note display to not overlap the end of its region */
+ 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()));
+ double y1;/* trim note display to not overlap the end of its region */
if (note->length() > 0) {
- const framepos_t note_end_frames = min (source_beats_to_region_frames (note->end_time()), _region->length());
- ev->set_x1 (trackview.editor().sample_to_pixel (note_end_frames));
+ Evoral::Beats note_end_time = note->end_time();
+
+ if (note->end_time() > mr->start_beats() + mr->length_beats()) {
+ note_end_time = mr->start_beats() + mr->length_beats();
+ }
+
+ const framepos_t note_end_frames = map.frame_at_beat (_region->beat() - mr->start_beats().to_double()
+ + note_end_time.to_double()) - _region->position();
+
+ x1 = std::max(1., trackview.editor().sample_to_pixel (note_end_frames)) - 1;
} else {
- ev->set_x1 (trackview.editor().sample_to_pixel (_region->length()));
+ x1 = std::max(1., trackview.editor().sample_to_pixel (_region->length())) - 1;
}
- ev->set_y1 (y0 + floor(midi_stream_view()->note_height()));
+ y1 = y0 + std::max(1., floor(midi_stream_view()->note_height()) - 1);
+
+ ArdourCanvas::Rect rect (x0, y0, x1, y1);
+ ev->set (rect);
- if (note->length() == 0) {
+ if (!note->length()) {
if (_active_notes && note->note() < 128) {
- // If this note is already active there's a stuck note,
- // finish the old note rectangle
- if (_active_notes[note->note()]) {
- Note* const old_rect = _active_notes[note->note()];
- boost::shared_ptr<NoteType> old_note = old_rect->note();
- old_rect->set_x1 (x);
- old_rect->set_outline_what (0xF);
+ Note* const old_rect = _active_notes[note->note()];
+ if (old_rect) {
+ /* There is an active note on this key, so we have a stuck
+ note. Finish the old rectangle here. */
+ old_rect->set_x1 (x1);
+ old_rect->set_outline_all ();
}
_active_notes[note->note()] = ev;
}
/* outline all but right edge */
- ev->set_outline_what (0x1 & 0x4 & 0x8);
+ ev->set_outline_what (ArdourCanvas::Rectangle::What (
+ ArdourCanvas::Rectangle::TOP|
+ ArdourCanvas::Rectangle::LEFT|
+ ArdourCanvas::Rectangle::BOTTOM));
} else {
/* outline all edges */
- ev->set_outline_what (0xF);
+ ev->set_outline_all ();
}
-
+
+ // Update color in case velocity has changed
+ //const uint32_t base_col = ev->base_color();
+ //ev->set_fill_color(base_col);
+ //ev->set_outline_color(ev->calculate_outline(base_col, ev->selected()));
+
if (update_ghost_regions) {
for (std::vector<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
MidiGhostRegion* gr = dynamic_cast<MidiGhostRegion*> (*i);
}
}
-double
-MidiRegionView::update_hit (Hit* ev)
+void
+MidiRegionView::update_hit (Hit* ev, bool update_ghost_regions)
{
boost::shared_ptr<NoteType> note = ev->note();
- const framepos_t note_start_frames = source_beats_to_region_frames(note->time());
+ const framepos_t note_start_frames = trackview.session()->tempo_map().frame_at_beat (_region->beat() - midi_region()->start_beats().to_double()
+ + note->time().to_double()) - _region->position();
const double x = trackview.editor().sample_to_pixel(note_start_frames);
- const double diamond_size = midi_stream_view()->note_height() / 2.0;
- const double y = midi_stream_view()->note_to_y(note->note()) + ((diamond_size-2) / 4.0);
+ 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;
+
+ // see DnD note in MidiRegionView::apply_note_range() above
+ if (y <= 0 || y >= _height) {
+ ev->hide();
+ } else {
+ ev->show();
+ }
ev->set_position (ArdourCanvas::Duple (x, y));
+ ev->set_height (diamond_size);
+
+ // Update color in case velocity has changed
+ ev->set_fill_color(ev->base_color());
+ ev->set_outline_color(ev->calculate_outline(ev->base_color(), ev->selected()));
- return diamond_size;
+ if (update_ghost_regions) {
+ for (std::vector<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
+ MidiGhostRegion* gr = dynamic_cast<MidiGhostRegion*> (*i);
+ if (gr) {
+ gr->update_note (ev);
+ }
+ }
+ }
}
/** Add a MIDI note to the view (with length).
* notes, and resolve_note should be called when the corresponding note off
* event arrives, to properly display the note.
*/
-void
+NoteBase*
MidiRegionView::add_note(const boost::shared_ptr<NoteType> note, bool visible)
{
NoteBase* event = 0;
- //ArdourCanvas::Group* const group = (ArdourCanvas::Group*) get_canvas_group();
-
if (midi_view()->note_mode() == Sustained) {
Note* ev_rect = new Note (*this, _note_group, note);
- update_note (ev_rect);
+ update_sustained (ev_rect);
event = ev_rect;
- MidiGhostRegion* gr;
-
- for (std::vector<GhostRegion*>::iterator g = ghosts.begin(); g != ghosts.end(); ++g) {
- if ((gr = dynamic_cast<MidiGhostRegion*>(*g)) != 0) {
- gr->add_note(ev_rect);
- }
- }
-
} else if (midi_view()->note_mode() == Percussive) {
- const double diamond_size = midi_stream_view()->note_height() / 2.0;
+ const double diamond_size = std::max(1., floor(midi_stream_view()->note_height()) - 2.);
Hit* ev_diamond = new Hit (*this, _note_group, diamond_size, note);
}
if (event) {
+ MidiGhostRegion* gr;
+
+ for (std::vector<GhostRegion*>::iterator g = ghosts.begin(); g != ghosts.end(); ++g) {
+ if ((gr = dynamic_cast<MidiGhostRegion*>(*g)) != 0) {
+ gr->add_note(event);
+ }
+ }
+
if (_marked_for_selection.find(note) != _marked_for_selection.end()) {
note_selected(event, true);
}
MidiStreamView* const view = mtv->midi_view();
view->update_note_range (note->note());
+ return event;
}
void
MidiRegionView::step_add_note (uint8_t channel, uint8_t number, uint8_t velocity,
- Evoral::MusicalTime pos, Evoral::MusicalTime len)
+ Evoral::Beats pos, Evoral::Beats len)
{
boost::shared_ptr<NoteType> new_note (new NoteType (channel, pos, len, number, velocity));
framepos_t region_end = _region->last_frame();
if (end_frame > region_end) {
- _region->set_length (end_frame - _region->position());
+ /* XX sets length in beats from audio space. make musical */
+ _region->set_length (end_frame - _region->position(), 0);
}
MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
view->update_note_range(new_note->note());
_marked_for_selection.clear ();
- clear_selection ();
start_note_diff_command (_("step add"));
+
+ clear_editor_note_selection ();
note_diff_add_note (new_note, true, false);
+
apply_diff();
// last_step_edit_note = new_note;
}
void
-MidiRegionView::step_sustain (Evoral::MusicalTime beats)
+MidiRegionView::step_sustain (Evoral::Beats beats)
{
change_note_lengths (false, false, beats, false, true);
}
/// Return true iff @p pc applies to the given time on the given channel.
static bool
-patch_applies (const ARDOUR::MidiModel::constPatchChangePtr pc, double time, uint8_t channel)
+patch_applies (const ARDOUR::MidiModel::constPatchChangePtr pc, Evoral::Beats time, uint8_t channel)
{
return pc->time() <= time && pc->channel() == channel;
}
-
-void
-MidiRegionView::get_patch_key_at (double time, uint8_t channel, MIDI::Name::PatchPrimaryKey& key) const
+
+void
+MidiRegionView::get_patch_key_at (Evoral::Beats time, uint8_t channel, MIDI::Name::PatchPrimaryKey& key) const
{
// The earliest event not before time
MidiModel::PatchChanges::iterator i = _model->patch_change_lower_bound (time);
}
if (i != _model->patch_changes().end() && patch_applies(*i, time, channel)) {
- key.bank_number = (*i)->bank();
- key.program_number = (*i)->program ();
+ key.set_bank((*i)->bank());
+ key.set_program((*i)->program ());
} else {
- key.bank_number = key.program_number = 0;
- }
-
- if (!key.is_sane()) {
- error << string_compose(_("insane MIDI patch key %1:%2"),
- key.bank_number, key.program_number) << endmsg;
+ key.set_bank(0);
+ key.set_program(0);
}
}
void
MidiRegionView::change_patch_change (PatchChange& pc, const MIDI::Name::PatchPrimaryKey& new_patch)
{
- MidiModel::PatchChangeDiffCommand* c = _model->new_patch_change_diff_command (_("alter patch change"));
+ string name = _("alter patch change");
+ trackview.editor().begin_reversible_command (name);
+ MidiModel::PatchChangeDiffCommand* c = _model->new_patch_change_diff_command (name);
- if (pc.patch()->program() != new_patch.program_number) {
- c->change_program (pc.patch (), new_patch.program_number);
+ if (pc.patch()->program() != new_patch.program()) {
+ c->change_program (pc.patch (), new_patch.program());
}
- int const new_bank = new_patch.bank_number;
+ int const new_bank = new_patch.bank();
if (pc.patch()->bank() != new_bank) {
c->change_bank (pc.patch (), new_bank);
}
_model->apply_command (*trackview.session(), c);
+ trackview.editor().commit_reversible_command ();
_patch_changes.clear ();
display_patch_changes ();
}
void
-MidiRegionView::change_patch_change (MidiModel::PatchChangePtr old_change, const Evoral::PatchChange<Evoral::MusicalTime> & new_change)
+MidiRegionView::change_patch_change (MidiModel::PatchChangePtr old_change, const Evoral::PatchChange<Evoral::Beats> & new_change)
{
- MidiModel::PatchChangeDiffCommand* c = _model->new_patch_change_diff_command (_("alter patch change"));
+ string name = _("alter patch change");
+ trackview.editor().begin_reversible_command (name);
+ MidiModel::PatchChangeDiffCommand* c = _model->new_patch_change_diff_command (name);
if (old_change->time() != new_change.time()) {
c->change_time (old_change, new_change.time());
}
_model->apply_command (*trackview.session(), c);
+ trackview.editor().commit_reversible_command ();
_patch_changes.clear ();
display_patch_changes ();
* MidiTimeAxisView::get_channel_for_add())
*/
void
-MidiRegionView::add_patch_change (framecnt_t t, Evoral::PatchChange<Evoral::MusicalTime> const & patch)
+MidiRegionView::add_patch_change (framecnt_t t, Evoral::PatchChange<Evoral::Beats> const & patch)
{
MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
+ string name = _("add patch change");
- MidiModel::PatchChangeDiffCommand* c = _model->new_patch_change_diff_command (_("add patch change"));
+ trackview.editor().begin_reversible_command (name);
+ MidiModel::PatchChangeDiffCommand* c = _model->new_patch_change_diff_command (name);
c->add (MidiModel::PatchChangePtr (
- new Evoral::PatchChange<Evoral::MusicalTime> (
+ new Evoral::PatchChange<Evoral::Beats> (
absolute_frames_to_source_beats (_region->position() + t),
mtv->get_channel_for_add(), patch.program(), patch.bank()
)
);
_model->apply_command (*trackview.session(), c);
+ trackview.editor().commit_reversible_command ();
_patch_changes.clear ();
display_patch_changes ();
}
void
-MidiRegionView::move_patch_change (PatchChange& pc, Evoral::MusicalTime t)
+MidiRegionView::move_patch_change (PatchChange& pc, Evoral::Beats t)
{
+ trackview.editor().begin_reversible_command (_("move patch change"));
MidiModel::PatchChangeDiffCommand* c = _model->new_patch_change_diff_command (_("move patch change"));
c->change_time (pc.patch (), t);
_model->apply_command (*trackview.session(), c);
+ trackview.editor().commit_reversible_command ();
_patch_changes.clear ();
display_patch_changes ();
void
MidiRegionView::delete_patch_change (PatchChange* pc)
{
+ trackview.editor().begin_reversible_command (_("delete patch change"));
MidiModel::PatchChangeDiffCommand* c = _model->new_patch_change_diff_command (_("delete patch change"));
c->remove (pc->patch ());
_model->apply_command (*trackview.session(), c);
+ trackview.editor().commit_reversible_command ();
_patch_changes.clear ();
display_patch_changes ();
}
void
-MidiRegionView::previous_patch (PatchChange& patch)
+MidiRegionView::step_patch (PatchChange& patch, bool bank, int delta)
{
- if (patch.patch()->program() < 127) {
- MIDI::Name::PatchPrimaryKey key = patch_change_to_patch_key (patch.patch());
- key.program_number++;
- change_patch_change (patch, key);
- }
-}
-
-void
-MidiRegionView::next_patch (PatchChange& patch)
-{
- if (patch.patch()->program() > 0) {
- MIDI::Name::PatchPrimaryKey key = patch_change_to_patch_key (patch.patch());
- key.program_number--;
- change_patch_change (patch, key);
- }
-}
-
-void
-MidiRegionView::next_bank (PatchChange& patch)
-{
- if (patch.patch()->program() < 127) {
- MIDI::Name::PatchPrimaryKey key = patch_change_to_patch_key (patch.patch());
- if (key.bank_number > 0) {
- key.bank_number--;
- change_patch_change (patch, key);
- }
- }
-}
-
-void
-MidiRegionView::previous_bank (PatchChange& patch)
-{
- if (patch.patch()->program() > 0) {
- MIDI::Name::PatchPrimaryKey key = patch_change_to_patch_key (patch.patch());
- if (key.bank_number < 127) {
- key.bank_number++;
- change_patch_change (patch, key);
- }
+ MIDI::Name::PatchPrimaryKey key = patch_change_to_patch_key(patch.patch());
+ if (bank) {
+ key.set_bank(key.bank() + delta);
+ } else {
+ key.set_program(key.program() + delta);
}
+ change_patch_change(patch, key);
}
void
-MidiRegionView::maybe_remove_deleted_note_from_selection (NoteBase* cne)
+MidiRegionView::note_deleted (NoteBase* cne)
{
if (_selection.empty()) {
return;
_selection.clear();
apply_diff ();
+ hide_verbose_cursor ();
}
void
_note_diff_command->remove (n);
apply_diff ();
- trackview.editor().verbose_cursor()->hide ();
+ hide_verbose_cursor ();
+}
+
+void
+MidiRegionView::clear_editor_note_selection ()
+{
+ DEBUG_TRACE(DEBUG::Selection, "MRV::clear_editor_note_selection\n");
+ PublicEditor& editor(trackview.editor());
+ editor.get_selection().clear_midi_notes();
}
void
-MidiRegionView::clear_selection_except (NoteBase* ev, bool signal)
+MidiRegionView::clear_selection ()
{
- for (Selection::iterator i = _selection.begin(); i != _selection.end(); ) {
- if ((*i) != ev) {
- Selection::iterator tmp = i;
- ++tmp;
+ clear_selection_internal();
+ PublicEditor& editor(trackview.editor());
+ editor.get_selection().remove(this);
+}
- (*i)->set_selected (false);
- (*i)->hide_velocity ();
- _selection.erase (i);
+void
+MidiRegionView::clear_selection_internal ()
+{
+ DEBUG_TRACE(DEBUG::Selection, "MRV::clear_selection_internal\n");
- i = tmp;
- } else {
- ++i;
- }
+ for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
+ (*i)->set_selected(false);
+ (*i)->hide_velocity();
}
+ _selection.clear();
- /* this does not change the status of this regionview w.r.t the editor
- selection.
- */
-
- if (signal) {
- SelectionCleared (this); /* EMIT SIGNAL */
+ if (_entered) {
+ // Clearing selection entirely, ungrab keyboard
+ Keyboard::magic_widget_drop_focus();
+ _grabbed_keyboard = false;
}
}
void
MidiRegionView::unique_select(NoteBase* ev)
{
- clear_selection_except (ev);
-
- /* don't bother with checking to see if we should remove this
- regionview from the editor selection, since we're about to add
- another note, and thus put/keep this regionview in the editor
- selection anyway.
- */
-
- if (!ev->selected()) {
- add_to_selection (ev);
- }
+ clear_editor_note_selection();
+ add_to_selection(ev);
}
void
MidiRegionView::select_all_notes ()
{
- clear_selection ();
+ clear_editor_note_selection ();
for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
add_to_selection (*i);
void
MidiRegionView::select_range (framepos_t start, framepos_t end)
{
- clear_selection ();
+ clear_editor_note_selection ();
for (Events::iterator i = _events.begin(); i != _events.end(); ++i) {
framepos_t t = source_beats_to_absolute_frames((*i)->note()->time());
}
}
+/** Used for selection undo/redo.
+ The requested notes most likely won't exist in the view until the next model redisplay.
+*/
+void
+MidiRegionView::select_notes (list<boost::shared_ptr<NoteType> > notes)
+{
+ NoteBase* cne;
+ list<boost::shared_ptr<NoteType> >::iterator n;
+
+ for (n = notes.begin(); n != notes.end(); ++n) {
+ if ((cne = find_canvas_note(*(*n))) != 0) {
+ add_to_selection (cne);
+ } else {
+ _pending_note_selection.insert(*n);
+ }
+ }
+}
+
void
MidiRegionView::select_matching_notes (uint8_t notenum, uint16_t channel_mask, bool add, bool extend)
{
uint8_t high_note = 0;
MidiModel::Notes& notes (_model->notes());
_optimization_iterator = _events.begin();
-
+
if (extend && !have_selection) {
extend = false;
}
/* scan existing selection to get note range */
-
+
for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
if ((*i)->note()->note() < low_note) {
low_note = (*i)->note()->note();
high_note = (*i)->note()->note();
}
}
-
+
if (!add) {
- clear_selection ();
+ clear_editor_note_selection ();
if (!extend && (low_note == high_note) && (high_note == notenum)) {
/* only note previously selected is the one we are
MidiRegionView::note_selected (NoteBase* ev, bool add, bool extend)
{
if (!add) {
- clear_selection_except (ev);
- if (!_selection.empty()) {
- PublicEditor& editor (trackview.editor());
- editor.get_selection().add (this);
- }
+ clear_editor_note_selection();
+ add_to_selection (ev);
}
if (!extend) {
} else {
/* find end of latest note selected, select all between that and the start of "ev" */
- Evoral::MusicalTime earliest = Evoral::MaxMusicalTime;
- Evoral::MusicalTime latest = 0;
+ Evoral::Beats earliest = Evoral::MaxBeats;
+ Evoral::Beats latest = Evoral::Beats();
for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
if ((*i)->note()->end_time() > latest) {
}
void
-MidiRegionView::update_drag_selection(double x0, double x1, double y0, double y1, bool extend)
+MidiRegionView::update_drag_selection(framepos_t start, framepos_t end, double gy0, double gy1, bool extend)
{
+ PublicEditor& editor = trackview.editor();
+
+ // Convert to local coordinates
+ const framepos_t p = _region->position();
+ const double y = midi_view()->y_position();
+ const double x0 = editor.sample_to_pixel(max((framepos_t)0, start - p));
+ const double x1 = editor.sample_to_pixel(max((framepos_t)0, end - p));
+ const double y0 = max(0.0, gy0 - y);
+ const double y1 = max(0.0, gy1 - y);
+
// TODO: Make this faster by storing the last updated selection rect, and only
// adjusting things that are in the area that appears/disappeared.
// We probably need a tree to be able to find events in O(log(n)) time.
remove_from_selection (*i);
}
}
+
+ typedef RouteTimeAxisView::AutomationTracks ATracks;
+ typedef std::list<Selectable*> Selectables;
+
+ /* Add control points to selection. */
+ const ATracks& atracks = midi_view()->automation_tracks();
+ Selectables selectables;
+ editor.get_selection().clear_points();
+ for (ATracks::const_iterator a = atracks.begin(); a != atracks.end(); ++a) {
+ a->second->get_selectables(start, end, gy0, gy1, selectables);
+ for (Selectables::const_iterator s = selectables.begin(); s != selectables.end(); ++s) {
+ ControlPoint* cp = dynamic_cast<ControlPoint*>(*s);
+ if (cp) {
+ editor.get_selection().add(cp);
+ }
+ }
+ a->second->set_selected_points(editor.get_selection().points);
+ }
}
void
if (i != _selection.end()) {
_selection.erase (i);
+ if (_selection.empty() && _grabbed_keyboard) {
+ // Ungrab keyboard
+ Keyboard::magic_widget_drop_focus();
+ _grabbed_keyboard = false;
+ }
}
ev->set_selected (false);
void
MidiRegionView::add_to_selection (NoteBase* ev)
{
- bool add_mrv_selection = false;
-
- if (_selection.empty()) {
- add_mrv_selection = true;
- }
+ const bool selection_was_empty = _selection.empty();
if (_selection.insert (ev).second) {
ev->set_selected (true);
start_playing_midi_note ((ev)->note());
+ if (selection_was_empty && _entered) {
+ // Grab keyboard for moving notes with arrow keys
+ Keyboard::magic_widget_grab_focus();
+ _grabbed_keyboard = true;
+ }
}
- if (add_mrv_selection) {
+ if (selection_was_empty) {
PublicEditor& editor (trackview.editor());
editor.get_selection().add (this);
}
{
typedef vector<boost::shared_ptr<NoteType> > PossibleChord;
PossibleChord to_play;
- Evoral::MusicalTime earliest = Evoral::MaxMusicalTime;
+ Evoral::Beats earliest = Evoral::MaxBeats;
for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
if ((*i)->note()->time() < earliest) {
}
for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
- if (Evoral::musical_time_equal ((*i)->note()->time(), earliest)) {
+ if ((*i)->note()->time() == earliest) {
to_play.push_back ((*i)->note());
}
(*i)->move_event(dx, dy);
}
- if (dy && !_selection.empty() && !_no_sound_notes && Config->get_sound_midi_notes()) {
+ if (dy && !_selection.empty() && !_no_sound_notes && UIConfiguration::instance().get_sound_midi_notes()) {
if (to_play.size() > 1) {
start_note_diff_command (_("move notes"));
for (Selection::iterator i = _selection.begin(); i != _selection.end() ; ++i) {
-
+
framepos_t new_frames = source_beats_to_absolute_frames ((*i)->note()->time()) + dt;
- Evoral::MusicalTime new_time = absolute_frames_to_source_beats (new_frames);
+ Evoral::Beats new_time = absolute_frames_to_source_beats (new_frames);
if (new_time < 0) {
continue;
}
/** @param x Pixel relative to the region position.
+ * @param ensure_snap defaults to false. true = snap always, ignoring snap mode and magnetic snap.
+ * Used for inverting the snap logic with key modifiers and snap delta calculation.
* @return Snapped frame relative to the region position.
*/
framepos_t
-MidiRegionView::snap_pixel_to_sample(double x)
+MidiRegionView::snap_pixel_to_sample(double x, bool ensure_snap)
{
PublicEditor& editor (trackview.editor());
- return snap_frame_to_frame (editor.pixel_to_sample (x));
+ return snap_frame_to_frame (editor.pixel_to_sample (x), ensure_snap);
}
/** @param x Pixel relative to the region position.
+ * @param ensure_snap defaults to false. true = ignore magnetic snap and snap mode (used for snap delta calculation).
* @return Snapped pixel relative to the region position.
*/
double
-MidiRegionView::snap_to_pixel(double x)
+MidiRegionView::snap_to_pixel(double x, bool ensure_snap)
{
- return (double) trackview.editor().sample_to_pixel(snap_pixel_to_sample(x));
+ return (double) trackview.editor().sample_to_pixel(snap_pixel_to_sample(x, ensure_snap));
}
double
}
framepos_t
-MidiRegionView::source_beats_to_absolute_frames(double beats) const
+MidiRegionView::source_beats_to_absolute_frames(Evoral::Beats beats) const
{
/* the time converter will return the frame corresponding to `beats'
relative to the start of the source. The start of the source
return source_start + _source_relative_time_converter.to (beats);
}
-double
+Evoral::Beats
MidiRegionView::absolute_frames_to_source_beats(framepos_t frames) const
{
/* the `frames' argument needs to be converted into a frame count
}
framepos_t
-MidiRegionView::region_beats_to_region_frames(double beats) const
+MidiRegionView::region_beats_to_region_frames(Evoral::Beats beats) const
{
return _region_relative_time_converter.to(beats);
}
-double
+Evoral::Beats
MidiRegionView::region_frames_to_region_beats(framepos_t frames) const
{
return _region_relative_time_converter.from(frames);
}
+double
+MidiRegionView::region_frames_to_region_beats_double (framepos_t frames) const
+{
+ return _region_relative_time_converter_double.from(frames);
+}
+
void
MidiRegionView::begin_resizing (bool /*at_front*/)
{
resize_data->note = note;
// create a new SimpleRect from the note which will be the resize preview
- ArdourCanvas::Rectangle *resize_rect = new ArdourCanvas::Rectangle (_note_group,
+ ArdourCanvas::Rectangle *resize_rect = new ArdourCanvas::Rectangle (_note_group,
ArdourCanvas::Rect (note->x0(), note->y0(), note->x0(), note->y1()));
// calculate the colors: get the color settings
uint32_t fill_color = UINT_RGBA_CHANGE_A(
- ARDOUR_UI::config()->get_canvasvar_MidiNoteSelected(),
+ UIConfiguration::instance().color ("midi note selected"),
128);
// make the resize preview notes more transparent and bright
0.85));
resize_rect->set_outline_color (NoteBase::calculate_outline (
- ARDOUR_UI::config()->get_canvasvar_MidiNoteSelected()));
+ UIConfiguration::instance().color ("midi note selected")));
resize_data->resize_rect = resize_rect;
_resize_data.push_back(resize_data);
* a difference when multiple notes are being resized; in relative mode, each note's length is changed by the
* amount of the drag. In non-relative mode, all selected notes are set to have the same start or end point
* as the \a primary note.
+ * @param snap_delta snap offset of the primary note in pixels. used in SnapRelative SnapDelta mode.
+ * @param with_snap true if snap is to be used to determine the position, false if no snap is to be used.
*/
void
-MidiRegionView::update_resizing (NoteBase* primary, bool at_front, double delta_x, bool relative)
+MidiRegionView::update_resizing (NoteBase* primary, bool at_front, double delta_x, bool relative, double snap_delta, bool with_snap)
{
+ TempoMap& tmap (trackview.session()->tempo_map());
bool cursor_set = false;
+ bool const ensure_snap = trackview.editor().snap_mode () != SnapMagnetic;
for (std::vector<NoteResizeData *>::iterator i = _resize_data.begin(); i != _resize_data.end(); ++i) {
ArdourCanvas::Rectangle* resize_rect = (*i)->resize_rect;
if (at_front) {
if (relative) {
- current_x = canvas_note->x0() + delta_x;
+ current_x = canvas_note->x0() + delta_x + snap_delta;
} else {
- current_x = primary->x0() + delta_x;
+ current_x = primary->x0() + delta_x + snap_delta;
}
} else {
if (relative) {
- current_x = canvas_note->x1() + delta_x;
+ current_x = canvas_note->x1() + delta_x + snap_delta;
} else {
- current_x = primary->x1() + delta_x;
+ current_x = primary->x1() + delta_x + snap_delta;
}
}
+ if (current_x < 0) {
+ // This works even with snapping because RegionView::snap_frame_to_frame()
+ // snaps forward if the snapped sample is before the beginning of the region
+ current_x = 0;
+ }
+ if (current_x > trackview.editor().sample_to_pixel(_region->length())) {
+ current_x = trackview.editor().sample_to_pixel(_region->length());
+ }
+
if (at_front) {
- resize_rect->set_x0 (snap_to_pixel(current_x));
+ if (with_snap) {
+ resize_rect->set_x0 (snap_to_pixel (current_x, ensure_snap) - snap_delta);
+ } else {
+ resize_rect->set_x0 (current_x - snap_delta);
+ }
resize_rect->set_x1 (canvas_note->x1());
} else {
- resize_rect->set_x1 (snap_to_pixel(current_x));
+ if (with_snap) {
+ resize_rect->set_x1 (snap_to_pixel (current_x, ensure_snap) - snap_delta);
+ } else {
+ resize_rect->set_x1 (current_x - snap_delta);
+ }
resize_rect->set_x0 (canvas_note->x0());
}
if (!cursor_set) {
- double beats;
+ /* Convert snap delta from pixels to beats. */
+ framepos_t snap_delta_samps = trackview.editor().pixel_to_sample (snap_delta);
+ double snap_delta_beats = 0.0;
+ int sign = 1;
+
+ /* negative beat offsets aren't allowed */
+ if (snap_delta_samps > 0) {
+ snap_delta_beats = region_frames_to_region_beats_double (snap_delta_samps);
+ } else if (snap_delta_samps < 0) {
+ snap_delta_beats = region_frames_to_region_beats_double ( - snap_delta_samps);
+ sign = -1;
+ }
+
+ double snapped_x;
+ uint32_t divisions = 0;
- beats = snap_pixel_to_sample (current_x);
- beats = region_frames_to_region_beats (beats);
+ if (with_snap) {
+ snapped_x = snap_pixel_to_sample (current_x, ensure_snap);
+ divisions = trackview.editor().get_grid_music_divisions (0);
+ } else {
+ snapped_x = trackview.editor ().pixel_to_sample (current_x);
+ }
+ const Evoral::Beats beats = Evoral::Beats (tmap.exact_beat_at_frame (snapped_x + midi_region()->position(), divisions)
+ - midi_region()->beat()) + midi_region()->start_beats();
- double len;
+ Evoral::Beats len = Evoral::Beats();
if (at_front) {
if (beats < canvas_note->note()->end_time()) {
- len = canvas_note->note()->time() - beats;
+ len = canvas_note->note()->time() - beats + (sign * snap_delta_beats);
len += canvas_note->note()->length();
- } else {
- len = 0;
}
} else {
if (beats >= canvas_note->note()->time()) {
- len = beats - canvas_note->note()->time();
- } else {
- len = 0;
+ len = beats - canvas_note->note()->time() - (sign * snap_delta_beats);
}
}
+ len = std::max(Evoral::Beats(1 / 512.0), len);
+
char buf[16];
- snprintf (buf, sizeof (buf), "%.3g beats", len);
+ snprintf (buf, sizeof (buf), "%.3g beats", len.to_double());
show_verbose_cursor (buf, 0, 0);
cursor_set = true;
* Parameters the same as for \a update_resizing().
*/
void
-MidiRegionView::commit_resizing (NoteBase* primary, bool at_front, double delta_x, bool relative)
+MidiRegionView::commit_resizing (NoteBase* primary, bool at_front, double delta_x, bool relative, double snap_delta, bool with_snap)
{
- start_note_diff_command (_("resize notes"));
+ _note_diff_command = _model->new_note_diff_command (_("resize notes"));
+ TempoMap& tmap (trackview.session()->tempo_map());
+
+ /* XX why doesn't snap_pixel_to_sample() handle this properly? */
+ bool const ensure_snap = trackview.editor().snap_mode () != SnapMagnetic;
for (std::vector<NoteResizeData *>::iterator i = _resize_data.begin(); i != _resize_data.end(); ++i) {
Note* canvas_note = (*i)->note;
/* Get the new x position for this resize, which is in pixels relative
* to the region position.
*/
-
+
double current_x;
if (at_front) {
if (relative) {
- current_x = canvas_note->x0() + delta_x;
+ current_x = canvas_note->x0() + delta_x + snap_delta;
} else {
- current_x = primary->x0() + delta_x;
+ current_x = primary->x0() + delta_x + snap_delta;
}
} else {
if (relative) {
- current_x = canvas_note->x1() + delta_x;
+ current_x = canvas_note->x1() + delta_x + snap_delta;
} else {
- current_x = primary->x1() + delta_x;
+ current_x = primary->x1() + delta_x + snap_delta;
}
}
- /* Convert that to a frame within the source */
- current_x = snap_pixel_to_sample (current_x) + _region->start ();
+ if (current_x < 0) {
+ current_x = 0;
+ }
+ if (current_x > trackview.editor().sample_to_pixel(_region->length())) {
+ current_x = trackview.editor().sample_to_pixel(_region->length());
+ }
- /* and then to beats */
- current_x = region_frames_to_region_beats (current_x);
+ /* Convert snap delta from pixels to beats with sign. */
+ framepos_t snap_delta_samps = trackview.editor().pixel_to_sample (snap_delta);
+ double snap_delta_beats = 0.0;
+ int sign = 1;
- if (at_front && current_x < canvas_note->note()->end_time()) {
- note_diff_add_change (canvas_note, MidiModel::NoteDiffCommand::StartTime, current_x);
+ if (snap_delta_samps > 0) {
+ snap_delta_beats = region_frames_to_region_beats_double (snap_delta_samps);
+ } else if (snap_delta_samps < 0) {
+ snap_delta_beats = region_frames_to_region_beats_double ( - snap_delta_samps);
+ sign = -1;
+ }
- double len = canvas_note->note()->time() - current_x;
+ uint32_t divisions = 0;
+ /* Convert the new x position to a frame within the source */
+ framepos_t current_fr;
+ if (with_snap) {
+ current_fr = snap_pixel_to_sample (current_x, ensure_snap);
+ divisions = trackview.editor().get_grid_music_divisions (0);
+ } else {
+ current_fr = trackview.editor().pixel_to_sample (current_x);
+ }
+
+ /* and then to beats */
+ const Evoral::Beats x_beats = Evoral::Beats (tmap.exact_beat_at_frame (current_fr + midi_region()->position(), divisions)
+ - midi_region()->beat()) + midi_region()->start_beats();
+
+ if (at_front && x_beats < canvas_note->note()->end_time()) {
+ note_diff_add_change (canvas_note, MidiModel::NoteDiffCommand::StartTime, x_beats - (sign * snap_delta_beats));
+ Evoral::Beats len = canvas_note->note()->time() - x_beats + (sign * snap_delta_beats);
len += canvas_note->note()->length();
- if (len > 0) {
- /* XXX convert to beats */
+ if (!!len) {
note_diff_add_change (canvas_note, MidiModel::NoteDiffCommand::Length, len);
}
}
if (!at_front) {
- double len = current_x - canvas_note->note()->time();
-
- if (len > 0) {
- /* XXX convert to beats */
- note_diff_add_change (canvas_note, MidiModel::NoteDiffCommand::Length, len);
- }
+ Evoral::Beats len = std::max(Evoral::Beats(1 / 512.0),
+ x_beats - canvas_note->note()->time() - (sign * snap_delta_beats));
+ note_diff_add_change (canvas_note, MidiModel::NoteDiffCommand::Length, len);
}
delete resize_rect;
}
_resize_data.clear();
- apply_diff();
+ apply_diff(true);
}
void
}
void
-MidiRegionView::trim_note (NoteBase* event, Evoral::MusicalTime front_delta, Evoral::MusicalTime end_delta)
+MidiRegionView::trim_note (NoteBase* event, Evoral::Beats front_delta, Evoral::Beats end_delta)
{
bool change_start = false;
bool change_length = false;
- Evoral::MusicalTime new_start = 0;
- Evoral::MusicalTime new_length = 0;
+ Evoral::Beats new_start;
+ Evoral::Beats new_length;
/* NOTE: the semantics of the two delta arguments are slightly subtle:
if negative - move the end of the note earlier in time (shortening it)
*/
- if (front_delta) {
+ if (!!front_delta) {
if (front_delta < 0) {
if (event->note()->time() < -front_delta) {
- new_start = 0;
+ new_start = Evoral::Beats();
} else {
new_start = event->note()->time() + front_delta; // moves earlier
}
} else {
- Evoral::MusicalTime new_pos = event->note()->time() + front_delta;
+ Evoral::Beats new_pos = event->note()->time() + front_delta;
if (new_pos < event->note()->end_time()) {
new_start = event->note()->time() + front_delta;
}
- if (end_delta) {
+ if (!!end_delta) {
bool can_change = true;
if (end_delta < 0) {
if (event->note()->length() < -end_delta) {
}
void
-MidiRegionView::change_note_time (NoteBase* event, Evoral::MusicalTime delta, bool relative)
+MidiRegionView::change_note_time (NoteBase* event, Evoral::Beats delta, bool relative)
{
- Evoral::MusicalTime new_time;
+ Evoral::Beats new_time;
if (relative) {
if (delta < 0.0) {
if (event->note()->time() < -delta) {
- new_time = 0;
+ new_time = Evoral::Beats();
} else {
new_time = event->note()->time() + delta;
}
}
void
-MidiRegionView::change_note_length (NoteBase* event, Evoral::MusicalTime t)
+MidiRegionView::change_note_length (NoteBase* event, Evoral::Beats t)
{
note_diff_add_change (event, MidiModel::NoteDiffCommand::Length, t);
}
}
void
-MidiRegionView::change_note_lengths (bool fine, bool shorter, Evoral::MusicalTime delta, bool start, bool end)
+MidiRegionView::change_note_lengths (bool fine, bool shorter, Evoral::Beats delta, bool start, bool end)
{
- if (delta == 0.0) {
+ if (!delta) {
if (fine) {
- delta = 1.0/128.0;
+ delta = Evoral::Beats(1.0/128.0);
} else {
/* grab the current grid distance */
- bool success;
- delta = trackview.editor().get_grid_type_as_beats (success, _region->position());
- if (!success) {
- /* XXX cannot get grid type as beats ... should always be possible ... FIX ME */
- error << string_compose (_("programming error: %1"), "Grid type not available as beats - TO BE FIXED") << endmsg;
- return;
- }
+ delta = get_grid_beats(_region->position());
}
}
/* note the negation of the delta for start */
- trim_note (*i, (start ? -delta : 0), (end ? delta : 0));
+ trim_note (*i,
+ (start ? -delta : Evoral::Beats()),
+ (end ? delta : Evoral::Beats()));
i = next;
}
}
void
-MidiRegionView::nudge_notes (bool forward)
+MidiRegionView::nudge_notes (bool forward, bool fine)
{
if (_selection.empty()) {
return;
into a vector and sort before using the first one.
*/
- framepos_t ref_point = source_beats_to_absolute_frames ((*(_selection.begin()))->note()->time());
- framepos_t unused;
- framecnt_t distance;
+ const framepos_t ref_point = source_beats_to_absolute_frames ((*(_selection.begin()))->note()->time());
+ Evoral::Beats delta;
+
+ if (!fine) {
- if (trackview.editor().snap_mode() == Editing::SnapOff) {
+ /* non-fine, move by 1 bar regardless of snap */
+ delta = Evoral::Beats(trackview.session()->tempo_map().meter_at_frame (ref_point).divisions_per_bar());
+
+ } else if (trackview.editor().snap_mode() == Editing::SnapOff) {
/* grid is off - use nudge distance */
- distance = trackview.editor().get_nudge_distance (ref_point, unused);
+ framepos_t unused;
+ const framecnt_t distance = trackview.editor().get_nudge_distance (ref_point, unused);
+ delta = region_frames_to_region_beats (fabs ((double)distance));
} else {
next_pos -= 1;
}
- trackview.editor().snap_to (next_pos, (forward ? 1 : -1), false);
- distance = ref_point - next_pos;
+ trackview.editor().snap_to (next_pos, (forward ? RoundUpAlways : RoundDownAlways), false);
+ const framecnt_t distance = ref_point - next_pos;
+ delta = region_frames_to_region_beats (fabs ((double)distance));
}
- if (distance == 0) {
+ if (!delta) {
return;
}
- Evoral::MusicalTime delta = region_frames_to_region_beats (fabs ((double)distance));
-
if (!forward) {
delta = -delta;
}
void
MidiRegionView::note_entered(NoteBase* ev)
{
- Editor* editor = dynamic_cast<Editor*>(&trackview.editor());
+ _note_entered = true;
- pre_enter_cursor = editor->get_canvas_cursor ();
+ Editor* editor = dynamic_cast<Editor*>(&trackview.editor());
if (_mouse_state == SelectTouchDragging) {
+
note_selected (ev, true);
- }
- show_verbose_cursor (ev->note ());
+ } else if (editor->current_mouse_mode() == MouseContent) {
+
+ remove_ghost_note ();
+ show_verbose_cursor (ev->note ());
+
+ } else if (editor->current_mouse_mode() == MouseDraw) {
+
+ remove_ghost_note ();
+ show_verbose_cursor (ev->note ());
+ }
}
void
MidiRegionView::note_left (NoteBase*)
{
- Editor* editor = dynamic_cast<Editor*>(&trackview.editor());
+ _note_entered = false;
for (Selection::iterator i = _selection.begin(); i != _selection.end(); ++i) {
(*i)->hide_velocity ();
}
- editor->verbose_cursor()->hide ();
-
- if (pre_enter_cursor) {
- editor->set_canvas_cursor (pre_enter_cursor);
- pre_enter_cursor = 0;
- }
+ hide_verbose_cursor ();
}
void
MidiRegionView::patch_entered (PatchChange* p)
{
ostringstream s;
- /* XXX should get patch name if we can */
- s << _("Bank ") << (p->patch()->bank() + MIDI_BP_ZERO) << '\n'
- << _("Program ") << ((int) p->patch()->program()) + MIDI_BP_ZERO << '\n'
+ s << _("Bank ") << (p->patch()->bank() + MIDI_BP_ZERO) << '\n'
+ << instrument_info().get_patch_name_without (p->patch()->bank(), p->patch()->program(), p->patch()->channel()) << '\n'
<< _("Channel ") << ((int) p->patch()->channel() + 1);
show_verbose_cursor (s.str(), 10, 20);
p->item().grab_focus();
void
MidiRegionView::patch_left (PatchChange *)
{
- trackview.editor().verbose_cursor()->hide ();
+ hide_verbose_cursor ();
/* focus will transfer back via the enter-notify event sent to this
* midi region view.
*/
void
MidiRegionView::sysex_left (SysEx *)
{
- trackview.editor().verbose_cursor()->hide ();
+ hide_verbose_cursor ();
/* focus will transfer back via the enter-notify event sent to this
* midi region view.
*/
{
Editor* editor = dynamic_cast<Editor*>(&trackview.editor());
Editing::MouseMode mm = editor->current_mouse_mode();
- bool trimmable = (mm == MouseObject || mm == MouseTimeFX || mm == MouseDraw);
-
- if (trimmable && x_fraction > 0.0 && x_fraction < 0.2) {
- editor->set_canvas_cursor (editor->cursors()->left_side_trim);
- } else if (trimmable && x_fraction >= 0.8 && x_fraction < 1.0) {
- editor->set_canvas_cursor (editor->cursors()->right_side_trim);
- } else {
- if (pre_enter_cursor && can_set_cursor) {
- editor->set_canvas_cursor (pre_enter_cursor);
+ bool trimmable = (mm == MouseContent || mm == MouseTimeFX || mm == MouseDraw);
+
+ Editor::EnterContext* ctx = editor->get_enter_context(NoteItem);
+ if (can_set_cursor && ctx) {
+ if (trimmable && x_fraction > 0.0 && x_fraction < 0.2) {
+ ctx->cursor_ctx->change(editor->cursors()->left_side_trim);
+ } else if (trimmable && x_fraction >= 0.8 && x_fraction < 1.0) {
+ ctx->cursor_ctx->change(editor->cursors()->right_side_trim);
+ } else {
+ ctx->cursor_ctx->change(editor->cursors()->grabber_note);
}
}
}
-void
-MidiRegionView::set_frame_color()
+uint32_t
+MidiRegionView::get_fill_color() const
{
- uint32_t f;
-
- TimeAxisViewItem::set_frame_color ();
-
- if (!frame) {
- return;
- }
-
+ const std::string mod_name = (_dragging ? "dragging region" :
+ trackview.editor().internal_editing() ? "editable region" :
+ "midi frame base");
if (_selected) {
- f = ARDOUR_UI::config()->get_canvasvar_SelectedFrameBase();
- } else if (high_enough_for_name) {
- f= ARDOUR_UI::config()->get_canvasvar_MidiFrameBase();
- } else {
- f = fill_color;
+ return UIConfiguration::instance().color_mod ("selected region base", mod_name);
+ } else if ((!UIConfiguration::instance().get_show_name_highlight() || high_enough_for_name) &&
+ !UIConfiguration::instance().get_color_regions_using_track_color()) {
+ return UIConfiguration::instance().color_mod ("midi frame base", mod_name);
}
-
- if (!rect_visible) {
- f = UINT_RGBA_CHANGE_A (f, 0);
- }
-
- frame->set_fill_color (f);
+ return UIConfiguration::instance().color_mod (fill_color, mod_name);
}
void
return cb;
}
+/** This method handles undo */
+bool
+MidiRegionView::paste (framepos_t pos, const ::Selection& selection, PasteContext& ctx, const int32_t sub_num)
+{
+ bool commit = false;
+ // Paste notes, if available
+ MidiNoteSelection::const_iterator m = selection.midi_notes.get_nth(ctx.counts.n_notes());
+ if (m != selection.midi_notes.end()) {
+ ctx.counts.increase_n_notes();
+ if (!(*m)->empty()) { commit = true; }
+ paste_internal(pos, ctx.count, ctx.times, **m);
+ }
+
+ // Paste control points to automation children, if available
+ typedef RouteTimeAxisView::AutomationTracks ATracks;
+ const ATracks& atracks = midi_view()->automation_tracks();
+ for (ATracks::const_iterator a = atracks.begin(); a != atracks.end(); ++a) {
+ if (a->second->paste(pos, selection, ctx, sub_num)) {
+ commit = true;
+ }
+ }
+
+ if (commit) {
+ trackview.editor().commit_reversible_command ();
+ }
+ return true;
+}
+
/** This method handles undo */
void
-MidiRegionView::paste (framepos_t pos, float times, const MidiCutBuffer& mcb)
+MidiRegionView::paste_internal (framepos_t pos, unsigned paste_count, float times, const MidiCutBuffer& mcb)
{
if (mcb.empty()) {
return;
}
- DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("MIDI paste @ %1 times %2\n", pos, times));
-
- trackview.session()->begin_reversible_command (_("paste"));
-
start_note_diff_command (_("paste"));
- Evoral::MusicalTime beat_delta;
- Evoral::MusicalTime paste_pos_beats;
- Evoral::MusicalTime duration;
- Evoral::MusicalTime end_point = 0;
-
- duration = (*mcb.notes().rbegin())->end_time() - (*mcb.notes().begin())->time();
- paste_pos_beats = absolute_frames_to_source_beats (pos);
- beat_delta = (*mcb.notes().begin())->time() - paste_pos_beats;
- paste_pos_beats = 0;
-
- DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("Paste data spans from %1 to %2 (%3) ; paste pos beats = %4 (based on %5 - %6 ; beat delta = %7\n",
- (*mcb.notes().begin())->time(),
- (*mcb.notes().rbegin())->end_time(),
+ const Evoral::Beats snap_beats = get_grid_beats(pos);
+ const Evoral::Beats first_time = (*mcb.notes().begin())->time();
+ const Evoral::Beats last_time = (*mcb.notes().rbegin())->end_time();
+ 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;
+ 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(),
- paste_pos_beats, beat_delta));
+ pos_beats));
- clear_selection ();
+ clear_editor_note_selection ();
for (int n = 0; n < (int) times; ++n) {
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 (paste_pos_beats + copied_note->time() - beat_delta);
+ copied_note->set_time (pos_beats + copied_note->time() - first_time);
+ copied_note->set_id (Evoral::next_event_id());
/* make all newly added notes selected */
note_diff_add_note (copied_note, true);
end_point = copied_note->end_time();
}
-
- paste_pos_beats += duration;
}
/* if we pasted past the current end of the region, extend the region */
DEBUG_TRACE (DEBUG::CutNPaste, string_compose ("Paste extended region from %1 to %2\n", region_end, end_frame));
_region->clear_changes ();
- _region->set_length (end_frame - _region->position());
+ /* we probably need to get the snap modifier somehow to make this correct for non-musical use */
+ _region->set_length (end_frame - _region->position(), trackview.editor().get_grid_music_divisions (0));
trackview.session()->add_command (new StatefulDiffCommand (_region));
}
apply_diff (true);
-
- trackview.session()->commit_reversible_command ();
}
struct EventNoteTimeEarlyFirstComparator {
void
MidiRegionView::update_ghost_note (double x, double y)
{
+ x = std::max(0.0, x);
+
MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
_last_ghost_x = x;
_note_group->canvas_to_item (x, y);
PublicEditor& editor = trackview.editor ();
-
+
framepos_t const unsnapped_frame = editor.pixel_to_sample (x);
framecnt_t grid_frames;
framepos_t const f = snap_frame_to_grid_underneath (unsnapped_frame, grid_frames);
- /* use region_frames... because we are converting a delta within the region
- */
-
- bool success;
- double length = editor.get_grid_type_as_beats (success, unsnapped_frame);
+ /* calculate time in beats relative to start of source */
+ const Evoral::Beats length = get_grid_beats(unsnapped_frame);
+ const Evoral::Beats time = std::max(
+ Evoral::Beats(),
+ absolute_frames_to_source_beats (f + _region->position ()));
- if (!success) {
- length = 1;
- }
-
- /* note that this sets the time of the ghost note in beats relative to
- the start of the source; that is how all note times are stored.
- */
- _ghost_note->note()->set_time (absolute_frames_to_source_beats (f + _region->position ()));
+ _ghost_note->note()->set_time (time);
_ghost_note->note()->set_length (length);
_ghost_note->note()->set_note (midi_stream_view()->y_to_note (y));
_ghost_note->note()->set_channel (mtv->get_channel_for_add ());
+ _ghost_note->note()->set_velocity (get_velocity_for_add (time));
/* the ghost note does not appear in ghost regions, so pass false in here */
update_note (_ghost_note, false);
remove_ghost_note ();
boost::shared_ptr<NoteType> g (new NoteType);
- _ghost_note = new Note (*this, _note_group, g);
+ if (midi_view()->note_mode() == Sustained) {
+ _ghost_note = new Note (*this, _note_group, g);
+ } else {
+ _ghost_note = new Hit (*this, _note_group, 10, g);
+ }
_ghost_note->set_ignore_events (true);
_ghost_note->set_outline_color (0x000000aa);
update_ghost_note (x, y);
_ghost_note->show ();
- _last_ghost_x = x;
- _last_ghost_y = y;
-
show_verbose_cursor (_ghost_note->note ());
}
_ghost_note = 0;
}
+void
+MidiRegionView::hide_verbose_cursor ()
+{
+ trackview.editor().verbose_cursor()->hide ();
+ MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
+ if (mtv) {
+ mtv->set_note_highlight (NO_MIDI_NOTE);
+ }
+}
+
void
MidiRegionView::snap_changed ()
{
void
MidiRegionView::maybe_select_by_position (GdkEventButton* ev, double /*x*/, double y)
{
+ /* XXX: This is dead code. What was it for? */
+
double note = midi_stream_view()->y_to_note(y);
Events e;
MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
uint16_t chn_mask = mtv->midi_track()->get_playback_channel_mask();
if (Keyboard::modifier_state_equals (ev->state, Keyboard::TertiaryModifier)) {
- get_events (e, Evoral::Sequence<Evoral::MusicalTime>::PitchGreaterThanOrEqual, (uint8_t) floor (note), chn_mask);
+ get_events (e, Evoral::Sequence<Evoral::Beats>::PitchGreaterThanOrEqual, (uint8_t) floor (note), chn_mask);
} else if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier)) {
- get_events (e, Evoral::Sequence<Evoral::MusicalTime>::PitchLessThanOrEqual, (uint8_t) floor (note), chn_mask);
+ get_events (e, Evoral::Sequence<Evoral::Beats>::PitchLessThanOrEqual, (uint8_t) floor (note), chn_mask);
} else {
return;
}
MidiRegionView::enable_display (bool yn)
{
RegionView::enable_display (yn);
- if (yn) {
- redisplay_model ();
- }
}
void
-MidiRegionView::show_step_edit_cursor (Evoral::MusicalTime pos)
+MidiRegionView::show_step_edit_cursor (Evoral::Beats pos)
{
if (_step_edit_cursor == 0) {
- ArdourCanvas::Group* const group = (ArdourCanvas::Group*)get_canvas_group();
+ ArdourCanvas::Item* const group = get_canvas_group();
_step_edit_cursor = new ArdourCanvas::Rectangle (group);
_step_edit_cursor->set_y0 (0);
}
void
-MidiRegionView::move_step_edit_cursor (Evoral::MusicalTime pos)
+MidiRegionView::move_step_edit_cursor (Evoral::Beats pos)
{
_step_edit_cursor_position = pos;
}
void
-MidiRegionView::set_step_edit_cursor_width (Evoral::MusicalTime beats)
+MidiRegionView::set_step_edit_cursor_width (Evoral::Beats beats)
{
_step_edit_cursor_width = beats;
if (_step_edit_cursor) {
- _step_edit_cursor->set_x1 (_step_edit_cursor->x0() + trackview.editor().sample_to_pixel (region_beats_to_region_frames (beats)));
+ _step_edit_cursor->set_x1 (_step_edit_cursor->x0() + trackview.editor().sample_to_pixel (
+ region_beats_to_region_frames (_step_edit_cursor_position + beats)
+ - region_beats_to_region_frames (_step_edit_cursor_position)));
}
}
boost::shared_ptr<MidiBuffer> buf = mtv->midi_track()->get_gui_feed_buffer ();
- BeatsFramesConverter converter (trackview.session()->tempo_map(), mtv->midi_track()->get_capture_start_frame (0));
-
framepos_t back = max_framepos;
for (MidiBuffer::iterator i = buf->begin(); i != buf->end(); ++i) {
}
}
- /* ev.time() is in session frames, so (ev.time() - converter.origin_b()) is
- frames from the start of the source, and so time_beats is in terms of the
- source.
- */
-
- Evoral::MusicalTime const time_beats = converter.from (ev.time () - converter.origin_b ());
+ /* convert from session frames to source beats */
+ Evoral::Beats const time_beats = _source_relative_time_converter.from(
+ ev.time() - src->timeline_position() + _region->start());
if (ev.type() == MIDI_CMD_NOTE_ON) {
boost::shared_ptr<NoteType> note (
- new NoteType (ev.channel(), time_beats, 0, ev.note(), ev.velocity()));
+ new NoteType (ev.channel(), time_beats, Evoral::Beats(), ev.note(), ev.velocity()));
add_note (note, true);
void
MidiRegionView::trim_front_starting ()
{
- /* Reparent the note group to the region view's parent, so that it doesn't change
- when the region view is trimmed.
+ /* We used to eparent the note group to the region view's parent, so that it didn't change.
+ now we update it.
*/
- _temporary_note_group = new ArdourCanvas::Group (group->parent ());
- _temporary_note_group->move (group->position ());
- _note_group->reparent (_temporary_note_group);
}
void
MidiRegionView::trim_front_ending ()
{
- _note_group->reparent (group);
- delete _temporary_note_group;
- _temporary_note_group = 0;
-
if (_region->start() < 0) {
/* Trim drag made start time -ve; fix this */
midi_region()->fix_negative_start ();
// display_sysexes();
}
-void
-MidiRegionView::show_verbose_cursor (boost::shared_ptr<NoteType> n) const
+std::string
+MidiRegionView::get_note_name (boost::shared_ptr<NoteType> n, uint8_t note_value) const
{
using namespace MIDI::Name;
-
std::string name;
- MidiTimeAxisView* const mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
+ MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
if (mtv) {
boost::shared_ptr<MasterDeviceNames> device_names(mtv->get_device_names());
if (device_names) {
get_patch_key_at(n->time(), n->channel(), patch_key);
name = device_names->note_name(mtv->gui_property(X_("midnam-custom-device-mode")),
n->channel(),
- patch_key.bank_number,
- patch_key.program_number,
- n->note());
+ patch_key.bank(),
+ patch_key.program(),
+ note_value);
}
}
char buf[128];
snprintf (buf, sizeof (buf), "%d %s\nCh %d Vel %d",
- (int) n->note (),
- name.empty() ? Evoral::midi_note_name (n->note()).c_str() : name.c_str(),
+ (int) note_value,
+ name.empty() ? ParameterDescriptor::midi_note_name (note_value).c_str() : name.c_str(),
(int) n->channel() + 1,
(int) n->velocity());
- show_verbose_cursor(buf, 10, 20);
+ return buf;
}
void
-MidiRegionView::show_verbose_cursor (string const & text, double xoffset, double yoffset) const
+MidiRegionView::show_verbose_cursor_for_new_note_value(boost::shared_ptr<NoteType> current_note,
+ uint8_t new_value) const
{
- double wx, wy;
-
- trackview.editor().verbose_cursor()->set_text (text);
- trackview.editor().get_pointer_position (wx, wy);
+ MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*>(&trackview);
+ if (mtv) {
+ mtv->set_note_highlight (new_value);
+ }
- wx += xoffset;
- wy += yoffset;
+ show_verbose_cursor(get_note_name(current_note, new_value), 10, 20);
+}
- /* Flip the cursor above the mouse pointer if it would overlap the bottom of the canvas */
+void
+MidiRegionView::show_verbose_cursor (boost::shared_ptr<NoteType> n) const
+{
+ show_verbose_cursor_for_new_note_value(n, n->note());
+}
- boost::optional<ArdourCanvas::Rect> bbo = trackview.editor().verbose_cursor()->item().bounding_box();
+void
+MidiRegionView::show_verbose_cursor (string const & text, double xoffset, double yoffset) const
+{
+ trackview.editor().verbose_cursor()->set (text);
+ trackview.editor().verbose_cursor()->show ();
+ trackview.editor().verbose_cursor()->set_offset (ArdourCanvas::Duple (xoffset, yoffset));
+}
- assert (bbo);
-
- ArdourCanvas::Rect bb = bbo.get();
+uint8_t
+MidiRegionView::get_velocity_for_add (MidiModel::TimeType time) const
+{
+ if (_model->notes().empty()) {
+ return 0x40; // No notes, use default
+ }
- if ((wy + bb.y1 - bb.y0) > trackview.editor().visible_canvas_height()) {
- wy -= (bb.y1 - bb.y0) + 2 * yoffset;
+ MidiModel::Notes::const_iterator m = _model->note_lower_bound(time);
+ if (m == _model->notes().begin()) {
+ // Before the start, use the velocity of the first note
+ return (*m)->velocity();
+ } else if (m == _model->notes().end()) {
+ // Past the end, use the velocity of the last note
+ --m;
+ return (*m)->velocity();
}
- trackview.editor().verbose_cursor()->set_position (wx, wy);
- trackview.editor().verbose_cursor()->show ();
+ // Interpolate velocity of surrounding notes
+ MidiModel::Notes::const_iterator n = m;
+ --n;
+
+ const double frac = ((time - (*n)->time()).to_double() /
+ ((*m)->time() - (*n)->time()).to_double());
+
+ return (*n)->velocity() + (frac * ((*m)->velocity() - (*n)->velocity()));
}
/** @param p A session framepos.
MidiRegionView::snap_frame_to_grid_underneath (framepos_t p, framecnt_t& grid_frames) const
{
PublicEditor& editor = trackview.editor ();
-
- bool success;
- Evoral::MusicalTime grid_beats = editor.get_grid_type_as_beats (success, p);
+ const Evoral::Beats grid_beats = get_grid_beats(p);
+ const Evoral::Beats p_beat = max (Evoral::Beats(), region_frames_to_region_beats (p));
- if (!success) {
- grid_beats = 1;
- }
-
- grid_frames = region_beats_to_region_frames (grid_beats);
+ grid_frames = region_beats_to_region_frames (p_beat + grid_beats) - region_beats_to_region_frames (p_beat);
/* 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.
return snap_frame_to_frame (p);
}
-/** Called when the selection has been cleared in any MidiRegionView.
- * @param rv MidiRegionView that the selection was cleared in.
- */
-void
-MidiRegionView::selection_cleared (MidiRegionView* rv)
-{
- if (rv == this) {
- return;
- }
-
- /* Clear our selection in sympathy; but don't signal the fact */
- clear_selection (false);
-}
-
-void
-MidiRegionView::note_button_release ()
-{
- delete _note_player;
- _note_player = 0;
-}
-
ChannelMode
MidiRegionView::get_channel_mode () const
{
return rtav->midi_track()->get_playback_channel_mask();
}
+
+Evoral::Beats
+MidiRegionView::get_grid_beats(framepos_t pos) const
+{
+ PublicEditor& editor = trackview.editor();
+ bool success = false;
+ Evoral::Beats beats = editor.get_grid_type_as_beats (success, pos);
+ if (!success) {
+ beats = Evoral::Beats(1);
+ }
+ return beats;
+}
projects / ardour.git / blobdiff