editor: move to device crate

crates/device/Cargo.toml

@@ -16,10 +16,11 @@ wavers    = { workspace = true, optional = true }
 winit     = { workspace = true, optional = true }
 
 [features]
-default   = [ "clock", "sequencer", "sampler", "lv2" ]
+default   = [ "clock", "editor", "sequencer", "sampler", "lv2" ]
 clock     = []
-sampler   = [ "symphonia", "wavers" ]
+editor    = []
 sequencer = [ "clock", "uuid" ]
+sampler   = [ "symphonia", "wavers" ]
 lv2       = [ "livi", "winit" ]
 vst2      = []
 vst3      = []

crates/device/src/device.rs

@@ -2,13 +2,18 @@ use crate::*;
 
 #[derive(Debug)]
 pub enum Device {
-    #[cfg(feature = "sequencer")] Sequencer(Sequencer),
-    #[cfg(feature = "sampler")]   Sampler(Sampler),
-    #[cfg(feature = "lv2")]       Lv2(Lv2),  // TODO
-    #[cfg(feature = "vst2")]      Vst2, // TODO
-    #[cfg(feature = "vst3")]      Vst3, // TODO
-    #[cfg(feature = "clap")]      Clap, // TODO
-    #[cfg(feature = "sf2")]       Sf2,  // TODO
+    #[cfg(feature = "sampler")]
+    Sampler(Sampler),
+    #[cfg(feature = "lv2")]  // TODO
+    Lv2(Lv2),
+    #[cfg(feature = "vst2")] // TODO
+    Vst2,
+    #[cfg(feature = "vst3")] // TODO
+    Vst3,
+    #[cfg(feature = "clap")] // TODO
+    Clap,
+    #[cfg(feature = "sf2")]  // TODO
+    Sf2,       
 }
 
 impl Device {
@@ -25,19 +30,22 @@ pub struct DeviceAudio<'a>(pub &'a mut Device);
 audio!(|self: DeviceAudio<'a>, client, scope|{
     use Device::*;
     match self.0 {
-        #[cfg(feature = "sequencer")] Sequencer(sequencer) =>
-            { Control::Continue /* TODO */ },
-        #[cfg(feature = "sampler")] Sampler(sampler) =>
-            SamplerAudio(sampler).process(client, scope),
-        #[cfg(feature = "lv2")] Lv2(lv2) =>
-            { todo!() }, // TODO
-        #[cfg(feature = "vst2")] Vst2 =>
-            { todo!() }, // TODO
-        #[cfg(feature = "vst3")] Vst3 =>
-            { todo!() }, // TODO
-        #[cfg(feature = "clap")] Clap =>
-            { todo!() }, // TODO
-        #[cfg(feature = "sf2")] Sf2 =>
-            { todo!() }, // TODO
+        #[cfg(feature = "sampler")]
+        Sampler(sampler) => SamplerAudio(sampler).process(client, scope),
+
+        #[cfg(feature = "lv2")]
+        Lv2(lv2) => lv2.process(client, scope),
+
+        #[cfg(feature = "vst2")]
+        Vst2 => { todo!() }, // TODO
+
+        #[cfg(feature = "vst3")]
+        Vst3 => { todo!() }, // TODO
+
+        #[cfg(feature = "clap")]
+        Clap => { todo!() }, // TODO
+
+        #[cfg(feature = "sf2")]
+        Sf2 => { todo!() }, // TODO
     }
 });

crates/device/src/editor.rs

@@ -0,0 +1,7 @@
+use crate::*;
+
+mod editor_api;    pub use self::editor_api::*;
+mod editor_model;  pub use self::editor_model::*;
+mod editor_view;   pub use self::editor_view::*;
+mod editor_view_h; pub use self::editor_view_h::*;
+mod editor_view_v; pub use self::editor_view_v::*;

crates/device/src/editor/editor_api.rs

@@ -0,0 +1,126 @@
+use crate::*;
+
+#[tengri_proc::expose] impl MidiEditor {
+    fn _todo_opt_clip_stub (&self) -> Option<Arc<RwLock<MidiClip>>> {
+        todo!()
+    }
+    fn time_lock (&self) -> bool {
+        self.get_time_lock()
+    }
+    fn time_lock_toggled (&self) -> bool {
+        !self.get_time_lock()
+    }
+
+    fn note_length (&self) -> usize {
+        self.get_note_len()
+    }
+
+    fn note_pos (&self) -> usize {
+        self.get_note_pos()
+    }
+    fn note_pos_next (&self) -> usize {
+        self.get_note_pos() + 1
+    }
+    fn note_pos_next_octave (&self) -> usize {
+        self.get_note_pos() + 12
+    }
+    fn note_pos_prev (&self) -> usize {
+        self.get_note_pos().saturating_sub(1)
+    }
+    fn note_pos_prev_octave (&self) -> usize {
+        self.get_note_pos().saturating_sub(12)
+    }
+
+    fn note_len (&self) -> usize {
+        self.get_note_len()
+    }
+    fn note_len_next (&self) -> usize {
+        self.get_note_len() + 1
+    }
+    fn note_len_prev (&self) -> usize {
+        self.get_note_len().saturating_sub(1)
+    }
+
+    fn note_range (&self) -> usize {
+        self.get_note_axis()
+    }
+    fn note_range_next (&self) -> usize {
+        self.get_note_axis() + 1
+    }
+    fn note_range_prev (&self) -> usize {
+        self.get_note_axis().saturating_sub(1)
+    }
+
+    fn time_pos (&self) -> usize {
+        self.get_time_pos()
+    }
+    fn time_pos_next (&self) -> usize {
+        self.get_time_pos() + self.time_zoom()
+    }
+    fn time_pos_prev (&self) -> usize {
+        self.get_time_pos().saturating_sub(self.time_zoom())
+    }
+
+    fn time_zoom (&self) -> usize {
+        self.get_time_zoom()
+    }
+    fn time_zoom_next (&self) -> usize {
+        self.get_time_zoom() + 1
+    }
+    fn time_zoom_prev (&self) -> usize {
+        self.get_time_zoom().saturating_sub(1).max(1)
+    }
+}
+
+#[tengri_proc::command(MidiEditor)] impl MidiEditCommand {
+    // TODO: 1-9 seek markers that by default start every 8th of the clip
+    fn note_append (editor: &mut MidiEditor) -> Perhaps<Self> {
+        editor.put_note(true);
+        Ok(None)
+    }
+    fn note_put (editor: &mut MidiEditor) -> Perhaps<Self> {
+        editor.put_note(false);
+        Ok(None)
+    }
+    fn note_del (editor: &mut MidiEditor) -> Perhaps<Self> {
+        todo!()
+    }
+    fn note_pos (editor: &mut MidiEditor, pos: usize) -> Perhaps<Self> {
+        editor.set_note_pos(pos.min(127));
+        Ok(None)
+    }
+    fn note_len (editor: &mut MidiEditor, value: usize) -> Perhaps<Self> {
+        //let note_len = editor.get_note_len();
+        //let time_zoom = editor.get_time_zoom();
+        editor.set_note_len(value);
+        //if note_len / time_zoom != x / time_zoom {
+            editor.redraw();
+        //}
+        Ok(None)
+    }
+    fn note_scroll (editor: &mut MidiEditor, value: usize) -> Perhaps<Self> {
+        editor.set_note_lo(value.min(127));
+        Ok(None)
+    }
+    fn time_pos (editor: &mut MidiEditor, value: usize) -> Perhaps<Self> {
+        editor.set_time_pos(value);
+        Ok(None)
+    }
+    fn time_scroll (editor: &mut MidiEditor, value: usize) -> Perhaps<Self> {
+        editor.set_time_start(value);
+        Ok(None)
+    }
+    fn time_zoom (editor: &mut MidiEditor, value: usize) -> Perhaps<Self> {
+        editor.set_time_zoom(value);
+        editor.redraw();
+        Ok(None)
+    }
+    fn time_lock (editor: &mut MidiEditor, value: bool) -> Perhaps<Self> {
+        editor.set_time_lock(value);
+        Ok(None)
+    }
+    fn show (editor: &mut MidiEditor, clip: Option<Arc<RwLock<MidiClip>>>) -> Perhaps<Self> {
+        editor.set_clip(clip.as_ref());
+        Ok(None)
+    }
+}

crates/device/src/editor/editor_model.rs

@@ -0,0 +1,160 @@
+use crate::*;
+
+/// Contains state for viewing and editing a clip
+pub struct MidiEditor {
+    /// Size of editor on screen
+    pub size: Measure<TuiOut>,
+    /// View mode and state of editor
+    pub mode: PianoHorizontal,
+}
+
+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 {
+            size: Measure::new(),
+            mode: PianoHorizontal::new(None),
+        }
+    }
+}
+
+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 MidiEditor {
+    /// 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.get_time_pos();
+            let note_pos   = self.get_note_pos();
+            let note_len   = self.get_note_len();
+            let note_end   = note_start + (note_len.saturating_sub(1));
+            let key: u7    = u7::from(note_pos 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_pos(note_end);
+            }
+            redraw = true;
+        }
+        if redraw {
+            self.mode.redraw();
+        }
+    }
+
+    pub fn clip_status (&self) -> impl Content<TuiOut> + '_ {
+        let (color, name, length, looped) = if let Some(clip) = self.clip().as_ref().map(|p|p.read().unwrap()) {
+            (clip.color, clip.name.clone(), clip.length, clip.looped)
+        } else { (ItemTheme::G[64], String::new().into(), 0, false) };
+        Bsp::e(
+            FieldH(color, "Edit", format!("{name} ({length})")),
+            FieldH(color, "Loop", looped.to_string())
+        )
+    }
+
+    pub fn edit_status (&self) -> impl Content<TuiOut> + '_ {
+        let (color, length) = if let Some(clip) = self.clip().as_ref().map(|p|p.read().unwrap()) {
+            (clip.color, clip.length)
+        } else { (ItemTheme::G[64], 0) };
+        let time_pos  = self.get_time_pos();
+        let time_zoom = self.get_time_zoom();
+        let time_lock = if self.get_time_lock() { "[lock]" } else { "      " };
+        let note_pos  = self.get_note_pos();
+        let note_name = format!("{:4}",  Note::pitch_to_name(note_pos));
+        let note_pos  = format!("{:>3}", note_pos);
+        let note_len  = format!("{:>4}", self.get_note_len());
+        Bsp::e(
+            FieldH(color, "Time", format!("{length}/{time_zoom}+{time_pos} {time_lock}")),
+            FieldH(color, "Note", format!("{note_name} {note_pos} {note_len}")),
+        )
+    }
+}
+
+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) -> &AtomicUsize { self.mode.note_len() }
+    fn note_pos (&self) -> &AtomicUsize { self.mode.note_pos() }
+}
+
+impl TimePoint for MidiEditor {
+    fn time_pos (&self) -> &AtomicUsize { self.mode.time_pos() }
+}
+
+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) }
+}
+
+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 }
+        }
+    };
+}
+

crates/device/src/editor/editor_view.rs

@@ -0,0 +1,9 @@
+use crate::*;
+
+has_size!(<TuiOut>|self: MidiEditor|&self.size);
+
+content!(TuiOut: |self: MidiEditor| {
+    self.autoscroll();
+    //self.autozoom();
+    self.size.of(&self.mode)
+});

crates/device/src/editor/editor_view_h.rs

@@ -0,0 +1,315 @@
+use crate::*;
+
+/// A clip, rendered as a horizontal piano roll.
+#[derive(Clone)]
+pub struct PianoHorizontal {
+    pub clip: Option<Arc<RwLock<MidiClip>>>,
+    /// Buffer where the whole clip is rerendered on change
+    pub buffer: Arc<RwLock<BigBuffer>>,
+    /// Size of actual notes area
+    pub size:   Measure<TuiOut>,
+    /// The display window
+    pub range:  MidiRangeModel,
+    /// The note cursor
+    pub point:  MidiPointModel,
+    /// The highlight color palette
+    pub color:  ItemTheme,
+    /// Width of the keyboard
+    pub keys_width: u16,
+}
+
+impl PianoHorizontal {
+    pub fn new (clip: Option<&Arc<RwLock<MidiClip>>>) -> Self {
+        let size = Measure::new();
+        let mut range  = MidiRangeModel::from((12, true));
+        range.time_axis = size.x.clone();
+        range.note_axis = size.y.clone();
+        let piano = Self {
+            keys_width: 5,
+            size,
+            range,
+            buffer: RwLock::new(Default::default()).into(),
+            point:  MidiPointModel::default(),
+            clip: clip.cloned(),
+            color: clip.as_ref().map(|p|p.read().unwrap().color).unwrap_or(ItemTheme::G[64]),
+        };
+        piano.redraw();
+        piano
+    }
+}
+
+pub(crate) fn note_y_iter (note_lo: usize, note_hi: usize, y0: u16)
+    -> impl Iterator<Item=(usize, u16, usize)>
+{
+    (note_lo..=note_hi).rev().enumerate().map(move|(y, n)|(y, y0 + y as u16, n))
+}
+
+content!(TuiOut:|self: PianoHorizontal| Tui::bg(Tui::g(40), Bsp::s(
+    Bsp::e(
+        Fixed::x(5, format!("{}x{}", self.size.w(), self.size.h())),
+        self.timeline()
+    ),
+    Bsp::e(
+        self.keys(),
+        self.size.of(Tui::bg(Tui::g(32), Bsp::b(
+            Fill::xy(self.notes()),
+            Fill::xy(self.cursor()),
+        )))
+    ),
+)));
+
+impl PianoHorizontal {
+    /// Draw the piano roll background.
+    ///
+    /// This mode uses full blocks on note on and half blocks on legato: █▄ █▄ █▄
+    fn draw_bg (buf: &mut BigBuffer, clip: &MidiClip, zoom: usize, note_len: usize) {
+        for (y, note) in (0..=127).rev().enumerate() {
+            for (x, time) in (0..buf.width).map(|x|(x, x*zoom)) {
+                let cell = buf.get_mut(x, y).unwrap();
+                cell.set_bg(clip.color.darkest.rgb);
+                if time % 384 == 0 {
+                    cell.set_fg(clip.color.darker.rgb);
+                    cell.set_char('│');
+                } else if time % 96 == 0 {
+                    cell.set_fg(clip.color.dark.rgb);
+                    cell.set_char('╎');
+                } else if time % note_len == 0 {
+                    cell.set_fg(clip.color.darker.rgb);
+                    cell.set_char('┊');
+                } else if (127 - note) % 12 == 0 {
+                    cell.set_fg(clip.color.darker.rgb);
+                    cell.set_char('=');
+                } else if (127 - note) % 6 == 0 {
+                    cell.set_fg(clip.color.darker.rgb);
+                    cell.set_char('—');
+                } else {
+                    cell.set_fg(clip.color.darker.rgb);
+                    cell.set_char('·');
+                }
+            }
+        }
+    }
+    /// Draw the piano roll foreground.
+    ///
+    /// This mode uses full blocks on note on and half blocks on legato: █▄ █▄ █▄
+    fn draw_fg (buf: &mut BigBuffer, clip: &MidiClip, zoom: usize) {
+        let style = Style::default().fg(clip.color.base.rgb);//.bg(Rgb(0, 0, 0));
+        let mut notes_on = [false;128];
+        for (x, time_start) in (0..clip.length).step_by(zoom).enumerate() {
+            for (_y, note) in (0..=127).rev().enumerate() {
+                if let Some(cell) = buf.get_mut(x, note) {
+                    if notes_on[note] {
+                        cell.set_char('▂');
+                        cell.set_style(style);
+                    }
+                }
+            }
+            let time_end = time_start + zoom;
+            for time in time_start..time_end.min(clip.length) {
+                for event in clip.notes[time].iter() {
+                    match event {
+                        MidiMessage::NoteOn { key, .. } => {
+                            let note = key.as_int() as usize;
+                            if let Some(cell) = buf.get_mut(x, note) {
+                                cell.set_char('█');
+                                cell.set_style(style);
+                            }
+                            notes_on[note] = true
+                        },
+                        MidiMessage::NoteOff { key, .. } => {
+                            notes_on[key.as_int() as usize] = false
+                        },
+                        _ => {}
+                    }
+                }
+            }
+
+        }
+    }
+    fn notes (&self) -> impl Content<TuiOut> {
+        let time_start = self.get_time_start();
+        let note_lo    = self.get_note_lo();
+        let note_hi    = self.get_note_hi();
+        let buffer     = self.buffer.clone();
+        ThunkRender::new(move|to: &mut TuiOut|{
+            let source = buffer.read().unwrap();
+            let [x0, y0, w, _h] = to.area().xywh();
+            //if h as usize != note_axis {
+                //panic!("area height mismatch: {h} <> {note_axis}");
+            //}
+            for (area_x, screen_x) in (x0..x0+w).enumerate() {
+                for (area_y, screen_y, _note) in note_y_iter(note_lo, note_hi, y0) {
+                    let source_x = time_start + area_x;
+                    let source_y = note_hi    - area_y;
+                    // TODO: enable loop rollover:
+                    //let source_x = (time_start + area_x) % source.width.max(1);
+                    //let source_y = (note_hi    - area_y) % source.height.max(1);
+                    let is_in_x = source_x < source.width;
+                    let is_in_y = source_y < source.height;
+                    if is_in_x && is_in_y {
+                        if let Some(source_cell) = source.get(source_x, source_y) {
+                            if let Some(cell) = to.buffer.cell_mut(ratatui::prelude::Position::from((screen_x, screen_y))) {
+                                *cell = source_cell.clone();
+                            }
+                        }
+                    }
+                }
+            }
+        })
+    }
+    fn cursor (&self) -> impl Content<TuiOut> {
+        let note_hi    = self.get_note_hi();
+        let note_lo    = self.get_note_lo();
+        let note_pos   = self.get_note_pos();
+        let note_len   = self.get_note_len();
+        let time_pos   = self.get_time_pos();
+        let time_start = self.get_time_start();
+        let time_zoom  = self.get_time_zoom();
+        let style      = Some(Style::default().fg(self.color.lightest.rgb));
+        ThunkRender::new(move|to: &mut TuiOut|{
+            let [x0, y0, w, _] = to.area().xywh();
+            for (_area_y, screen_y, note) in note_y_iter(note_lo, note_hi, y0) {
+                if note == note_pos {
+                    for x in 0..w {
+                        let screen_x = x0 + x;
+                        let time_1 = time_start + x as usize * time_zoom;
+                        let time_2 = time_1 + time_zoom;
+                        if time_1 <= time_pos && time_pos < time_2 {
+                            to.blit(&"█", screen_x, screen_y, style);
+                            let tail = note_len as u16 / time_zoom as u16;
+                            for x_tail in (screen_x + 1)..(screen_x + tail) {
+                                to.blit(&"▂", x_tail, screen_y, style);
+                            }
+                            break
+                        }
+                    }
+                    break
+                }
+            }
+        })
+    }
+    fn keys (&self) -> impl Content<TuiOut> {
+        let state      = self;
+        let color      = state.color;
+        let note_lo    = state.get_note_lo();
+        let note_hi    = state.get_note_hi();
+        let note_pos   = state.get_note_pos();
+        let key_style  = Some(Style::default().fg(Rgb(192, 192, 192)).bg(Rgb(0, 0, 0)));
+        let off_style  = Some(Style::default().fg(Tui::g(255)));
+        let on_style   = Some(Style::default().fg(Rgb(255,0,0)).bg(color.base.rgb).bold());
+        Fill::y(Fixed::x(self.keys_width, ThunkRender::new(move|to: &mut TuiOut|{
+            let [x, y0, _w, _h] = to.area().xywh();
+            for (_area_y, screen_y, note) in note_y_iter(note_lo, note_hi, y0) {
+                to.blit(&to_key(note), x, screen_y, key_style);
+                if note > 127 {
+                    continue
+                }
+                if note == note_pos {
+                    to.blit(&format!("{:<5}", Note::pitch_to_name(note)), x, screen_y, on_style)
+                } else {
+                    to.blit(&Note::pitch_to_name(note), x, screen_y, off_style)
+                };
+            }
+        })))
+    }
+    fn timeline (&self) -> impl Content<TuiOut> + '_ {
+        Fill::x(Fixed::y(1, ThunkRender::new(move|to: &mut TuiOut|{
+            let [x, y, w, _h] = to.area();
+            let style = Some(Style::default().dim());
+            let length = self.clip.as_ref().map(|p|p.read().unwrap().length).unwrap_or(1);
+            for (area_x, screen_x) in (0..w).map(|d|(d, d+x)) {
+                let t = area_x as usize * self.time_zoom().get();
+                if t < length {
+                    to.blit(&"|", screen_x, y, style);
+                }
+            }
+        })))
+    }
+}
+
+has_size!(<TuiOut>|self:PianoHorizontal|&self.size);
+
+impl TimeRange for PianoHorizontal {
+    fn time_len   (&self) -> &AtomicUsize { self.range.time_len()   }
+    fn time_zoom  (&self) -> &AtomicUsize { self.range.time_zoom()  }
+    fn time_lock  (&self) -> &AtomicBool  { self.range.time_lock()  }
+    fn time_start (&self) -> &AtomicUsize { self.range.time_start() }
+    fn time_axis  (&self) -> &AtomicUsize { self.range.time_axis()  }
+}
+
+impl NoteRange for PianoHorizontal {
+    fn note_lo    (&self) -> &AtomicUsize { self.range.note_lo()    }
+    fn note_axis  (&self) -> &AtomicUsize { self.range.note_axis()  }
+}
+
+impl NotePoint for PianoHorizontal {
+    fn note_len (&self) -> &AtomicUsize { self.point.note_len() }
+    fn note_pos (&self) -> &AtomicUsize { self.point.note_pos() }
+}
+
+impl TimePoint for PianoHorizontal {
+    fn time_pos (&self) -> &AtomicUsize { self.point.time_pos() }
+}
+
+impl MidiViewer for PianoHorizontal {
+    fn clip (&self) -> &Option<Arc<RwLock<MidiClip>>> {
+        &self.clip
+    }
+    fn clip_mut (&mut self) -> &mut Option<Arc<RwLock<MidiClip>>> {
+        &mut self.clip
+    }
+    /// Determine the required space to render the clip.
+    fn buffer_size (&self, clip: &MidiClip) -> (usize, usize) {
+        (clip.length / self.range.time_zoom().get(), 128)
+    }
+    fn redraw (&self) {
+        *self.buffer.write().unwrap() = if let Some(clip) = self.clip.as_ref() {
+            let clip       = clip.read().unwrap();
+            let buf_size   = self.buffer_size(&clip);
+            let mut buffer = BigBuffer::from(buf_size);
+            let note_len   = self.get_note_len();
+            let time_zoom  = self.get_time_zoom();
+            self.time_len().set(clip.length);
+            PianoHorizontal::draw_bg(&mut buffer, &clip, time_zoom, note_len);
+            PianoHorizontal::draw_fg(&mut buffer, &clip, time_zoom);
+            buffer
+        } else {
+            Default::default()
+        }
+    }
+    fn set_clip (&mut self, clip: Option<&Arc<RwLock<MidiClip>>>) {
+        *self.clip_mut() = clip.cloned();
+        self.color = clip.map(|p|p.read().unwrap().color)
+            .unwrap_or(ItemTheme::G[64]);
+        self.redraw();
+    }
+}
+
+impl std::fmt::Debug for PianoHorizontal {
+    fn fmt (&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+        let buffer = self.buffer.read().unwrap();
+        f.debug_struct("PianoHorizontal")
+            .field("time_zoom", &self.range.time_zoom)
+            .field("buffer", &format!("{}x{}", buffer.width, buffer.height))
+            .finish()
+    }
+}
+        // Update sequencer playhead indicator
+        //self.now().set(0.);
+        //if let Some((ref started_at, Some(ref playing))) = self.sequencer.play_clip {
+            //let clip = clip.read().unwrap();
+            //if *playing.read().unwrap() == *clip {
+                //let pulse = self.current().pulse.get();
+                //let start = started_at.pulse.get();
+                //let now   = (pulse - start) % clip.length as f64;
+                //self.now().set(now);
+            //}
+        //}
+
+fn to_key (note: usize) -> &'static str {
+    match note % 12 {
+        11 | 9 | 7 | 5 | 4 | 2 | 0 => "████▌",
+        10 | 8 | 6 | 3 | 1         => "     ",
+        _  => unreachable!(),
+    }
+}

crates/device/src/editor/editor_view_v.rs

@@ -0,0 +1,37 @@
+use crate::*;
+
+pub struct OctaveVertical {
+    on:     [bool; 12],
+    colors: [Color; 3]
+}
+
+impl Default for OctaveVertical {
+    fn default () -> Self {
+        Self {
+            on:     [false; 12],
+            colors: [Rgb(255,255,255), Rgb(0,0,0), Rgb(255,0,0)]
+        }
+    }
+}
+
+impl OctaveVertical {
+    fn color (&self, pitch: usize) -> Color {
+        let pitch = pitch % 12;
+        self.colors[if self.on[pitch] { 2 } else {
+            match pitch { 0 | 2 | 4 | 5 | 6 | 8 | 10 => 0, _ => 1 }
+        }]
+    }
+}
+
+impl Content<TuiOut> for OctaveVertical {
+    fn content (&self) -> impl Render<TuiOut> {
+        row!(
+            Tui::fg_bg(self.color(0),  self.color(1),  "▙"),
+            Tui::fg_bg(self.color(2),  self.color(3),  "▙"),
+            Tui::fg_bg(self.color(4),  self.color(5),  "▌"),
+            Tui::fg_bg(self.color(6),  self.color(7),  "▟"),
+            Tui::fg_bg(self.color(8),  self.color(9),  "▟"),
+            Tui::fg_bg(self.color(10), self.color(11), "▟"),
+        )
+    }
+}

crates/device/src/lib.rs

@@ -3,7 +3,8 @@
 pub(crate) use std::cmp::Ord;
 pub(crate) use std::fmt::{Debug, Formatter};
 pub(crate) use std::thread::JoinHandle;
-pub(crate) use std::sync::{Arc, RwLock, atomic::{AtomicUsize, Ordering::Relaxed}};
+pub(crate) use std::sync::{Arc, RwLock};
+pub(crate) use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::Relaxed};
 pub(crate) use std::fs::File;
 pub(crate) use std::path::PathBuf;
 pub(crate) use std::error::Error;
@@ -14,6 +15,7 @@ pub(crate) use ::tek_engine::*;
 pub(crate) use ::tek_engine::midi::{u7, LiveEvent, MidiMessage};
 pub(crate) use ::tek_engine::jack::{Control, ProcessScope, MidiWriter, RawMidi};
 pub(crate) use ratatui::{prelude::Rect, widgets::{Widget, canvas::{Canvas, Line}}};
+pub(crate) use Color::*;
 
 mod device;
 pub use self::device::*;
@@ -21,6 +23,9 @@ pub use self::device::*;
 #[cfg(feature = "clock")] mod clock;
 #[cfg(feature = "clock")] pub use self::clock::*;
 
+#[cfg(feature = "editor")] mod editor;
+#[cfg(feature = "editor")] pub use self::editor::*;
+
 #[cfg(feature = "sequencer")] mod sequencer;
 #[cfg(feature = "sequencer")] pub use self::sequencer::*;