Fixes to bundle manager to make it vaguely usable.

[ardour.git] / libs / ardour / ardour / midi_model.h

diff --git a/libs/ardour/ardour/midi_model.h b/libs/ardour/ardour/midi_model.h
index c68ea668a5e9ffd04137867b5b7ab3531d7d03e9..fb881ae127f0c825d8a1a4fb05fee21612673f40 100644 (file)
--- a/libs/ardour/ardour/midi_model.h
+++ b/libs/ardour/ardour/midi_model.h
@@ -1,7 +1,6 @@
-
 /*
-    Copyright (C) 2006 Paul Davis
-       Written by Dave Robillard, 2006
+    Copyright (C) 2007 Paul Davis
+    Author: Dave Robillard
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -22,33 +21,94 @@
 #ifndef __ardour_midi_model_h__ 
 #define __ardour_midi_model_h__
 
+#include <queue>
+#include <deque>
+#include <utility>
 #include <boost/utility.hpp>
+#include <glibmm/thread.h>
+#include <pbd/command.h>
+#include <ardour/types.h>
+#include <ardour/midi_buffer.h>
+#include <ardour/midi_ring_buffer.h>
+#include <ardour/automatable.h>
 #include <ardour/types.h>
-#include <ardour/buffer.h>
+#include <evoral/Note.hpp>
+#include <evoral/Sequence.hpp>
 
 namespace ARDOUR {
 
-/** A dynamically resizable collection of MIDI events, sorted by time
+class Session;
+class MidiSource;
+
+/** This is a higher level (than MidiBuffer) model of MIDI data, with separate
+ * representations for notes (instead of just unassociated note on/off events)
+ * and controller data.  Controller data is represented as part of the
+ * Automatable base (i.e. in a map of AutomationList, keyed by Parameter).
+ * Because of this MIDI controllers and automatable controllers/widgets/etc
+ * are easily interchangeable.
  */
-class MidiModel : public boost::noncopyable {
+class MidiModel : public AutomatableSequence<double> {
 public:
-       MidiModel(size_t size=0);
-       ~MidiModel();
-
-       void clear() { _events.clear(); }
+       typedef double TimeType;
 
-       /** Resizes vector if necessary (NOT realtime safe) */
-       void append(const MidiBuffer& data);
+       MidiModel(MidiSource* s, size_t size=0);
        
-       /** Resizes vector if necessary (NOT realtime safe) */
-       void append(double time, size_t size, Byte* in_buffer);
+       NoteMode note_mode() const { return (percussive() ? Percussive : Sustained); }
+       void set_note_mode(NoteMode mode) { set_percussive(mode == Percussive); };
+
+       /** Add/Remove notes.
+        * Technically all note operations can be implemented as one of these, but
+        * a custom command can be more efficient.
+        */
+       class DeltaCommand : public Command {
+       public:
+               DeltaCommand (boost::shared_ptr<MidiModel> m, const std::string& name);
+               DeltaCommand (boost::shared_ptr<MidiModel> m, const XMLNode& node);
+
+               const std::string& name() const { return _name; }
+               
+               void operator()();
+               void undo();
+               
+               int set_state (const XMLNode&);
+               XMLNode& get_state ();
+
+               void add(const boost::shared_ptr< Evoral::Note<TimeType> > note);
+               void remove(const boost::shared_ptr< Evoral::Note<TimeType> > note);
+
+       private:
+               XMLNode &marshal_note(const boost::shared_ptr< Evoral::Note<TimeType> > note);
+               boost::shared_ptr< Evoral::Note<TimeType> > unmarshal_note(XMLNode *xml_note);
+               
+               boost::shared_ptr<MidiModel> _model;
+               const std::string            _name;
+               
+               typedef std::list< boost::shared_ptr< Evoral::Note<TimeType> > > NoteList;
+               
+               NoteList _added_notes;
+               NoteList _removed_notes;
+       };
+
+       MidiModel::DeltaCommand* new_delta_command(const std::string name="midi edit");
+       void                     apply_command(Session& session, Command* cmd);
+
+       bool write_to(boost::shared_ptr<MidiSource> source);
+               
+       // MidiModel doesn't use the normal AutomationList serialisation code
+       // since controller data is stored in the .mid
+       XMLNode& get_state();
+       int set_state(const XMLNode&) { return 0; }
+
+       sigc::signal<void> ContentsChanged;
+       
+       const MidiSource* midi_source() const { return _midi_source; }
+       void set_midi_source(MidiSource* source) { _midi_source = source; } 
        
-       inline const MidiEvent& event_at(unsigned i) const { return _events[i]; }
-
-       inline size_t n_events() const { return _events.size(); }
-
 private:
-       std::vector<MidiEvent> _events;
+       friend class DeltaCommand;
+       
+       // We cannot use a boost::shared_ptr here to avoid a retain cycle
+       MidiSource* _midi_source;
 };
 
 } /* namespace ARDOUR */