flatten workspace into 1 crate

src/piano_h/piano_h_cursor.rs

@@ -0,0 +1,33 @@
+use crate::*;
+use super::note_y_iter;
+
+pub struct PianoHorizontalCursor<'a>(pub(crate) &'a PianoHorizontal);
+render!(<Tui>|self: PianoHorizontalCursor<'a>|render(|to|Ok({
+    let style = Some(Style::default().fg(self.0.color.lightest.rgb));
+    let note_hi    = self.0.note_hi();
+    let note_len   = self.0.note_len();
+    let note_lo    = self.0.note_lo().get();
+    let note_point = self.0.note_point();
+    let time_point = self.0.time_point();
+    let time_start = self.0.time_start().get();
+    let time_zoom  = self.0.time_zoom().get();
+    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_point {
+            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_point && time_point < 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
+        }
+    }
+})));

src/piano_h/piano_h_keys.rs

@@ -0,0 +1,56 @@
+use crate::*;
+use super::note_y_iter;
+
+pub struct PianoHorizontalKeys<'a>(pub(crate) &'a PianoHorizontal);
+render!(<Tui>|self: PianoHorizontalKeys<'a>|render(|to|Ok(render_keys_v(to, self))));
+has_color!(|self: PianoHorizontalKeys<'a>|self.0.color.base);
+impl<'a> NoteRange for PianoHorizontalKeys<'a> {
+    fn note_lo   (&self) -> &AtomicUsize { &self.0.note_lo()   }
+    fn note_axis (&self) -> &AtomicUsize { &self.0.note_axis() }
+}
+impl<'a> NotePoint for PianoHorizontalKeys<'a> {
+    fn note_len (&self) -> usize { self.0.note_len() }
+    fn set_note_len (&self, x: usize) { self.0.set_note_len(x) }
+    fn note_point (&self) -> usize { self.0.note_point() }
+    fn set_note_point (&self, x: usize) { self.0.set_note_point(x) }
+}
+
+pub fn render_keys_v <T: HasColor + NoteRange + NotePoint> (to: &mut TuiOutput, state: &T) {
+    let color       = state.color();
+    let note_lo     = state.note_lo().get();
+    let note_hi     = state.note_hi();
+    let note_point  = state.note_point();
+    let [x, y0, w, h] = to.area().xywh();
+    let key_style   = Some(Style::default().fg(Color::Rgb(192, 192, 192)).bg(Color::Rgb(0, 0, 0)));
+    let off_style   = Some(Style::default().fg(TuiTheme::g(160)));
+    let on_style    = Some(Style::default().fg(TuiTheme::g(255)).bg(color.rgb).bold());
+    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_point {
+            to.blit(&format!("{:<5}", to_note_name(note)), x, screen_y, on_style)
+        } else {
+            to.blit(&to_note_name(note), x, screen_y, off_style)
+        };
+    }
+}
+
+fn to_key (note: usize) -> &'static str {
+    match note % 12 {
+        11 => "████▌",
+        10 => "     ",
+        9  => "████▌",
+        8  => "     ",
+        7  => "████▌",
+        6  => "     ",
+        5  => "████▌",
+        4  => "████▌",
+        3  => "     ",
+        2  => "████▌",
+        1  => "     ",
+        0  => "████▌",
+        _  => unreachable!(),
+    }
+}

src/piano_h/piano_h_notes.rs

@@ -0,0 +1,46 @@
+use crate::*;
+use super::note_y_iter;
+
+pub struct PianoHorizontalNotes<'a>(pub(crate) &'a PianoHorizontal);
+render!(<Tui>|self: PianoHorizontalNotes<'a>|render(|to|Ok({
+    let time_start = self.0.time_start().get();
+    let note_lo    = self.0.note_lo().get();
+    let note_hi    = self.0.note_hi();
+    let note_point = self.0.note_point();
+    let source     = &self.0.buffer;
+    let [x0, y0, w, h] = to.area().xywh();
+    if h as usize != self.0.note_axis().get() {
+        panic!("area height mismatch");
+    }
+    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) {
+            //if area_x % 10 == 0 {
+                //to.blit(&format!("{area_y} {note}"), screen_x, screen_y, None);
+            //}
+            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) {
+                    *to.buffer.get_mut(screen_x, screen_y) = source_cell.clone();
+                }
+            }
+        }
+    }
+    //let debug = true;
+    //if debug {
+        //let x0=20+x0;
+        //to.blit(&format!("KYP                     "), x0, y0,   None);
+        //to.blit(&format!("x0={x0}                 "), x0, y0+1, None);
+        //to.blit(&format!("y0={y0}                 "), x0, y0+2, None);
+        //to.blit(&format!("note_lo={note_lo}, {}   ", to_note_name(note_lo)), x0, y0+3, None);
+        //to.blit(&format!("note_hi={note_hi}, {}   ", to_note_name(note_hi)), x0, y0+4, None);
+        //to.blit(&format!("note_point={note_point}, {}   ", to_note_name(note_point)), x0, y0+5, None);
+        //to.blit(&format!("time_start={time_start} "), x0, y0+6, None);
+        //return Ok(());
+    //}
+})));

src/piano_h/piano_h_time.rs

@@ -0,0 +1,20 @@
+use crate::*;
+
+pub struct PianoHorizontalTimeline<'a>(pub(crate) &'a PianoHorizontal);
+render!(<Tui>|self: PianoHorizontalTimeline<'a>|render(|to|{
+    let [x, y, w, h] = to.area();
+    let style = Some(Style::default().dim());
+    let length = self.0.phrase.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.0.time_zoom().get();
+        if t < length {
+            to.blit(&"|", screen_x, y, style);
+        }
+    }
+    Ok(())
+}));
+    //Tui::fg_bg(
+    //self.0.color.lightest.rgb,
+    //self.0.color.darkest.rgb,
+    //format!("{}*{}", self.0.time_start(), self.0.time_zoom()).as_str()
+//));