void
MidiRegionView::init (Gdk::Color& basic_color, bool wfd)
{
- if (wfd)
+ if (wfd) {
midi_region()->midi_source(0)->load_model();
+ }
const Meter& m = trackview.session().tempo_map().meter_at(_region->position());
const Tempo& t = trackview.session().tempo_map().tempo_at(_region->position());
static ArdourCanvas::SimpleRect* drag_rect = NULL;
- if (trackview.editor.current_mouse_mode() != MouseNote)
+ if (trackview.editor().current_mouse_mode() != MouseNote)
return false;
// Mmmm, spaghetti
case GDK_KEY_PRESS:
if (ev->key.keyval == GDK_Delete && !delete_mod) {
delete_mod = true;
- original_mode = trackview.editor.current_midi_edit_mode();
- trackview.editor.set_midi_edit_mode(MidiEditErase);
+ original_mode = trackview.editor().current_midi_edit_mode();
+ trackview.editor().set_midi_edit_mode(MidiEditErase);
start_delta_command(_("erase notes"));
_mouse_state = EraseTouchDragging;
return true;
apply_command();
}
if (delete_mod) {
- trackview.editor.set_midi_edit_mode(original_mode);
+ trackview.editor().set_midi_edit_mode(original_mode);
_mouse_state = None;
delete_mod = false;
}
group->w2i(event_x, event_y);
// convert event_x to global frame
- event_frame = trackview.editor.pixel_to_frame(event_x) + _region->position();
- trackview.editor.snap_to(event_frame);
+ event_frame = trackview.editor().pixel_to_frame(event_x) + _region->position();
+ trackview.editor().snap_to(event_frame);
// convert event_frame back to local coordinates relative to position
event_frame -= _region->position();
case Pressed: // Drag start
// Select drag start
- if (_pressed_button == 1 && trackview.editor.current_midi_edit_mode() == MidiEditSelect) {
+ if (_pressed_button == 1 && trackview.editor().current_midi_edit_mode() == MidiEditSelect) {
group->grab(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
Gdk::Cursor(Gdk::FLEUR), ev->motion.time);
last_x = event_x;
return true;
// Add note drag start
- } else if (trackview.editor.current_midi_edit_mode() == MidiEditPencil) {
+ } else if (trackview.editor().current_midi_edit_mode() == MidiEditPencil) {
group->grab(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
Gdk::Cursor(Gdk::FLEUR), ev->motion.time);
last_x = event_x;
drag_start_y = event_y;
drag_rect = new ArdourCanvas::SimpleRect(*group);
- drag_rect->property_x1() = trackview.editor.frame_to_pixel(event_frame);
+ drag_rect->property_x1() = trackview.editor().frame_to_pixel(event_frame);
drag_rect->property_y1() = midi_stream_view()->note_to_y(midi_stream_view()->y_to_note(event_y));
drag_rect->property_x2() = event_x;
}
if (_mouse_state == AddDragging)
- event_x = trackview.editor.frame_to_pixel(event_frame);
+ event_x = trackview.editor().frame_to_pixel(event_frame);
if (drag_rect) {
if (event_x > drag_start_x)
event_y = ev->motion.y;
group->w2i(event_x, event_y);
group->ungrab(ev->button.time);
- event_frame = trackview.editor.pixel_to_frame(event_x);
+ event_frame = trackview.editor().pixel_to_frame(event_x);
if (_pressed_button != 1) {
return false;
switch (_mouse_state) {
case Pressed: // Clicked
- switch (trackview.editor.current_midi_edit_mode()) {
+ switch (trackview.editor().current_midi_edit_mode()) {
case MidiEditSelect:
case MidiEditResize:
clear_selection();
_mouse_state = None;
if (drag_rect->property_x2() > drag_rect->property_x1() + 2) {
const double x = drag_rect->property_x1();
- const double length = trackview.editor.pixel_to_frame(
+ const double length = trackview.editor().pixel_to_frame(
drag_rect->property_x2() - drag_rect->property_x1());
create_note_at(x, drag_rect->property_y1(), length);
assert(note >= 0.0);
assert(note <= 127.0);
- nframes64_t new_note_time = trackview.editor.pixel_to_frame (x);
+ nframes64_t new_note_time = trackview.editor().pixel_to_frame (x);
assert(new_note_time >= 0);
new_note_time += _region->start();
new_note_length = snap_to_frame(new_note_time_position_relative + new_note_length) + _region->start()
- new_note_time;
- const boost::shared_ptr<Evoral::Note> new_note(new Evoral::Note(
+ const boost::shared_ptr<NoteType> new_note(new NoteType(
0, new_note_time, new_note_length, (uint8_t)note, 0x40));
view->update_note_range(new_note->note());
}
void
-MidiRegionView::command_add_note(const boost::shared_ptr<Evoral::Note> note, bool selected)
+MidiRegionView::command_add_note(const boost::shared_ptr<NoteType> note, bool selected)
{
if (_delta_command)
_delta_command->add(note);
for (AutomationList::const_iterator event = control->second->list()->begin();
event != control->second->list()->end(); ++event) {
double event_time = (*event)->when;
- double program_number = (*event)->value;
+ double program_number = floor((*event)->value + 0.5);
//cerr << " got program change on channel " << int(channel) << " time: " << event_time << " number: " << program_number << endl;
- // find bank select msb and lsb for the program change
+ // find bank select msb and lsb for the program change
Evoral::Parameter bank_select_msb(MidiCCAutomation, channel, MIDI_CTL_MSB_BANK);
+ boost::shared_ptr<Evoral::Control> msb_control = _model->control(bank_select_msb);
+ uint8_t msb = 0;
+ if (msb_control != 0) {
+ msb = uint8_t(floor(msb_control->get_float(true, event_time) + 0.5));
+ }
+
Evoral::Parameter bank_select_lsb(MidiCCAutomation, channel, MIDI_CTL_LSB_BANK);
-
boost::shared_ptr<Evoral::Control> lsb_control = _model->control(bank_select_lsb);
- boost::shared_ptr<Evoral::Control> msb_control = _model->control(bank_select_msb);
-
- boost::shared_ptr<MIDI::Name::MasterDeviceNames> master_device
- = MIDI::Name::MidiPatchManager::instance().master_device_by_model(_model_name);
-
- boost::shared_ptr<MIDI::Name::Patch> patch;
-
- if (master_device != 0 && _custom_device_mode != "") {
- uint8_t msb = 0;
- if (msb_control != 0) {
- msb = uint8_t(msb_control->get_float(true, event_time));
- }
-
- uint8_t lsb = 0;
- if (lsb_control != 0) {
- lsb = uint8_t(lsb_control->get_float(true, event_time));
- }
+ uint8_t lsb = 0;
+ if (lsb_control != 0) {
+ lsb = uint8_t(floor(lsb_control->get_float(true, event_time) + 0.5));
+ }
- //cerr << " got msb " << int(msb) << " and lsb " << int(lsb) << endl;
+ //cerr << " got msb " << int(msb) << " and lsb " << int(lsb) << " thread_id: " << pthread_self() << endl;
- patch = master_device->find_patch(
+ MIDI::Name::PatchPrimaryKey patch_key(msb, lsb, program_number);
+
+ boost::shared_ptr<MIDI::Name::Patch> patch =
+ MIDI::Name::MidiPatchManager::instance().find_patch(
+ _model_name,
_custom_device_mode,
channel,
- msb,
- lsb,
- uint8_t(program_number)
+ patch_key
);
-
- //cerr << " got patch with name " << patch.name() << " number " << patch.number() << endl;
- }
+
+ ControlEvent program_change(nframes_t(event_time), uint8_t(program_number), channel);
+
if (patch != 0) {
- add_pgm_change(event_time, patch->name());
+ //cerr << " got patch with name " << patch->name() << " number " << patch->number() << endl;
+ add_pgm_change(program_change, patch->name());
} else {
char buf[4];
snprintf(buf, 4, "%d", int(program_number));
- add_pgm_change(event_time, buf);
+ add_pgm_change(program_change, buf);
}
}
break;
note->property_y1() = y1;
note->property_y2() = y2;
} else if (CanvasHit* hit = dynamic_cast<CanvasHit*>(event)) {
- double x = trackview.editor.frame_to_pixel((nframes64_t)
+ double x = trackview.editor().frame_to_pixel((nframes64_t)
event->note()->time() - _region->start());
const double diamond_size = midi_stream_view()->note_height() / 2.0;
double y = midi_stream_view()->note_to_y(event->note()->note())
return;
if (_active_notes && _active_notes[note]) {
- _active_notes[note]->property_x2() = trackview.editor.frame_to_pixel((nframes64_t)end_time);
+ _active_notes[note]->property_x2() = trackview.editor().frame_to_pixel((nframes64_t)end_time);
_active_notes[note]->property_outline_what() = (guint32) 0xF; // all edges
_active_notes[note] = NULL;
}
for (unsigned i=0; i < 128; ++i) {
if (_active_notes[i]) {
- _active_notes[i]->property_x2() = trackview.editor.frame_to_pixel(_region->length());
+ _active_notes[i]->property_x2() = trackview.editor().frame_to_pixel(_region->length());
}
}
}
+void
+MidiRegionView::play_midi_note(boost::shared_ptr<NoteType> note)
+{
+ if (!trackview.editor().sound_notes()) {
+ return;
+ }
+
+ RouteUI* route_ui = dynamic_cast<RouteUI*> (&trackview);
+ assert(route_ui);
+
+ route_ui->midi_track()->write_immediate_event(note->on_event().size(), note->on_event().buffer());
+
+ nframes_t note_length_ms = (note->off_event().time() - note->on_event().time())
+ * (1000 / (double)route_ui->session().nominal_frame_rate());
+ Glib::signal_timeout().connect(bind(mem_fun(this, &MidiRegionView::play_midi_note_off), note),
+ note_length_ms, G_PRIORITY_DEFAULT);
+}
+
+bool
+MidiRegionView::play_midi_note_off(boost::shared_ptr<NoteType> note)
+{
+ RouteUI* route_ui = dynamic_cast<RouteUI*> (&trackview);
+ assert(route_ui);
+
+ route_ui->midi_track()->write_immediate_event(note->off_event().size(), note->off_event().buffer());
+
+ return false;
+}
+
/** Add a MIDI note to the view (with length).
*
* event arrives, to properly display the note.
*/
void
-MidiRegionView::add_note(const boost::shared_ptr<Evoral::Note> note)
+MidiRegionView::add_note(const boost::shared_ptr<NoteType> note)
{
assert(note->time() >= 0);
assert(midi_view()->note_mode() == Sustained || midi_view()->note_mode() == Percussive);
CanvasNoteEvent* event = 0;
- const double x = trackview.editor.frame_to_pixel((nframes64_t)note->time() - _region->start());
+ const double x = trackview.editor().frame_to_pixel((nframes64_t)note->time() - _region->start());
if (midi_view()->note_mode() == Sustained) {
const double y1 = midi_stream_view()->note_to_y(note->note());
const double note_endpixel =
- trackview.editor.frame_to_pixel((nframes64_t)note->end_time() - _region->start());
+ trackview.editor().frame_to_pixel((nframes64_t)note->end_time() - _region->start());
CanvasNote* ev_rect = new CanvasNote(*this, *group, note);
ev_rect->property_x1() = x;
if (note->length() > 0)
ev_rect->property_x2() = note_endpixel;
else
- ev_rect->property_x2() = trackview.editor.frame_to_pixel(_region->length());
+ ev_rect->property_x2() = trackview.editor().frame_to_pixel(_region->length());
ev_rect->property_y2() = y1 + floor(midi_stream_view()->note_height());
if (note->length() == 0) {
// finish the old note rectangle
if (_active_notes[note->note()]) {
CanvasNote* const old_rect = _active_notes[note->note()];
- boost::shared_ptr<Evoral::Note> old_note = old_rect->note();
+ boost::shared_ptr<NoteType> old_note = old_rect->note();
cerr << "MidiModel: WARNING: Note has length 0: chan " << old_note->channel()
<< "note " << (int)old_note->note() << " @ " << old_note->time() << endl;
/* FIXME: How large to make it? Make it a diamond? */
event = 0;
}
- if (event) {
+ if (event) {
if (_marked_for_selection.find(note) != _marked_for_selection.end()) {
note_selected(event, true);
}
}
void
-MidiRegionView::add_pgm_change(nframes_t time, string displaytext)
+MidiRegionView::add_pgm_change(ControlEvent& program, string displaytext)
{
- assert(time >= 0);
+ assert(program.time >= 0);
- // dont display notes beyond the region bounds
- if (time - _region->start() >= _region->length() || time < _region->start())
+ // dont display program changes beyond the region bounds
+ if (program.time - _region->start() >= _region->length() || program.time < _region->start())
return;
ArdourCanvas::Group* const group = (ArdourCanvas::Group*)get_canvas_group();
- const double x = trackview.editor.frame_to_pixel((nframes64_t)time - _region->start());
+ const double x = trackview.editor().frame_to_pixel((nframes64_t)program.time - _region->start());
double height = midi_stream_view()->contents_height();
- _pgm_changes.push_back(
- boost::shared_ptr<CanvasProgramChange>(
- new CanvasProgramChange(*this, *group, displaytext, height, x, 1.0)));
+
+ boost::shared_ptr<CanvasProgramChange> pgm_change = boost::shared_ptr<CanvasProgramChange>(
+ new CanvasProgramChange(
+ *this,
+ *group,
+ displaytext,
+ height,
+ x,
+ 1.0,
+ _model_name,
+ _custom_device_mode,
+ program.time,
+ program.channel,
+ program.value));
+
+ _pgm_changes.push_back(pgm_change);
+}
+
+void
+MidiRegionView::get_patch_key_at(double time, uint8_t channel, MIDI::Name::PatchPrimaryKey& key)
+{
+
+ cerr << "getting patch key at " << time << " for channel " << channel << endl;
+ Evoral::Parameter bank_select_msb(MidiCCAutomation, channel, MIDI_CTL_MSB_BANK);
+ boost::shared_ptr<Evoral::Control> msb_control = _model->control(bank_select_msb);
+ float msb = -1.0;
+ if (msb_control != 0) {
+ msb = int(msb_control->get_float(true, time));
+ cerr << "got msb " << msb;
+ }
+
+ Evoral::Parameter bank_select_lsb(MidiCCAutomation, channel, MIDI_CTL_LSB_BANK);
+ boost::shared_ptr<Evoral::Control> lsb_control = _model->control(bank_select_lsb);
+ float lsb = -1.0;
+ if (lsb_control != 0) {
+ lsb = lsb_control->get_float(true, time);
+ cerr << " got lsb " << lsb;
+ }
+
+ Evoral::Parameter program_change(MidiPgmChangeAutomation, channel, 0);
+ boost::shared_ptr<Evoral::Control> program_control = _model->control(program_change);
+ float program_number = -1.0;
+ if (program_control != 0) {
+ program_number = program_control->get_float(true, time);
+ cerr << " got program " << program_number << endl;
+ }
+
+ key.msb = (int) floor(msb + 0.5);
+ key.lsb = (int) floor(lsb + 0.5);
+ key.program_number = (int) floor(program_number + 0.5);
+ assert(key.is_sane());
+}
+
+
+void
+MidiRegionView::alter_program_change(ControlEvent& old_program, const MIDI::Name::PatchPrimaryKey& new_patch)
+{
+
+ // TODO: Get the real event here and alter them at the original times
+ Evoral::Parameter bank_select_msb(MidiCCAutomation, old_program.channel, MIDI_CTL_MSB_BANK);
+ boost::shared_ptr<Evoral::Control> msb_control = _model->control(bank_select_msb);
+ if (msb_control != 0) {
+ msb_control->set_float(float(new_patch.msb), true, old_program.time);
+ }
+
+ // TODO: Get the real event here and alter them at the original times
+ Evoral::Parameter bank_select_lsb(MidiCCAutomation, old_program.channel, MIDI_CTL_LSB_BANK);
+ boost::shared_ptr<Evoral::Control> lsb_control = _model->control(bank_select_lsb);
+ if (lsb_control != 0) {
+ lsb_control->set_float(float(new_patch.lsb), true, old_program.time);
+ }
+
+ Evoral::Parameter program_change(MidiPgmChangeAutomation, old_program.channel, 0);
+ boost::shared_ptr<Evoral::Control> program_control = _model->control(program_change);
+
+ assert(program_control != 0);
+ program_control->set_float(float(new_patch.program_number), true, old_program.time);
+
+ redisplay_model();
+}
+
+void
+MidiRegionView::program_selected(CanvasProgramChange& program, const MIDI::Name::PatchPrimaryKey& new_patch)
+{
+ ControlEvent program_change_event(program.event_time(), program.program(), program.channel());
+ alter_program_change(program_change_event, new_patch);
+}
+
+void
+MidiRegionView::previous_program(CanvasProgramChange& program)
+{
+ MIDI::Name::PatchPrimaryKey key;
+ get_patch_key_at(program.event_time(), program.channel(), key);
+
+ boost::shared_ptr<MIDI::Name::Patch> patch =
+ MIDI::Name::MidiPatchManager::instance().previous_patch(
+ _model_name,
+ _custom_device_mode,
+ program.channel(),
+ key
+ );
+
+ ControlEvent program_change_event(program.event_time(), program.program(), program.channel());
+ if (patch) {
+ alter_program_change(program_change_event, patch->patch_primary_key());
+ }
+}
+
+void
+MidiRegionView::next_program(CanvasProgramChange& program)
+{
+ MIDI::Name::PatchPrimaryKey key;
+ get_patch_key_at(program.event_time(), program.channel(), key);
+
+ boost::shared_ptr<MIDI::Name::Patch> patch =
+ MIDI::Name::MidiPatchManager::instance().next_patch(
+ _model_name,
+ _custom_device_mode,
+ program.channel(),
+ key
+ );
+ ControlEvent program_change_event(program.event_time(), program.program(), program.channel());
+ if (patch) {
+ alter_program_change(program_change_event, patch->patch_primary_key());
+ }
}
void
clear_selection_except(ev);
}
- _selection.insert(ev);
+ if (_selection.insert(ev).second) {
+ play_midi_note(ev->note());
+ }
if ( ! ev->selected()) {
ev->selected(true);
if (!(*i)->selected()) {
(*i)->selected(true);
_selection.insert(*i);
+ play_midi_note((*i)->note());
}
// Not inside rectangle
} else if ((*i)->selected()) {
if (!(*i)->selected()) {
(*i)->selected(true);
_selection.insert(*i);
+ play_midi_note((*i)->note());
}
// Not inside rectangle
} else if ((*i)->selected()) {
Selection::iterator next = i;
++next;
- const boost::shared_ptr<Evoral::Note> copy(new Evoral::Note(*(*i)->note().get()));
+ const boost::shared_ptr<NoteType> copy(new NoteType(*(*i)->note().get()));
// we need to snap here again in nframes64_t in order to be sample accurate
double new_note_time = (*i)->note()->time();
copy->set_note(new_pitch);
command_remove_note(*i);
- command_add_note(copy, true);
+ command_add_note(copy, (*i)->selected());
i = next;
}
nframes64_t
MidiRegionView::snap_to_frame(double x)
{
- PublicEditor &editor = trackview.editor;
+ PublicEditor &editor = trackview.editor();
// x is region relative
// convert x to global frame
nframes64_t frame = editor.pixel_to_frame(x) + _region->position();
nframes64_t
MidiRegionView::snap_to_frame(nframes64_t x)
{
- PublicEditor &editor = trackview.editor;
+ PublicEditor &editor = trackview.editor();
// x is region relative
// convert x to global frame
nframes64_t frame = x + _region->position();
double
MidiRegionView::snap_to_pixel(double x)
{
- return (double) trackview.editor.frame_to_pixel(snap_to_frame(x));
+ return (double) trackview.editor().frame_to_pixel(snap_to_frame(x));
}
double
-MidiRegionView::get_position_pixels(void)
+MidiRegionView::get_position_pixels()
{
- nframes64_t region_frame = get_position();
- return trackview.editor.frame_to_pixel(region_frame);
+ nframes64_t region_frame = get_position();
+ return trackview.editor().frame_to_pixel(region_frame);
}
void
// calculate the colors: get the color settings
uint32_t fill_color =
UINT_RGBA_CHANGE_A(
- ARDOUR_UI::config()->canvasvar_MidiNoteSelectedOutline.get(),
+ ARDOUR_UI::config()->canvasvar_MidiNoteSelected.get(),
128);
// make the resize preview notes more transparent and bright
// calculate color based on note velocity
resize_rect->property_fill_color_rgba() =
UINT_INTERPOLATE(
- note_fill_color(note->note()->velocity()),
+ CanvasNoteEvent::meter_style_fill_color(note->note()->velocity()),
fill_color,
0.85);
resize_rect->property_outline_color_rgba() =
- ARDOUR_UI::config()->canvasvar_MidiNoteSelectedOutline.get();
+ CanvasNoteEvent::calculate_outline(ARDOUR_UI::config()->canvasvar_MidiNoteSelected.get());
resize_data->resize_rect = resize_rect;
// transform to region start relative
current_frame += _region->start();
- const boost::shared_ptr<Evoral::Note> copy(new Evoral::Note(*(canvas_note->note().get())));
+ const boost::shared_ptr<NoteType> copy(new NoteType(*(canvas_note->note().get())));
// resize beginning of note
if (note_end == CanvasNote::NOTE_ON && current_frame < copy->end_time()) {
apply_command();
}
+void
+MidiRegionView::change_note_velocity(CanvasNoteEvent* event, int8_t velocity, bool relative)
+{
+ const boost::shared_ptr<NoteType> copy(new NoteType(*(event->note().get())));
+
+ if (relative) {
+ uint8_t new_velocity = copy->velocity() + velocity;
+ clamp_0_to_127(new_velocity);
+ copy->set_velocity(new_velocity);
+ } else {
+ copy->set_velocity(velocity);
+ }
+
+ command_remove_note(event);
+ command_add_note(copy, event->selected());
+}
void
-MidiRegionView::change_velocity(uint8_t velocity, bool relative)
+MidiRegionView::change_velocity(CanvasNoteEvent* ev, int8_t velocity, bool relative)
{
start_delta_command(_("change velocity"));
+
+ change_note_velocity(ev, velocity, relative);
+
for (Selection::iterator i = _selection.begin(); i != _selection.end();) {
Selection::iterator next = i;
++next;
-
- CanvasNoteEvent *event = *i;
- const boost::shared_ptr<Evoral::Note> copy(new Evoral::Note(*(event->note().get())));
-
- if (relative) {
- uint8_t new_velocity = copy->velocity() + velocity;
- clamp_0_to_127(new_velocity);
-
- copy->set_velocity(new_velocity);
- } else { // absolute
- copy->set_velocity(velocity);
+ if ( !(*((*i)->note()) == *(ev->note())) ) {
+ change_note_velocity(*i, velocity, relative);
}
-
- command_remove_note(event);
- command_add_note(copy, true);
-
i = next;
}
Selection::iterator next = i;
++next;
- CanvasNoteEvent *event = *i;
- const boost::shared_ptr<Evoral::Note> copy(new Evoral::Note(*(event->note().get())));
+ CanvasNoteEvent* event = *i;
+ const boost::shared_ptr<NoteType> copy(new NoteType(*(event->note().get())));
copy->set_channel(channel);
command_remove_note(event);
- command_add_note(copy, true);
+ command_add_note(copy, event->selected());
i = next;
}