restruct: 30e

src/device/editor/piano.rs

@@ -0,0 +1,302 @@
+use crate::*;
+
+/// A clip, rendered as a horizontal piano roll.
+///
+/// ```
+/// let piano = tek::PianoHorizontal::default();
+/// ```
+#[derive(Clone, Default)]
+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: Size,
+    /// The display window
+    pub range: MidiSelection,
+    /// The note cursor
+    pub point: MidiCursor,
+    /// The highlight color palette
+    pub color: ItemTheme,
+    /// Width of the keyboard
+    pub keys_width: u16,
+}
+
+impl_has!(Size: |self: PianoHorizontal| self.size);
+impl Draw<Tui> for PianoHorizontal {
+    fn draw (self, to: &mut Tui) -> Usually<XYWH<u16>> {
+        self.tui().draw(to)
+    }
+}
+
+impl PianoHorizontal {
+
+    pub fn new (clip: Option<&Arc<RwLock<MidiClip>>>) -> Self {
+        let size: Size = [0, 0].into();
+        let mut range = MidiSelection::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:  MidiCursor::default(),
+            clip: clip.cloned(),
+            color: clip.as_ref().map(|p|p.read().unwrap().color).unwrap_or(ItemTheme::G[64]),
+        };
+        piano.redraw();
+        piano
+    }
+
+    pub fn tui (&self) -> impl Draw<Tui> {
+        south(
+            east(w_exact(5, format!("{}x{}", self.size.w(), self.size.h())), self.timeline()),
+            east(self.keys(), self.size.of(below(wh_full(self.notes()), wh_full(self.cursor())))),
+        )
+    }
+
+    /// 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, note_point: usize, time_point: 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();
+                if note == (127-note_point) || time == time_point {
+                    cell.set_bg(Rgb(0,0,0));
+                } else {
+                    cell.set_bg(clip.color.darkest.term);
+                }
+                if time % 384 == 0 {
+                    cell.set_fg(clip.color.darker.term);
+                    cell.set_char('│');
+                } else if time % 96 == 0 {
+                    cell.set_fg(clip.color.dark.term);
+                    cell.set_char('╎');
+                } else if time % note_len == 0 {
+                    cell.set_fg(clip.color.darker.term);
+                    cell.set_char('┊');
+                } else if (127 - note) % 12 == 0 {
+                    cell.set_fg(clip.color.darker.term);
+                    cell.set_char('=');
+                } else if (127 - note) % 6 == 0 {
+                    cell.set_fg(clip.color.darker.term);
+                    cell.set_char('—');
+                } else {
+                    cell.set_fg(clip.color.darker.term);
+                    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.term);//.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 Draw<Tui> {
+        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();
+        thunk(move|to: &mut Tui|{
+            let xywh = to.area().into();
+            let XYWH(x0, y0, w, _h) = xywh;
+            let source = buffer.read().unwrap();
+            //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.0.cell_mut(ratatui::prelude::Position::from((screen_x, screen_y))) {
+                                *cell = source_cell.clone();
+                            }
+                        }
+                    }
+                }
+            }
+            Ok(xywh)
+        })
+    }
+
+    fn cursor (&self) -> impl Draw<Tui> {
+        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.term));
+        thunk(move|to: &mut Tui|{
+            let xywh = to.area().into();
+            let XYWH(x0, y0, w, _h) = 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
+                }
+            }
+            Ok(xywh)
+        })
+    }
+
+    fn keys (&self) -> impl Draw<Tui> {
+        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(g(255)));
+        let on_style   = Some(Style::default().fg(Rgb(255,0,0)).bg(color.base.term).bold());
+        h_full(w_exact(self.keys_width, thunk(move|to: &mut Tui|{
+            let xywh = to.area().into();
+            let XYWH(x, y0, _w, _h) = 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)
+                };
+            }
+            Ok(xywh)
+        })))
+    }
+
+    fn timeline (&self) -> impl Draw<Tui> + '_ {
+        w_full(h_exact(1, thunk(move|to: &mut Tui|{
+            let xywh = to.area().into();
+            let XYWH(x, y, w, _h) = xywh;
+            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().load(Relaxed);
+                if t < length {
+                    to.blit(&"|", screen_x, y, style);
+                }
+            }
+            Ok(xywh)
+        })))
+    }
+}
+
+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().load(Relaxed), 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 time_zoom  = self.get_time_zoom();
+            self.time_len().store(clip.length, Relaxed);
+            PianoHorizontal::draw_bg(&mut buffer, &clip, time_zoom,self.get_note_len(), self.get_note_pos(), self.get_time_pos());
+            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 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()
+    }
+}