remove those two pesky status widgets to the trait

midi/src/midi_edit.rs

@@ -0,0 +1,128 @@
+use crate::*;
+pub trait HasEditor {
+    fn editor (&self) -> &Option<MidiEditor>;
+    fn editor_mut (&mut self) -> &Option<MidiEditor>;
+    fn is_editing (&self) -> bool { true }
+    fn editor_w (&self) -> usize { 0 }
+    fn editor_h (&self) -> usize { 0 }
+}
+#[macro_export] macro_rules! has_editor {
+    (|$self:ident: $Struct:ident|{
+        editor     = $e0:expr;
+        editor_w   = $e1:expr;
+        editor_h   = $e2:expr;
+        is_editing = $e3:expr;
+    }) => {
+        impl HasEditor for $Struct {
+            fn editor (&$self) -> &Option<MidiEditor> { &$e0 }
+            fn editor_mut (&mut $self) -> &Option<MidiEditor> { &mut $e0 }
+            fn editor_w (&$self) -> usize { $e1 }
+            fn editor_h (&$self) -> usize { $e2 }
+            fn is_editing (&$self) -> bool { $e3 }
+        }
+    };
+    (|$self:ident:$Struct:ident$(<$($L:lifetime),*$($T:ident$(:$U:path)?),*>)?|$cb:expr) => {
+        impl $(<$($L),*$($T $(: $U)?),*>)? HasEditor for $Struct $(<$($L),*$($T),*>)? {
+            fn editor (&$self) -> &MidiEditor { &$cb }
+        }
+    };
+}
+/// Contains state for viewing and editing a clip
+pub struct MidiEditor {
+    pub mode:   PianoHorizontal,
+    pub size:   Measure<TuiOut>,
+    pub keymap: EdnKeymap,
+}
+impl std::fmt::Debug for MidiEditor {
+    fn fmt (&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+        f.debug_struct("MidiEditor")
+            .field("mode", &self.mode)
+            .finish()
+    }
+}
+impl Default for MidiEditor {
+    fn default () -> Self {
+        Self {
+            mode: PianoHorizontal::new(None),
+            size: Measure::new(),
+            keymap: EdnKeymap(
+                EdnItem::<String>::read_all(include_str!("midi_editor_keys.edn"))
+                    .expect("failed to load keymap for MidiEditor")
+            )
+        }
+    }
+}
+impl MidiEditor {
+    pub fn clip_length (&self) -> usize {
+        self.clip().as_ref().map(|p|p.read().unwrap().length).unwrap_or(1)
+    }
+    /// Put note at current position
+    pub fn put_note (&mut self, advance: bool) {
+        let mut redraw = false;
+        if let Some(clip) = self.clip() {
+            let mut clip = clip.write().unwrap();
+            let note_start = self.time_point();
+            let note_point = self.note_point();
+            let note_len   = self.note_len();
+            let note_end   = note_start + (note_len.saturating_sub(1));
+            let key: u7    = u7::from(note_point as u8);
+            let vel: u7    = 100.into();
+            let length     = clip.length;
+            let note_end   = note_end % length;
+            let note_on = MidiMessage::NoteOn { key, vel };
+            if !clip.notes[note_start].iter().any(|msg|*msg == note_on) {
+                clip.notes[note_start].push(note_on);
+            }
+            let note_off = MidiMessage::NoteOff { key, vel };
+            if !clip.notes[note_end].iter().any(|msg|*msg == note_off) {
+                clip.notes[note_end].push(note_off);
+            }
+            if advance {
+                self.set_time_point(note_end);
+            }
+            redraw = true;
+        }
+        if redraw {
+            self.mode.redraw();
+        }
+    }
+}
+from!(|clip: &Arc<RwLock<MidiClip>>|MidiEditor = {
+    let model = Self::from(Some(clip.clone()));
+    model.redraw();
+    model
+});
+from!(|clip: Option<Arc<RwLock<MidiClip>>>|MidiEditor = {
+    let mut model = Self::default();
+    *model.clip_mut() = clip;
+    model.redraw();
+    model
+});
+impl TimeRange for MidiEditor {
+    fn time_len   (&self) -> &AtomicUsize { self.mode.time_len()   }
+    fn time_zoom  (&self) -> &AtomicUsize { self.mode.time_zoom()  }
+    fn time_lock  (&self) -> &AtomicBool  { self.mode.time_lock()  }
+    fn time_start (&self) -> &AtomicUsize { self.mode.time_start() }
+    fn time_axis  (&self) -> &AtomicUsize { self.mode.time_axis()  }
+}
+impl NoteRange for MidiEditor {
+    fn note_lo    (&self) -> &AtomicUsize { self.mode.note_lo()    }
+    fn note_axis  (&self) -> &AtomicUsize { self.mode.note_axis()  }
+}
+impl NotePoint for MidiEditor {
+    fn note_len       (&self) -> usize  { self.mode.note_len() }
+    fn set_note_len   (&self, x: usize) { self.mode.set_note_len(x) }
+    fn note_point     (&self) -> usize  { self.mode.note_point() }
+    fn set_note_point (&self, x: usize) { self.mode.set_note_point(x) }
+}
+impl TimePoint for MidiEditor {
+    fn time_point     (&self) -> usize  { self.mode.time_point() }
+    fn set_time_point (&self, x: usize) { self.mode.set_time_point(x) }
+}
+impl MidiViewer for MidiEditor {
+    fn buffer_size (&self, clip: &MidiClip) -> (usize, usize) { self.mode.buffer_size(clip) }
+    fn redraw (&self) { self.mode.redraw() }
+    fn clip (&self) -> &Option<Arc<RwLock<MidiClip>>> { self.mode.clip() }
+    fn clip_mut (&mut self) -> &mut Option<Arc<RwLock<MidiClip>>> { self.mode.clip_mut() }
+    fn set_clip (&mut self, p: Option<&Arc<RwLock<MidiClip>>>) { self.mode.set_clip(p) }
+}