*/
-#define __STDC_LIMIT_MACROS 1
#include <set>
#include <iostream>
#include <algorithm>
#include "ardour/smf_source.h"
#include "ardour/types.h"
#include "ardour/session.h"
+#include "ardour/midi_automation_list_binder.h"
using namespace std;
using namespace ARDOUR;
using namespace PBD;
-MidiModel::MidiModel(MidiSource* s)
+MidiModel::MidiModel (boost::shared_ptr<MidiSource> s)
: AutomatableSequence<TimeType>(s->session())
- , _midi_source(s)
{
+ set_midi_source (s);
}
-/** Start a new Diff command.
+/** Start a new NoteDiff command.
*
* This has no side-effects on the model or Session, the returned command
* can be held on to for as long as the caller wishes, or discarded without
* formality, until apply_command is called and ownership is taken.
*/
-MidiModel::DiffCommand*
-MidiModel::new_diff_command(const string name)
+MidiModel::NoteDiffCommand*
+MidiModel::new_note_diff_command (const string name)
{
- DiffCommand* cmd = new DiffCommand(_midi_source->model(), name);
- return cmd;
+ boost::shared_ptr<MidiSource> ms = _midi_source.lock ();
+ assert (ms);
+
+ return new NoteDiffCommand (ms->model(), name);
}
+/** Start a new SysExDiff command */
+MidiModel::SysExDiffCommand*
+MidiModel::new_sysex_diff_command (const string name)
+{
+ boost::shared_ptr<MidiSource> ms = _midi_source.lock ();
+ assert (ms);
+
+ return new SysExDiffCommand (ms->model(), name);
+}
+
+
/** Apply a command.
*
* Ownership of cmd is taken, it must not be deleted by the caller.
/************** DIFF COMMAND ********************/
-#define DIFF_COMMAND_ELEMENT "DiffCommand"
+#define NOTE_DIFF_COMMAND_ELEMENT "NoteDiffCommand"
#define DIFF_NOTES_ELEMENT "ChangedNotes"
#define ADDED_NOTES_ELEMENT "AddedNotes"
#define REMOVED_NOTES_ELEMENT "RemovedNotes"
#define SIDE_EFFECT_REMOVALS_ELEMENT "SideEffectRemovals"
+#define SYSEX_DIFF_COMMAND_ELEMENT "SysExDiffCommand"
+#define DIFF_SYSEXES_ELEMENT "ChangedSysExes"
MidiModel::DiffCommand::DiffCommand(boost::shared_ptr<MidiModel> m, const std::string& name)
- : Command(name)
- , _model(m)
- , _name(name)
+ : Command (name)
+ , _model (m)
+ , _name (name)
{
assert(_model);
}
-MidiModel::DiffCommand::DiffCommand(boost::shared_ptr<MidiModel> m, const XMLNode& node)
- : _model(m)
+MidiModel::NoteDiffCommand::NoteDiffCommand (boost::shared_ptr<MidiModel> m, const XMLNode& node)
+ : DiffCommand (m, "")
{
- assert(_model);
- set_state(node, Stateful::loading_state_version);
+ assert (_model);
+ set_state (node, Stateful::loading_state_version);
}
void
-MidiModel::DiffCommand::add(const NotePtr note)
+MidiModel::NoteDiffCommand::add (const NotePtr note)
{
_removed_notes.remove(note);
_added_notes.push_back(note);
}
void
-MidiModel::DiffCommand::remove(const NotePtr note)
+MidiModel::NoteDiffCommand::remove (const NotePtr note)
{
_added_notes.remove(note);
_removed_notes.push_back(note);
}
void
-MidiModel::DiffCommand::side_effect_remove(const NotePtr note)
+MidiModel::NoteDiffCommand::side_effect_remove (const NotePtr note)
{
side_effect_removals.insert (note);
}
void
-MidiModel::DiffCommand::change(const NotePtr note, Property prop,
- uint8_t new_value)
+MidiModel::NoteDiffCommand::change (const NotePtr note, Property prop,
+ uint8_t new_value)
{
- NoteChange change;
-
- switch (prop) {
- case NoteNumber:
+ assert (note);
+
+ NoteChange change;
+
+ switch (prop) {
+ case NoteNumber:
if (new_value == note->note()) {
return;
}
- change.old_value = note->note();
- break;
- case Velocity:
+ change.old_value = note->note();
+ break;
+ case Velocity:
if (new_value == note->velocity()) {
return;
}
- change.old_value = note->velocity();
- break;
- case Channel:
+ change.old_value = note->velocity();
+ break;
+ case Channel:
if (new_value == note->channel()) {
return;
}
- change.old_value = note->channel();
- break;
-
-
- case StartTime:
- fatal << "MidiModel::DiffCommand::change() with integer argument called for start time" << endmsg;
- /*NOTREACHED*/
- break;
- case Length:
- fatal << "MidiModel::DiffCommand::change() with integer argument called for length" << endmsg;
- /*NOTREACHED*/
- break;
- }
+ change.old_value = note->channel();
+ break;
+
+
+ case StartTime:
+ fatal << "MidiModel::DiffCommand::change() with integer argument called for start time" << endmsg;
+ /*NOTREACHED*/
+ break;
+ case Length:
+ fatal << "MidiModel::DiffCommand::change() with integer argument called for length" << endmsg;
+ /*NOTREACHED*/
+ break;
+ }
- change.note = note;
- change.property = prop;
- change.new_value = new_value;
+ change.note = note;
+ change.property = prop;
+ change.new_value = new_value;
- _changes.push_back (change);
+ _changes.push_back (change);
}
void
-MidiModel::DiffCommand::change(const NotePtr note, Property prop,
- TimeType new_time)
+MidiModel::NoteDiffCommand::change (const NotePtr note, Property prop,
+ TimeType new_time)
{
- NoteChange change;
-
- switch (prop) {
- case NoteNumber:
- case Channel:
- case Velocity:
- fatal << "MidiModel::DiffCommand::change() with time argument called for note, channel or velocity" << endmsg;
- break;
-
- case StartTime:
+ assert (note);
+
+ NoteChange change;
+
+ switch (prop) {
+ case NoteNumber:
+ case Channel:
+ case Velocity:
+ fatal << "MidiModel::NoteDiffCommand::change() with time argument called for note, channel or velocity" << endmsg;
+ break;
+
+ case StartTime:
if (Evoral::musical_time_equal (note->time(), new_time)) {
return;
}
- change.old_time = note->time();
- break;
- case Length:
+ change.old_time = note->time();
+ break;
+ case Length:
if (Evoral::musical_time_equal (note->length(), new_time)) {
return;
}
- change.old_time = note->length();
- break;
- }
+ change.old_time = note->length();
+ break;
+ }
- change.note = note;
- change.property = prop;
- change.new_time = new_time;
+ change.note = note;
+ change.property = prop;
+ change.new_time = new_time;
- _changes.push_back (change);
+ _changes.push_back (change);
}
-MidiModel::DiffCommand&
-MidiModel::DiffCommand::operator+= (const DiffCommand& other)
+MidiModel::NoteDiffCommand &
+MidiModel::NoteDiffCommand::operator+= (const NoteDiffCommand& other)
{
if (this == &other) {
return *this;
}
void
-MidiModel::DiffCommand::operator()()
+MidiModel::NoteDiffCommand::operator() ()
{
{
MidiModel::WriteLock lock(_model->edit_lock());
if (!_model->add_note_unlocked(*i)) {
/* failed to add it, so don't leave it in the removed list, to
avoid apparent errors on undo.
- */
+ */
_removed_notes.remove (*i);
}
}
-
+
for (NoteList::iterator i = _removed_notes.begin(); i != _removed_notes.end(); ++i) {
_model->remove_note_unlocked(*i);
}
}
i->note->set_channel (i->new_value);
break;
-
- /* no remove-then-add required for these properties, since we do not index them
- */
+
+ /* no remove-then-add required for these properties, since we do not index them
+ */
case Velocity:
i->note->set_velocity (i->new_value);
for (set<NotePtr>::iterator i = temporary_removals.begin(); i != temporary_removals.end(); ++i) {
- DiffCommand side_effects (model(), "side effects");
- _model->add_note_unlocked (*i, &side_effects);
- *this += side_effects;
+ NoteDiffCommand side_effects (model(), "side effects");
+ if (_model->add_note_unlocked (*i, &side_effects)) {
+ /* The note was re-added ok */
+ *this += side_effects;
+ } else {
+ /* The note that we removed earlier could not be re-added. This change record
+ must say that the note was removed. It is an un-note.
+ */
+
+ /* We didn't change it... */
+ for (ChangeList::iterator j = _changes.begin(); j != _changes.end(); ) {
+
+ ChangeList::iterator k = j;
+ ++k;
+
+ if (*i == j->note) {
+ _changes.erase (j);
+ }
+
+ j = k;
+ }
+
+ /* ...in fact, we removed it */
+ _removed_notes.push_back (*i);
+ }
}
if (!side_effect_removals.empty()) {
}
}
- _model->ContentsChanged(); /* EMIT SIGNAL */
+ _model->ContentsChanged(); /* EMIT SIGNAL */
}
void
-MidiModel::DiffCommand::undo()
+MidiModel::NoteDiffCommand::undo ()
{
{
MidiModel::WriteLock lock(_model->edit_lock());
-
+
for (NoteList::iterator i = _added_notes.begin(); i != _added_notes.end(); ++i) {
_model->remove_note_unlocked(*i);
}
-
+
for (NoteList::iterator i = _removed_notes.begin(); i != _removed_notes.end(); ++i) {
_model->add_note_unlocked(*i);
}
/* finally add back notes that were removed by the "do". we don't care
about side effects here since the model should be back to its original
state once this is done.
- */
+ */
- cerr << "This undo has " << side_effect_removals.size() << " SER's to be re-added\n";
for (set<NotePtr>::iterator i = side_effect_removals.begin(); i != side_effect_removals.end(); ++i) {
_model->add_note_unlocked (*i);
}
}
- _model->ContentsChanged(); /* EMIT SIGNAL */
+ _model->ContentsChanged(); /* EMIT SIGNAL */
}
XMLNode&
-MidiModel::DiffCommand::marshal_note(const NotePtr note)
+MidiModel::NoteDiffCommand::marshal_note(const NotePtr note)
{
- XMLNode* xml_note = new XMLNode("note");
+ XMLNode* xml_note = new XMLNode("note");
+
+ {
+ ostringstream id_str(ios::ate);
+ id_str << int(note->id());
+ xml_note->add_property("id", id_str.str());
+ }
- cerr << "Marshalling note: " << *note << endl;
+ {
+ ostringstream note_str(ios::ate);
+ note_str << int(note->note());
+ xml_note->add_property("note", note_str.str());
+ }
- ostringstream note_str(ios::ate);
- note_str << int(note->note());
- xml_note->add_property("note", note_str.str());
+ {
+ ostringstream channel_str(ios::ate);
+ channel_str << int(note->channel());
+ xml_note->add_property("channel", channel_str.str());
+ }
- ostringstream channel_str(ios::ate);
- channel_str << int(note->channel());
- xml_note->add_property("channel", channel_str.str());
+ {
+ ostringstream time_str(ios::ate);
+ time_str << note->time();
+ xml_note->add_property("time", time_str.str());
+ }
- ostringstream time_str(ios::ate);
- time_str << note->time();
- xml_note->add_property("time", time_str.str());
-
- ostringstream length_str(ios::ate);
- length_str << note->length();
- xml_note->add_property("length", length_str.str());
+ {
+ ostringstream length_str(ios::ate);
+ length_str << note->length();
+ xml_note->add_property("length", length_str.str());
+ }
- ostringstream velocity_str(ios::ate);
- velocity_str << (unsigned int) note->velocity();
- xml_note->add_property("velocity", velocity_str.str());
+ {
+ ostringstream velocity_str(ios::ate);
+ velocity_str << (unsigned int) note->velocity();
+ xml_note->add_property("velocity", velocity_str.str());
+ }
- return *xml_note;
+ return *xml_note;
}
Evoral::Sequence<MidiModel::TimeType>::NotePtr
-MidiModel::DiffCommand::unmarshal_note(XMLNode *xml_note)
+MidiModel::NoteDiffCommand::unmarshal_note (XMLNode *xml_note)
{
- unsigned int note;
- XMLProperty* prop;
- unsigned int channel;
- unsigned int time;
- unsigned int length;
- unsigned int velocity;
-
- if ((prop = xml_note->property("note")) != 0) {
- istringstream note_str(prop->value());
- note_str >> note;
- } else {
- warning << "note information missing note value" << endmsg;
- note = 127;
- }
+ unsigned int note;
+ XMLProperty* prop;
+ unsigned int channel;
+ unsigned int time;
+ unsigned int length;
+ unsigned int velocity;
+ gint id;
+
+ if ((prop = xml_note->property("id")) != 0) {
+ istringstream id_str(prop->value());
+ id_str >> id;
+ } else {
+ error << "note information missing ID value" << endmsg;
+ id = -1;
+ }
- if ((prop = xml_note->property("channel")) != 0) {
- istringstream channel_str(prop->value());
- channel_str >> channel;
- } else {
- warning << "note information missing channel" << endmsg;
- channel = 0;
- }
+ if ((prop = xml_note->property("note")) != 0) {
+ istringstream note_str(prop->value());
+ note_str >> note;
+ } else {
+ warning << "note information missing note value" << endmsg;
+ note = 127;
+ }
- if ((prop = xml_note->property("time")) != 0) {
- istringstream time_str(prop->value());
- time_str >> time;
- } else {
- warning << "note information missing time" << endmsg;
- time = 0;
- }
+ if ((prop = xml_note->property("channel")) != 0) {
+ istringstream channel_str(prop->value());
+ channel_str >> channel;
+ } else {
+ warning << "note information missing channel" << endmsg;
+ channel = 0;
+ }
- if ((prop = xml_note->property("length")) != 0) {
- istringstream length_str(prop->value());
- length_str >> length;
- } else {
- warning << "note information missing length" << endmsg;
- length = 1;
- }
+ if ((prop = xml_note->property("time")) != 0) {
+ istringstream time_str(prop->value());
+ time_str >> time;
+ } else {
+ warning << "note information missing time" << endmsg;
+ time = 0;
+ }
- if ((prop = xml_note->property("velocity")) != 0) {
- istringstream velocity_str(prop->value());
- velocity_str >> velocity;
- } else {
- warning << "note information missing velocity" << endmsg;
- velocity = 127;
- }
+ if ((prop = xml_note->property("length")) != 0) {
+ istringstream length_str(prop->value());
+ length_str >> length;
+ } else {
+ warning << "note information missing length" << endmsg;
+ length = 1;
+ }
+
+ if ((prop = xml_note->property("velocity")) != 0) {
+ istringstream velocity_str(prop->value());
+ velocity_str >> velocity;
+ } else {
+ warning << "note information missing velocity" << endmsg;
+ velocity = 127;
+ }
- NotePtr note_ptr(new Evoral::Note<TimeType>(channel, time, length, note, velocity));
+ NotePtr note_ptr(new Evoral::Note<TimeType>(channel, time, length, note, velocity));
+ note_ptr->set_id (id);
- return note_ptr;
+ return note_ptr;
}
XMLNode&
-MidiModel::DiffCommand::marshal_change(const NoteChange& change)
+MidiModel::NoteDiffCommand::marshal_change (const NoteChange& change)
{
- XMLNode* xml_change = new XMLNode("change");
-
- /* first, the change itself */
-
- xml_change->add_property ("property", enum_2_string (change.property));
-
- {
- ostringstream old_value_str (ios::ate);
- if (change.property == StartTime || change.property == Length) {
- old_value_str << change.old_time;
- } else {
- old_value_str << (unsigned int) change.old_value;
- }
- xml_change->add_property ("old", old_value_str.str());
- }
-
- {
- ostringstream new_value_str (ios::ate);
- if (change.property == StartTime || change.property == Length) {
- new_value_str << change.new_time;
- } else {
- new_value_str << (unsigned int) change.new_value;
- }
- xml_change->add_property ("new", new_value_str.str());
- }
+ XMLNode* xml_change = new XMLNode("Change");
- /* now the rest of the note */
+ /* first, the change itself */
- const SMFSource* smf = dynamic_cast<const SMFSource*> (_model->midi_source());
+ xml_change->add_property ("property", enum_2_string (change.property));
- if (change.property != NoteNumber) {
- ostringstream note_str;
- note_str << int(change.note->note());
- xml_change->add_property("note", note_str.str());
- }
-
- if (change.property != Channel) {
- ostringstream channel_str;
- channel_str << int(change.note->channel());
- xml_change->add_property("channel", channel_str.str());
- }
-
- if (change.property != StartTime) {
- ostringstream time_str;
- if (smf) {
- time_str << smf->round_to_file_precision (change.note->time());
- } else {
- time_str << change.note->time();
- }
- xml_change->add_property("time", time_str.str());
- }
-
- if (change.property != Length) {
- ostringstream length_str;
- if (smf) {
- length_str << smf->round_to_file_precision (change.note->length());
- } else {
- length_str << change.note->length();
- }
- xml_change->add_property ("length", length_str.str());
- }
+ {
+ ostringstream old_value_str (ios::ate);
+ if (change.property == StartTime || change.property == Length) {
+ old_value_str << change.old_time;
+ } else {
+ old_value_str << (unsigned int) change.old_value;
+ }
+ xml_change->add_property ("old", old_value_str.str());
+ }
- if (change.property != Velocity) {
- ostringstream velocity_str;
- velocity_str << int (change.note->velocity());
- xml_change->add_property("velocity", velocity_str.str());
- }
+ {
+ ostringstream new_value_str (ios::ate);
+ if (change.property == StartTime || change.property == Length) {
+ new_value_str << change.new_time;
+ } else {
+ new_value_str << (unsigned int) change.new_value;
+ }
+ xml_change->add_property ("new", new_value_str.str());
+ }
- /* and now notes that were remove as a side-effect */
+ ostringstream id_str;
+ id_str << change.note->id();
+ xml_change->add_property ("id", id_str.str());
- return *xml_change;
+ return *xml_change;
}
-MidiModel::DiffCommand::NoteChange
-MidiModel::DiffCommand::unmarshal_change(XMLNode *xml_change)
+MidiModel::NoteDiffCommand::NoteChange
+MidiModel::NoteDiffCommand::unmarshal_change (XMLNode *xml_change)
{
- XMLProperty* prop;
- NoteChange change;
- unsigned int note;
- unsigned int channel;
- unsigned int velocity;
- Evoral::MusicalTime time;
- Evoral::MusicalTime length;
-
- if ((prop = xml_change->property("property")) != 0) {
- change.property = (Property) string_2_enum (prop->value(), change.property);
- } else {
- fatal << "!!!" << endmsg;
- /*NOTREACHED*/
- }
-
- if ((prop = xml_change->property ("old")) != 0) {
- istringstream old_str (prop->value());
- if (change.property == StartTime || change.property == Length) {
- old_str >> change.old_time;
- } else {
- int integer_value_so_that_istream_does_the_right_thing;
- old_str >> integer_value_so_that_istream_does_the_right_thing;
- change.old_value = integer_value_so_that_istream_does_the_right_thing;
- }
- } else {
- fatal << "!!!" << endmsg;
- /*NOTREACHED*/
- }
-
- if ((prop = xml_change->property ("new")) != 0) {
- istringstream new_str (prop->value());
- if (change.property == StartTime || change.property == Length) {
- new_str >> change.new_time;
- } else {
- int integer_value_so_that_istream_does_the_right_thing;
- new_str >> integer_value_so_that_istream_does_the_right_thing;
- change.new_value = integer_value_so_that_istream_does_the_right_thing;
- }
- } else {
- fatal << "!!!" << endmsg;
- /*NOTREACHED*/
- }
-
- if (change.property != NoteNumber) {
- if ((prop = xml_change->property("note")) != 0) {
- istringstream note_str(prop->value());
- note_str >> note;
- } else {
- warning << "note information missing note value" << endmsg;
- note = 127;
- }
- } else {
- note = change.new_value;
- }
-
- if (change.property != Channel) {
- if ((prop = xml_change->property("channel")) != 0) {
- istringstream channel_str(prop->value());
- channel_str >> channel;
- } else {
- warning << "note information missing channel" << endmsg;
- channel = 0;
- }
- } else {
- channel = change.new_value;
- }
+ XMLProperty* prop;
+ NoteChange change;
+
+ if ((prop = xml_change->property("property")) != 0) {
+ change.property = (Property) string_2_enum (prop->value(), change.property);
+ } else {
+ fatal << "!!!" << endmsg;
+ /*NOTREACHED*/
+ }
- if (change.property != StartTime) {
- if ((prop = xml_change->property("time")) != 0) {
- istringstream time_str(prop->value());
- time_str >> time;
- } else {
- warning << "note information missing time" << endmsg;
- time = 0;
- }
- } else {
- time = change.new_time;
- }
+ if ((prop = xml_change->property ("id")) == 0) {
+ error << _("No NoteID found for note property change - ignored") << endmsg;
+ return change;
+ }
- if (change.property != Length) {
- if ((prop = xml_change->property("length")) != 0) {
- istringstream length_str(prop->value());
- length_str >> length;
- } else {
- warning << "note information missing length" << endmsg;
- length = 1;
- }
- } else {
- length = change.new_time;
- }
+ gint note_id = atoi (prop->value().c_str());
- if (change.property != Velocity) {
- if ((prop = xml_change->property("velocity")) != 0) {
- istringstream velocity_str(prop->value());
- velocity_str >> velocity;
- } else {
- warning << "note information missing velocity" << endmsg;
- velocity = 127;
- }
- } else {
- velocity = change.new_value;
- }
+ if ((prop = xml_change->property ("old")) != 0) {
+ istringstream old_str (prop->value());
+ if (change.property == StartTime || change.property == Length) {
+ old_str >> change.old_time;
+ } else {
+ int integer_value_so_that_istream_does_the_right_thing;
+ old_str >> integer_value_so_that_istream_does_the_right_thing;
+ change.old_value = integer_value_so_that_istream_does_the_right_thing;
+ }
+ } else {
+ fatal << "!!!" << endmsg;
+ /*NOTREACHED*/
+ }
- /* we must point at the instance of the note that is actually in the model.
- so go look for it ...
- */
+ if ((prop = xml_change->property ("new")) != 0) {
+ istringstream new_str (prop->value());
+ if (change.property == StartTime || change.property == Length) {
+ new_str >> change.new_time;
+ } else {
+ int integer_value_so_that_istream_does_the_right_thing;
+ new_str >> integer_value_so_that_istream_does_the_right_thing;
+ change.new_value = integer_value_so_that_istream_does_the_right_thing;
+ }
+ } else {
+ fatal << "!!!" << endmsg;
+ /*NOTREACHED*/
+ }
- NotePtr new_note (new Evoral::Note<TimeType> (channel, time, length, note, velocity));
+ /* we must point at the instance of the note that is actually in the model.
+ so go look for it ...
+ */
- change.note = _model->find_note (new_note);
+ change.note = _model->find_note (note_id);
- if (!change.note) {
- warning << "MIDI note " << *new_note << " not found in model - programmers should investigate this" << endmsg;
- /* use the actual new note */
- change.note = new_note;
- }
+ if (!change.note) {
+ warning << "MIDI note #" << note_id << " not found in model - programmers should investigate this" << endmsg;
+ return change;
+ }
- return change;
+ return change;
}
int
-MidiModel::DiffCommand::set_state(const XMLNode& diff_command, int /*version*/)
+MidiModel::NoteDiffCommand::set_state (const XMLNode& diff_command, int /*version*/)
{
- if (diff_command.name() != string(DIFF_COMMAND_ELEMENT)) {
- return 1;
- }
+ if (diff_command.name() != string (NOTE_DIFF_COMMAND_ELEMENT)) {
+ return 1;
+ }
/* additions */
- _added_notes.clear();
- XMLNode* added_notes = diff_command.child(ADDED_NOTES_ELEMENT);
- if (added_notes) {
- XMLNodeList notes = added_notes->children();
- transform(notes.begin(), notes.end(), back_inserter(_added_notes),
- boost::bind (&DiffCommand::unmarshal_note, this, _1));
- }
+ _added_notes.clear();
+ XMLNode* added_notes = diff_command.child(ADDED_NOTES_ELEMENT);
+ if (added_notes) {
+ XMLNodeList notes = added_notes->children();
+ transform(notes.begin(), notes.end(), back_inserter(_added_notes),
+ boost::bind (&NoteDiffCommand::unmarshal_note, this, _1));
+ }
/* removals */
- _removed_notes.clear();
- XMLNode* removed_notes = diff_command.child(REMOVED_NOTES_ELEMENT);
- if (removed_notes) {
- XMLNodeList notes = removed_notes->children();
- transform(notes.begin(), notes.end(), back_inserter(_removed_notes),
- boost::bind (&DiffCommand::unmarshal_note, this, _1));
- }
+ _removed_notes.clear();
+ XMLNode* removed_notes = diff_command.child(REMOVED_NOTES_ELEMENT);
+ if (removed_notes) {
+ XMLNodeList notes = removed_notes->children();
+ transform(notes.begin(), notes.end(), back_inserter(_removed_notes),
+ boost::bind (&NoteDiffCommand::unmarshal_note, this, _1));
+ }
/* changes */
- _changes.clear();
+ _changes.clear();
- XMLNode* changed_notes = diff_command.child(DIFF_NOTES_ELEMENT);
+ XMLNode* changed_notes = diff_command.child(DIFF_NOTES_ELEMENT);
- if (changed_notes) {
- XMLNodeList notes = changed_notes->children();
- transform (notes.begin(), notes.end(), back_inserter(_changes),
- boost::bind (&DiffCommand::unmarshal_change, this, _1));
+ if (changed_notes) {
+ XMLNodeList notes = changed_notes->children();
+ transform (notes.begin(), notes.end(), back_inserter(_changes),
+ boost::bind (&NoteDiffCommand::unmarshal_change, this, _1));
- }
+ }
/* side effect removals caused by changes */
-
- side_effect_removals.clear();
- XMLNode* side_effect_notes = diff_command.child(SIDE_EFFECT_REMOVALS_ELEMENT);
+ side_effect_removals.clear();
+
+ XMLNode* side_effect_notes = diff_command.child(SIDE_EFFECT_REMOVALS_ELEMENT);
- if (side_effect_notes) {
- XMLNodeList notes = side_effect_notes->children();
- cerr << "Reconstruct DiffCommand with " << notes.size() << " SER's\n";
+ if (side_effect_notes) {
+ XMLNodeList notes = side_effect_notes->children();
for (XMLNodeList::iterator n = notes.begin(); n != notes.end(); ++n) {
side_effect_removals.insert (unmarshal_note (*n));
}
- }
+ }
- return 0;
+ return 0;
}
XMLNode&
-MidiModel::DiffCommand::get_state ()
+MidiModel::NoteDiffCommand::get_state ()
{
- XMLNode* diff_command = new XMLNode(DIFF_COMMAND_ELEMENT);
- diff_command->add_property("midi-source", _model->midi_source()->id().to_s());
-
- XMLNode* changes = diff_command->add_child(DIFF_NOTES_ELEMENT);
- for_each(_changes.begin(), _changes.end(),
- boost::bind (
- boost::bind (&XMLNode::add_child_nocopy, changes, _1),
- boost::bind (&DiffCommand::marshal_change, this, _1)));
-
- XMLNode* added_notes = diff_command->add_child(ADDED_NOTES_ELEMENT);
- for_each(_added_notes.begin(), _added_notes.end(),
- boost::bind(
- boost::bind (&XMLNode::add_child_nocopy, added_notes, _1),
- boost::bind (&DiffCommand::marshal_note, this, _1)));
-
- XMLNode* removed_notes = diff_command->add_child(REMOVED_NOTES_ELEMENT);
- for_each(_removed_notes.begin(), _removed_notes.end(),
- boost::bind (
- boost::bind (&XMLNode::add_child_nocopy, removed_notes, _1),
- boost::bind (&DiffCommand::marshal_note, this, _1)));
+ XMLNode* diff_command = new XMLNode (NOTE_DIFF_COMMAND_ELEMENT);
+ diff_command->add_property("midi-source", _model->midi_source()->id().to_s());
+
+ XMLNode* changes = diff_command->add_child(DIFF_NOTES_ELEMENT);
+ for_each(_changes.begin(), _changes.end(),
+ boost::bind (
+ boost::bind (&XMLNode::add_child_nocopy, changes, _1),
+ boost::bind (&NoteDiffCommand::marshal_change, this, _1)));
+
+ XMLNode* added_notes = diff_command->add_child(ADDED_NOTES_ELEMENT);
+ for_each(_added_notes.begin(), _added_notes.end(),
+ boost::bind(
+ boost::bind (&XMLNode::add_child_nocopy, added_notes, _1),
+ boost::bind (&NoteDiffCommand::marshal_note, this, _1)));
+
+ XMLNode* removed_notes = diff_command->add_child(REMOVED_NOTES_ELEMENT);
+ for_each(_removed_notes.begin(), _removed_notes.end(),
+ boost::bind (
+ boost::bind (&XMLNode::add_child_nocopy, removed_notes, _1),
+ boost::bind (&NoteDiffCommand::marshal_note, this, _1)));
/* if this command had side-effects, store that state too
*/
for_each(side_effect_removals.begin(), side_effect_removals.end(),
boost::bind (
boost::bind (&XMLNode::add_child_nocopy, side_effect_notes, _1),
- boost::bind (&DiffCommand::marshal_note, this, _1)));
+ boost::bind (&NoteDiffCommand::marshal_note, this, _1)));
}
- return *diff_command;
+ return *diff_command;
+}
+
+MidiModel::SysExDiffCommand::SysExDiffCommand (boost::shared_ptr<MidiModel> m, const XMLNode& node)
+ : DiffCommand (m, "")
+{
+ assert (_model);
+ set_state (node, Stateful::loading_state_version);
+}
+
+void
+MidiModel::SysExDiffCommand::change (boost::shared_ptr<Evoral::Event<TimeType> > s, TimeType new_time)
+{
+ Change change;
+
+ change.sysex = s;
+ change.property = Time;
+ change.old_time = s->time ();
+ change.new_time = new_time;
+
+ _changes.push_back (change);
+}
+
+void
+MidiModel::SysExDiffCommand::operator() ()
+{
+ {
+ MidiModel::WriteLock lock (_model->edit_lock ());
+
+ for (ChangeList::iterator i = _changes.begin(); i != _changes.end(); ++i) {
+ switch (i->property) {
+ case Time:
+ i->sysex->set_time (i->new_time);
+ }
+ }
+ }
+
+ _model->ContentsChanged (); /* EMIT SIGNAL */
+}
+
+void
+MidiModel::SysExDiffCommand::undo ()
+{
+ {
+ MidiModel::WriteLock lock (_model->edit_lock ());
+
+ for (ChangeList::iterator i = _changes.begin(); i != _changes.end(); ++i) {
+ switch (i->property) {
+ case Time:
+ i->sysex->set_time (i->old_time);
+ break;
+ }
+ }
+
+ }
+
+ _model->ContentsChanged(); /* EMIT SIGNAL */
+}
+
+XMLNode&
+MidiModel::SysExDiffCommand::marshal_change (const Change& change)
+{
+ XMLNode* xml_change = new XMLNode ("Change");
+
+ /* first, the change itself */
+
+ xml_change->add_property ("property", enum_2_string (change.property));
+
+ {
+ ostringstream old_value_str (ios::ate);
+ old_value_str << change.old_time;
+ xml_change->add_property ("old", old_value_str.str());
+ }
+
+ {
+ ostringstream new_value_str (ios::ate);
+ new_value_str << change.new_time;
+ xml_change->add_property ("new", new_value_str.str());
+ }
+
+ ostringstream id_str;
+ id_str << change.sysex->id();
+ xml_change->add_property ("id", id_str.str());
+
+ return *xml_change;
+}
+
+MidiModel::SysExDiffCommand::Change
+MidiModel::SysExDiffCommand::unmarshal_change (XMLNode *xml_change)
+{
+ XMLProperty* prop;
+ Change change;
+
+ if ((prop = xml_change->property ("property")) != 0) {
+ change.property = (Property) string_2_enum (prop->value(), change.property);
+ } else {
+ fatal << "!!!" << endmsg;
+ /*NOTREACHED*/
+ }
+
+ if ((prop = xml_change->property ("id")) == 0) {
+ error << _("No SysExID found for sys-ex property change - ignored") << endmsg;
+ return change;
+ }
+
+ gint sysex_id = atoi (prop->value().c_str());
+
+ if ((prop = xml_change->property ("old")) != 0) {
+ istringstream old_str (prop->value());
+ old_str >> change.old_time;
+ } else {
+ fatal << "!!!" << endmsg;
+ /*NOTREACHED*/
+ }
+
+ if ((prop = xml_change->property ("new")) != 0) {
+ istringstream new_str (prop->value());
+ new_str >> change.new_time;
+ } else {
+ fatal << "!!!" << endmsg;
+ /*NOTREACHED*/
+ }
+
+ /* we must point at the instance of the sysex that is actually in the model.
+ so go look for it ...
+ */
+
+ change.sysex = _model->find_sysex (sysex_id);
+
+ if (!change.sysex) {
+ warning << "Sys-ex #" << sysex_id << " not found in model - programmers should investigate this" << endmsg;
+ return change;
+ }
+
+ return change;
+}
+
+int
+MidiModel::SysExDiffCommand::set_state (const XMLNode& diff_command, int /*version*/)
+{
+ if (diff_command.name() != string (SYSEX_DIFF_COMMAND_ELEMENT)) {
+ return 1;
+ }
+
+ /* changes */
+
+ _changes.clear();
+
+ XMLNode* changed_sysexes = diff_command.child (DIFF_SYSEXES_ELEMENT);
+
+ if (changed_sysexes) {
+ XMLNodeList sysexes = changed_sysexes->children();
+ transform (sysexes.begin(), sysexes.end(), back_inserter (_changes),
+ boost::bind (&SysExDiffCommand::unmarshal_change, this, _1));
+
+ }
+
+ return 0;
+}
+
+XMLNode&
+MidiModel::SysExDiffCommand::get_state ()
+{
+ XMLNode* diff_command = new XMLNode (SYSEX_DIFF_COMMAND_ELEMENT);
+ diff_command->add_property ("midi-source", _model->midi_source()->id().to_s());
+
+ XMLNode* changes = diff_command->add_child(DIFF_SYSEXES_ELEMENT);
+ for_each (_changes.begin(), _changes.end(),
+ boost::bind (
+ boost::bind (&XMLNode::add_child_nocopy, changes, _1),
+ boost::bind (&SysExDiffCommand::marshal_change, this, _1)));
+
+ return *diff_command;
}
/** Write all of the model to a MidiSource (i.e. save the model).
* user can switch a recorded track (with note durations from some instrument)
* to percussive, save, reload, then switch it back to sustained without
* destroying the original note durations.
+ *
+ * Similarly, control events are written without interpolation (as with the
+ * `Discrete' mode).
*/
bool
MidiModel::write_to (boost::shared_ptr<MidiSource> source)
{
- ReadLock lock(read_lock());
+ ReadLock lock(read_lock());
- const bool old_percussive = percussive();
- set_percussive(false);
+ const bool old_percussive = percussive();
+ set_percussive(false);
- source->drop_model();
- source->mark_streaming_midi_write_started(note_mode(), _midi_source->timeline_position());
+ boost::shared_ptr<MidiSource> ms = _midi_source.lock ();
+ assert (ms);
+
+ source->drop_model();
+ source->mark_streaming_midi_write_started (note_mode(), ms->timeline_position ());
- for (Evoral::Sequence<TimeType>::const_iterator i = begin(); i != end(); ++i) {
+ for (Evoral::Sequence<TimeType>::const_iterator i = begin(0, true); i != end(); ++i) {
source->append_event_unlocked_beats(*i);
- }
+ }
+
+ set_percussive(old_percussive);
+ source->mark_streaming_write_completed();
+
+ set_edited(false);
+
+ return true;
+}
+
+/** very similar to ::write_to() but writes to the model's own
+ existing midi_source, without making it call MidiSource::drop_model().
+ the caller is a MidiSource that needs to catch up with the state
+ of the model.
+*/
+bool
+MidiModel::sync_to_source ()
+{
+ ReadLock lock(read_lock());
- set_percussive(old_percussive);
- source->mark_streaming_write_completed();
+ const bool old_percussive = percussive();
+ set_percussive(false);
- set_edited(false);
+ boost::shared_ptr<MidiSource> ms = _midi_source.lock ();
+ assert (ms);
+
+ ms->mark_streaming_midi_write_started (note_mode(), ms->timeline_position());
- return true;
+ for (Evoral::Sequence<TimeType>::const_iterator i = begin(0, true); i != end(); ++i) {
+ ms->append_event_unlocked_beats(*i);
+ }
+
+ set_percussive (old_percussive);
+ ms->mark_streaming_write_completed ();
+
+ set_edited (false);
+
+ return true;
}
/** Write part or all of the model to a MidiSource (i.e. save the model).
bool
MidiModel::write_section_to (boost::shared_ptr<MidiSource> source, Evoral::MusicalTime begin_time, Evoral::MusicalTime end_time)
{
- ReadLock lock(read_lock());
+ ReadLock lock(read_lock());
MidiStateTracker mst;
Evoral::MusicalTime extra_note_on_time = end_time;
- const bool old_percussive = percussive();
- set_percussive(false);
+ const bool old_percussive = percussive();
+ set_percussive(false);
- source->drop_model();
- source->mark_streaming_midi_write_started(note_mode(), _midi_source->timeline_position());
+ boost::shared_ptr<MidiSource> ms = _midi_source.lock ();
+ assert (ms);
+
+ source->drop_model();
+ source->mark_streaming_midi_write_started (note_mode(), ms->timeline_position());
- for (Evoral::Sequence<TimeType>::const_iterator i = begin(); i != end(); ++i) {
+ for (Evoral::Sequence<TimeType>::const_iterator i = begin(0, true); i != end(); ++i) {
const Evoral::Event<Evoral::MusicalTime>& ev (*i);
-
+
if (ev.time() >= begin_time && ev.time() < end_time) {
const Evoral::MIDIEvent<Evoral::MusicalTime>* mev =
static_cast<const Evoral::MIDIEvent<Evoral::MusicalTime>* > (&ev);
-
+
if (!mev) {
continue;
}
if (mev->is_note_off()) {
-
+
if (!mst.active (mev->note(), mev->channel())) {
-
+
/* add a note-on at the start of the range we're writing
to the file. velocity is just an arbitary reasonable value.
*/
-
+
Evoral::MIDIEvent<Evoral::MusicalTime> on (mev->event_type(), extra_note_on_time, 3, 0, true);
on.set_type (mev->type());
on.set_note (mev->note());
on.set_channel (mev->channel());
on.set_velocity (mev->velocity());
-
+
cerr << "Add note on for odd note off, note = " << (int) on.note() << endl;
source->append_event_unlocked_beats (on);
mst.add (on.note(), on.channel());
mst.dump (cerr);
extra_note_on_time += 1.0/128.0;
}
-
+
cerr << "MIDI Note off (note = " << (int) mev->note() << endl;
source->append_event_unlocked_beats (*i);
mst.remove (mev->note(), mev->channel());
mst.dump (cerr);
-
+
} else if (mev->is_note_on()) {
cerr << "MIDI Note on (note = " << (int) mev->note() << endl;
mst.add (mev->note(), mev->channel());
source->append_event_unlocked_beats(*i);
}
}
- }
+ }
mst.resolve_notes (*source, end_time);
- set_percussive(old_percussive);
- source->mark_streaming_write_completed();
+ set_percussive(old_percussive);
+ source->mark_streaming_write_completed();
- set_edited(false);
+ set_edited(false);
- return true;
+ return true;
}
XMLNode&
MidiModel::get_state()
{
- XMLNode *node = new XMLNode("MidiModel");
- return *node;
+ XMLNode *node = new XMLNode("MidiModel");
+ return *node;
}
Evoral::Sequence<MidiModel::TimeType>::NotePtr
MidiModel::find_note (NotePtr other)
{
- Notes::iterator l = notes().lower_bound(other);
+ Notes::iterator l = notes().lower_bound(other);
- if (l != notes().end()) {
- for (; (*l)->time() == other->time(); ++l) {
+ if (l != notes().end()) {
+ for (; (*l)->time() == other->time(); ++l) {
/* NB: compare note contents, not note pointers.
If "other" was a ptr to a note already in
the model, we wouldn't be looking for it,
would we now?
- */
- if (**l == *other) {
- return *l;
- }
- }
- }
+ */
+ if (**l == *other) {
+ return *l;
+ }
+ }
+ }
+
+ return NotePtr();
+}
+
+Evoral::Sequence<MidiModel::TimeType>::NotePtr
+MidiModel::find_note (gint note_id)
+{
+ /* used only for looking up notes when reloading history from disk,
+ so we don't care about performance *too* much.
+ */
+
+ for (Notes::iterator l = notes().begin(); l != notes().end(); ++l) {
+ if ((*l)->id() == note_id) {
+ return *l;
+ }
+ }
+
+ return NotePtr();
+}
+
+boost::shared_ptr<Evoral::Event<MidiModel::TimeType> >
+MidiModel::find_sysex (gint sysex_id)
+{
+ /* used only for looking up notes when reloading history from disk,
+ so we don't care about performance *too* much.
+ */
+
+ for (SysExes::iterator l = sysexes().begin(); l != sysexes().end(); ++l) {
+ if ((*l)->id() == sysex_id) {
+ return *l;
+ }
+ }
- return NotePtr();
+ return boost::shared_ptr<Evoral::Event<TimeType> > ();
}
/** Lock and invalidate the source.
MidiModel::WriteLock
MidiModel::edit_lock()
{
- Glib::Mutex::Lock* source_lock = new Glib::Mutex::Lock(_midi_source->mutex());
- _midi_source->invalidate(); // Release cached iterator's read lock on model
- return WriteLock(new WriteLockImpl(source_lock, _lock, _control_lock));
+ boost::shared_ptr<MidiSource> ms = _midi_source.lock ();
+ assert (ms);
+
+ Glib::Mutex::Lock* source_lock = new Glib::Mutex::Lock (ms->mutex());
+ ms->invalidate(); // Release cached iterator's read lock on model
+ return WriteLock(new WriteLockImpl(source_lock, _lock, _control_lock));
}
/** Lock just the model, the source lock must already be held.
MidiModel::WriteLock
MidiModel::write_lock()
{
- assert(!_midi_source->mutex().trylock());
- return WriteLock(new WriteLockImpl(NULL, _lock, _control_lock));
+ boost::shared_ptr<MidiSource> ms = _midi_source.lock ();
+ assert (ms);
+
+ assert (!ms->mutex().trylock ());
+ return WriteLock(new WriteLockImpl(NULL, _lock, _control_lock));
}
int
MidiModel::resolve_overlaps_unlocked (const NotePtr note, void* arg)
{
using namespace Evoral;
-
+
if (_writing || insert_merge_policy() == InsertMergeRelax) {
return 0;
}
- DiffCommand* cmd = static_cast<DiffCommand*>(arg);
+ NoteDiffCommand* cmd = static_cast<NoteDiffCommand*>(arg);
TimeType sa = note->time();
TimeType ea = note->end_time();
-
+
const Pitches& p (pitches (note->channel()));
NotePtr search_note(new Note<TimeType>(0, 0, 0, note->note()));
set<NotePtr> to_be_deleted;
TimeType note_time = note->time();
TimeType note_length = note->length();
+ DEBUG_TRACE (DEBUG::Sequence, string_compose ("%1 checking overlaps for note %2 @ %3\n", this, (int)note->note(), note->time()));
+
for (Pitches::const_iterator i = p.lower_bound (search_note);
i != p.end() && (*i)->note() == note->note(); ++i) {
-
+
TimeType sb = (*i)->time();
TimeType eb = (*i)->end_time();
OverlapType overlap = OverlapNone;
-
+
if ((sb > sa) && (eb <= ea)) {
overlap = OverlapInternal;
} else if ((eb >= sa) && (eb <= ea)) {
continue;
}
+ DEBUG_TRACE (DEBUG::Sequence, string_compose ("\toverlap is %1 for (%2,%3) vs (%4,%5)\n", enum_2_string(overlap),
+ sa, ea, sb, eb));
+
if (insert_merge_policy() == InsertMergeReject) {
+ DEBUG_TRACE (DEBUG::Sequence, string_compose ("%1 just reject\n", this));
return -1;
}
break;
case InsertMergeTruncateExisting:
if (cmd) {
- cmd->change (*i, DiffCommand::Length, (note->time() - (*i)->time()));
+ cmd->change (*i, NoteDiffCommand::Length, (note->time() - (*i)->time()));
}
(*i)->set_length (note->time() - (*i)->time());
break;
break;
case InsertMergeExtend:
if (cmd) {
- cmd->change ((*i), DiffCommand::Length, note->end_time() - (*i)->time());
+ cmd->change ((*i), NoteDiffCommand::Length, note->end_time() - (*i)->time());
}
(*i)->set_length (note->end_time() - (*i)->time());
return -1; /* do not add the new note */
set_note_length = true;
note_length = min (note_length, ((*i)->time() - note->time()));
break;
-
+
case InsertMergeExtend:
/* we can't reset the time of the existing note because
that will corrupt time ordering. So remove the
if (set_note_time) {
if (cmd) {
- cmd->change (note, DiffCommand::StartTime, note_time);
+ cmd->change (note, NoteDiffCommand::StartTime, note_time);
}
note->set_time (note_time);
}
if (set_note_length) {
if (cmd) {
- cmd->change (note, DiffCommand::Length, note_length);
+ cmd->change (note, NoteDiffCommand::Length, note_length);
}
note->set_length (note_length);
}
InsertMergePolicy
MidiModel::insert_merge_policy () const
{
- char* c = getenv ("AMP");
+ /* XXX ultimately this should be a per-track or even per-model policy */
+ boost::shared_ptr<MidiSource> ms = _midi_source.lock ();
+ assert (ms);
- if (!c || c[0] == 0) {
- return InsertMergeReject;
- }
-
- switch (c[0]) {
- case 'x':
- return InsertMergeRelax;
- case 'p':
- return InsertMergeReplace;
- case 't':
- return InsertMergeTruncateExisting;
- case 'a':
- return InsertMergeTruncateAddition;
- case 'e':
- default:
- return InsertMergeExtend;
- }
+ return ms->session().config.get_insert_merge_policy ();
}
void
-MidiModel::set_midi_source (MidiSource* s)
+MidiModel::set_midi_source (boost::shared_ptr<MidiSource> s)
{
- _midi_source->invalidate ();
+ boost::shared_ptr<MidiSource> old = _midi_source.lock ();
+
+ if (old) {
+ old->invalidate ();
+ }
+
+ _midi_source_connections.drop_connections ();
+
_midi_source = s;
+
+ s->InterpolationChanged.connect_same_thread (
+ _midi_source_connections, boost::bind (&MidiModel::source_interpolation_changed, this, _1, _2)
+ );
+
+ s->AutomationStateChanged.connect_same_thread (
+ _midi_source_connections, boost::bind (&MidiModel::source_automation_state_changed, this, _1, _2)
+ );
+}
+
+/** The source has signalled that the interpolation style for a parameter has changed. In order to
+ * keep MidiSource and ControlList interpolation state the same, we pass this change onto the
+ * appropriate ControlList.
+ *
+ * The idea is that MidiSource and the MidiModel's ControlList states are kept in sync, and one
+ * or the other is listened to by the GUI.
+ */
+void
+MidiModel::source_interpolation_changed (Evoral::Parameter p, Evoral::ControlList::InterpolationStyle s)
+{
+ Glib::Mutex::Lock lm (_control_lock);
+ control(p)->list()->set_interpolation (s);
+}
+
+/** A ControlList has signalled that its interpolation style has changed. Again, in order to keep
+ * MidiSource and ControlList interpolation state in sync, we pass this change onto our MidiSource.
+ */
+void
+MidiModel::control_list_interpolation_changed (Evoral::Parameter p, Evoral::ControlList::InterpolationStyle s)
+{
+ boost::shared_ptr<MidiSource> ms = _midi_source.lock ();
+ assert (ms);
+
+ ms->set_interpolation_of (p, s);
+}
+
+void
+MidiModel::source_automation_state_changed (Evoral::Parameter p, AutoState s)
+{
+ Glib::Mutex::Lock lm (_control_lock);
+ boost::shared_ptr<AutomationList> al = boost::dynamic_pointer_cast<AutomationList> (control(p)->list ());
+ al->set_automation_state (s);
+}
+
+void
+MidiModel::automation_list_automation_state_changed (Evoral::Parameter p, AutoState s)
+{
+ boost::shared_ptr<MidiSource> ms = _midi_source.lock ();
+ assert (ms);
+ ms->set_automation_state_of (p, s);
+}
+
+boost::shared_ptr<Evoral::Control>
+MidiModel::control_factory (Evoral::Parameter const & p)
+{
+ boost::shared_ptr<Evoral::Control> c = Automatable::control_factory (p);
+
+ /* Set up newly created control's lists to the appropriate interpolation and
+ automation state from our source.
+ */
+
+ boost::shared_ptr<MidiSource> ms = _midi_source.lock ();
+ assert (ms);
+
+ c->list()->set_interpolation (ms->interpolation_of (p));
+
+ boost::shared_ptr<AutomationList> al = boost::dynamic_pointer_cast<AutomationList> (c->list ());
+ assert (al);
+
+ al->set_automation_state (ms->automation_state_of (p));
+
+ return c;
+}
+
+boost::shared_ptr<const MidiSource>
+MidiModel::midi_source ()
+{
+ return _midi_source.lock ();
+}
+
+/** Moves notes, controllers and sys-ex to insert silence at the start of the model.
+ * Adds commands to the session's current undo stack to reflect the movements.
+ */
+void
+MidiModel::insert_silence_at_start (TimeType t)
+{
+ boost::shared_ptr<MidiSource> s = _midi_source.lock ();
+ assert (s);
+
+ /* Notes */
+
+ if (!notes().empty ()) {
+ NoteDiffCommand* c = new_note_diff_command ("insert silence");
+
+ for (Notes::const_iterator i = notes().begin(); i != notes().end(); ++i) {
+ c->change (*i, NoteDiffCommand::StartTime, (*i)->time() + t);
+ }
+
+ apply_command_as_subcommand (s->session(), c);
+ }
+
+ /* Controllers */
+
+ for (Controls::iterator i = controls().begin(); i != controls().end(); ++i) {
+ boost::shared_ptr<AutomationControl> ac = boost::dynamic_pointer_cast<AutomationControl> (i->second);
+ XMLNode& before = ac->alist()->get_state ();
+ i->second->list()->shift (0, t);
+ XMLNode& after = ac->alist()->get_state ();
+ s->session().add_command (new MementoCommand<AutomationList> (new MidiAutomationListBinder (s, i->first), &before, &after));
+ }
+
+ /* Sys-ex */
+
+ if (!sysexes().empty()) {
+ SysExDiffCommand* c = new_sysex_diff_command ("insert silence");
+
+ for (SysExes::iterator i = sysexes().begin(); i != sysexes().end(); ++i) {
+ c->change (*i, (*i)->time() + t);
+ }
+
+ apply_command_as_subcommand (s->session(), c);
+ }
}
projects / ardour.git / blobdiff