refactor: reuse horizontal::draw

src/core/time.rs

@@ -27,7 +27,7 @@ impl Timebase {
         self.bpm.load(Ordering::Relaxed)
     }
     #[inline] fn beat_usec (&self) -> f64 {
-        60_000_000_000_000f64 / self.bpm() as f64
+        60_000_000f64 / self.bpm() as f64
     }
 
     #[inline] pub fn ppq (&self) -> f64 {
@@ -36,7 +36,7 @@ impl Timebase {
     #[inline] fn pulse_usec (&self) -> f64 {
         self.beat_usec() / self.ppq() as f64
     }
-    #[inline] fn pulse_frame (&self) -> f64 {
+    #[inline] pub fn pulse_frame (&self) -> f64 {
         self.pulse_usec() / self.frame_usec() as f64
     }
     #[inline] pub fn pulses_frames (&self, pulses: f64) -> f64 {
@@ -130,3 +130,33 @@ impl Timebase {
     }
 }
 
+#[cfg(test)] mod test {
+    use super::*;
+
+    #[test]
+    fn test_timebase () -> Usually<()> {
+        let timebase = Timebase::new(48000.0, 240.0, 24.0);
+        println!("F/S = {:.03}", s.rate());
+        println!("B/S = {:.03}", s.beats_per_secon());
+        println!("F/B = {:.03}", s.frames_per_beat());
+        println!("T/B = {:.03}", s.ticks_per_beat());
+        println!("F/T = {:.03}", s.frames_per_tick());
+        println!("F/L = {:.03}", s.frames_per_loop());
+        println!("T/L = {:.03}", s.ticks_per_loop());
+        let fpt = s.fpt();
+        let frames_per_chunk = 240;
+        let chunk = |chunk: usize| s.frames_to_ticks(
+            chunk * frames_per_chunk,
+            (chunk + 1) * frames_per_chunk
+        );
+        //for i in 0..2000 {
+            //println!("{i} {:?}", chunk(i));
+        //}
+        assert_eq!(chunk(0), vec![(0, 0), (125, 1)]);
+        assert_eq!(chunk(1), vec![(10, 2), (135, 3)]);
+        assert_eq!(chunk(12), vec![(120, 24)]);
+        assert_eq!(chunk(412), vec![(120, 24)]);
+        assert_eq!(chunk(413), vec![(5, 25), (130, 26)]);
+        Ok(())
+    }
+}

src/device/launcher/mod.rs

@@ -221,26 +221,24 @@ fn draw_section_sequencer (state: &Launcher, buf: &mut Buffer, area: Rect) -> Us
     }
     let track = track.unwrap().1;
     let sequencer = track.sequencer.state();
-    {
+    crate::device::sequencer::horizontal::draw(
-        use crate::device::sequencer::horizontal::*;
+        buf,
-        timer(buf, x+5, y, sequencer.time_start, sequencer.time_start + area.width as usize, 0);
+        area,
-        keys(buf, Rect { x, y: y + 1, width, height }, sequencer.note_start)?;
+        match state.phrase_id().map(|id|sequencer.phrases.get(id)) {
-        if let Some(Some(phrase)) = state.phrase_id().map(|id|sequencer.phrases.get(id)) {
+            Some(Some(phrase)) => Some(phrase),
-            let ppq  = sequencer.timebase.ppq() as usize;
+            _ => None
-            let zoom = sequencer.time_zoom;
+        },
-            let t0   = sequencer.time_start;
+        state.timebase.ppq() as usize,
-            let t1   = t0 + area.width as usize;
+        sequencer.time_cursor,
-            let n0   = sequencer.note_start;
+        sequencer.time_start,
-            let n1   = n0 + area.height as usize;
+        sequencer.time_zoom,
-            lanes(buf, x, y + 1, &phrase, ppq, zoom, t0, t1, n0, n1);
+        sequencer.note_cursor,
-        }
+        sequencer.note_start,
-        let cursor_style = match view {
+        Some(match view {
             LauncherView::Sequencer => Style::default().green().not_dim(),
             _ => Style::default().green().dim(),
-        };
+        })
-        cursor(buf, x, y + 1, cursor_style, sequencer.time_cursor, sequencer.note_cursor);
+    )
-    }
-    Ok(area)
 }
 fn draw_section_chains (state: &Launcher, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
     let style = Some(Style::default().green().dim());

src/device/sequencer/horizontal.rs

@@ -2,47 +2,39 @@ use crate::core::*;
 use super::*;
 
 pub fn draw (
-    s: &Sequencer,
     buf:      &mut Buffer,
-    mut area: Rect,
+    area:     Rect,
+    phrase:   Option<&Phrase>,
+    ppq:      usize,
+    time:     usize,
+    time0:    usize,
+    timeZ:    usize,
+    note:     usize,
+    note0:    usize,
+    style:    Option<Style>,
 ) -> Usually<Rect> {
-    area.x = area.x + 13;
+    let now   = 0;
-    let Rect { x, y, width, height } = area;
+    let notes = &[];
-    keys(buf, area, s.note_start)?;
+    keys(buf, area, note0, notes)?;
-    timer(buf, x+6, y-1, s.time_start, s.time_start + area.width as usize, 0);
+    timer(buf, area, time0, now);
-    if let Some(phrase) = s.phrase() {
+    if let Some(phrase) = phrase {
-        lanes(buf, x, y,
+        lanes(buf, area, phrase, ppq, timeZ, time0, note0);
-            phrase,
-            s.timebase.ppq() as usize,
-            s.time_zoom,
-            s.time_start,
-            s.time_start + area.width as usize,
-            s.note_start,
-            s.note_start + area.height as usize,
-        );
     }
-    cursor(
+    let style = style.unwrap_or_else(||{Style::default().green().not_dim()});
-        buf,
+    cursor(buf, area, style, time, note);
-        x,
+    //footer(buf, area, note0, note, time0, time, timeZ);
-        y,
+    Ok(area)
-        Style::default().green().not_dim(),
-        s.time_cursor,
-        s.note_cursor
-    );
-    footer(s, buf, x, y, width, height);
-    Ok(Rect { x: x - 13, y, width, height })
 }
 
 pub fn timer (
     buf:   &mut Buffer,
-    x:     u16,
+    area:  Rect,
-    y:     u16,
     time0: usize,
-    time1: usize,
     now:   usize
 ) {
-    for step in time0..time1 {
+    let x = area.x + 5;
-        buf.set_string(x + step as u16, y, &"-", if step == now {
+    for step in time0..(time0+area.width as usize).saturating_sub(5) {
+        buf.set_string(x + step as u16, area.y, &"-", if step == now {
             Style::default().yellow().bold().not_dim()
         } else {
             Style::default()
@@ -51,20 +43,23 @@ pub fn timer (
 }
 
 pub fn keys (
-    buf: &mut Buffer, area: Rect, note_start: usize
+    buf:   &mut Buffer,
+    area:  Rect,
+    note0: usize,
+    notes: &[bool],
 ) -> Usually<Rect> {
     let bw = Style::default().dim();
     let Rect { x, y, width, height } = area;
     let h = height.saturating_sub(2);
     for i in 0..h {
-        let y = y + i;
+        let y = y + i + 1;
         let key = KEYS_VERTICAL[(i % 6) as usize];
         key.blit(buf, x + 1, y, Some(bw));
         "█".blit(buf, x + 2, y, Some(bw));
-        "·".repeat(width.saturating_sub(6) as usize).blit(buf, x + 5, y, Some(bw.black()));
+        "|---".repeat(width.saturating_sub(6) as usize).blit(buf, x + 5, y, Some(bw.black()));
         //buf.set_string(x + 3, y, &format!("{i}"), Style::default());
         if i % 6 == 0 {
-            let octave = format!("C{}", ((note_start - i as usize) / 6) as i8 - 4);
+            let octave = format!("C{}", ((note0 - i as usize) / 6) as i8 - 4);
             buf.set_string(x + 3, y, &octave, Style::default());
         }
     }
@@ -73,27 +68,27 @@ pub fn keys (
 
 pub fn lanes (
     buf:       &mut Buffer,
-    x:         u16,
+    area:      Rect,
-    y:         u16,
     phrase:    &Phrase,
     ppq:       usize,
     time_zoom: usize,
     time0:     usize,
-    time1:     usize,
     note0:     usize,
-    note1:     usize,
 ) {
+    let Rect { x, y, width, height } = area;
+    let time1    = time0 + width  as usize;
+    let note1    = note0 + height as usize;
     let bg       = Style::default();
     let (bw, wh) = (bg.dim(), bg.white());
     for step in time0..time1 {
         let x = x as usize + 5 + step;
         let (a, b) = ((step + 0) * ppq / time_zoom, (step + 1) * ppq / time_zoom,);
         if step % 4 == 0 {
-            "|".blit(buf, x as u16, y - 1, Some(Style::default().dim()));
+            "|".blit(buf, x as u16, y, Some(Style::default().dim()));
         }
         if step % (time_zoom * 4) == 0 {
             format!("{}", step / time_zoom / 4 + 1)
-                .blit(buf, x as u16, y - 1, Some(Style::default().bold().not_dim()));
+                .blit(buf, x as u16, y, Some(Style::default().bold().not_dim()));
         }
         let h = ((note1-note0)/2).saturating_sub(y as usize);
         for k in 0..h {
@@ -112,14 +107,29 @@ pub fn lanes (
     }
 }
 
-pub fn cursor (buf: &mut Buffer, x: u16, y: u16, style: Style, time: usize, note: usize) {
+pub fn cursor (
-    let x = x + 5 + time as u16;
+    buf:   &mut Buffer,
-    let y = y + note as u16 / 2;
+    area:  Rect,
+    style: Style,
+    time:  usize,
+    note:  usize
+) {
+    let x = area.x + 5 + time as u16;
+    let y = area.y + 1 + note as u16 / 2;
     let c = if note % 2 == 0 { "▀" } else { "▄" };
     c.blit(buf, x, y, Some(style));
 }
 
-pub fn footer (s: &Sequencer, buf: &mut Buffer, mut x: u16, y: u16, width: u16, height: u16) {
+pub fn footer (
+    buf:   &mut Buffer,
+    area:  Rect,
+    note0: usize,
+    note:  usize,
+    time0: usize,
+    time:  usize,
+    timeZ: usize,
+) {
+    let Rect { mut x, y, width, height } = area;
     buf.set_string(x, y + height, format!("├{}┤", "-".repeat((width - 2).into())),
         Style::default().dim());
     buf.set_string(x, y + height + 2, format!("├{}┤", "-".repeat((width - 2).into())),
@@ -128,15 +138,9 @@ pub fn footer (s: &Sequencer, buf: &mut Buffer, mut x: u16, y: u16, width: u16,
     {
         for (_, [letter, title, value]) in [
             ["S", &format!("ync"),  &format!("<4/4>")],
-            ["Q", &format!("uant"), &format!("<1/{}>", 4 * s.time_zoom)],
+            ["Q", &format!("uant"), &format!("<1/{}>", 4 * timeZ)],
-            ["N", &format!("ote"),  &format!("{} ({}-{})",
+            ["N", &format!("ote"),  &format!("{} ({}-{})", note0 + note, note0, "X")],
-                s.note_start + s.note_cursor,
+            ["T", &format!("ime"),  &format!("{} ({}-{})", time0 + time, time0 + 1, "X")],
-                s.note_start,
-                "X")],
-            ["T", &format!("ime"),  &format!("{} ({}-{})",
-                s.time_start + s.time_cursor + 1,
-                s.time_start + 1,
-                "X")],
         ].iter().enumerate() {
             buf.set_string(x, y + height + 1, letter, Style::default().bold().yellow().dim());
             x = x + 1;

src/device/sequencer/mod.rs

@@ -102,9 +102,18 @@ fn render (s: &Sequencer, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
         SequencerView::Vertical => self::vertical::draw(s, buf, Rect {
             x, y: y + header.height, width, height,
         })?,
-        SequencerView::Horizontal => self::horizontal::draw(s, buf, Rect {
+        SequencerView::Horizontal => self::horizontal::draw(
-            x, y: y + header.height, width, height,
+            buf,
-        })?,
+            Rect { x, y: y + header.height, width, height, },
+            s.phrase(),
+            s.timebase.ppq() as usize,
+            s.time_cursor,
+            s.time_start,
+            s.time_zoom,
+            s.note_cursor,
+            s.note_start,
+            None
+        )?,
     };
     Ok(draw_box(buf, Rect {
         x, y,
@@ -159,37 +168,3 @@ pub fn contains_note_on (sequence: &Phrase, k: u7, start: usize, end: usize) ->
     }
     return false
 }
-
-#[cfg(test)] mod test {
-    use super::*;
-
-    #[test]
-    fn test_sequencer_output () -> Usually<()> {
-        let sequencer = Sequencer::new("test")?;
-        let mut s = sequencer.state.lock().unwrap();
-        s.rate  = Hz(48000);
-        s.tempo = Tempo(240_000);
-        println!("F/S = {:.03}", s.rate());
-        println!("B/S = {:.03}", s.beats_per_secon());
-        println!("F/B = {:.03}", s.frames_per_beat());
-        println!("T/B = {:.03}", s.ticks_per_beat());
-        println!("F/T = {:.03}", s.frames_per_tick());
-        println!("F/L = {:.03}", s.frames_per_loop());
-        println!("T/L = {:.03}", s.ticks_per_loop());
-        let fpt = s.fpt();
-        let frames_per_chunk = 240;
-        let chunk = |chunk: usize| s.frames_to_ticks(
-            chunk * frames_per_chunk,
-            (chunk + 1) * frames_per_chunk
-        );
-        //for i in 0..2000 {
-            //println!("{i} {:?}", chunk(i));
-        //}
-        assert_eq!(chunk(0), vec![(0, 0), (125, 1)]);
-        assert_eq!(chunk(1), vec![(10, 2), (135, 3)]);
-        assert_eq!(chunk(12), vec![(120, 24)]);
-        assert_eq!(chunk(412), vec![(120, 24)]);
-        assert_eq!(chunk(413), vec![(5, 25), (130, 26)]);
-        Ok(())
-    }
-}

src/device/transport.rs

@@ -3,13 +3,19 @@ use crate::layout::*;
 
 pub fn draw_timer (buf: &mut Buffer, x: u16, y: u16, timebase: &Arc<Timebase>, frame: usize) {
     let ppq = timebase.ppq() as usize;
+
     let pulse = timebase.frames_pulses(frame as f64) as usize;
     let (beats, pulses) = (pulse / ppq, pulse % ppq);
     let (bars, beats)   = (beats / 4, beats % 4);
+
     let usecs = timebase.frames_usecs(frame as f64) as usize;
     let (seconds, msecs)   = (usecs / 1000000, usecs / 1000 % 1000);
     let (minutes, seconds) = (seconds / 60, seconds % 60);
-    let timer = format!("{minutes}:{seconds:02}:{msecs:03}  {}.{}.{pulses:02}", bars as usize + 1, beats as usize + 1);
+
+    let timer = format!("{minutes}:{seconds:02}:{msecs:03}  {}.{}.{pulses:02}",
+        bars as usize + 1,
+        beats as usize + 1
+    );
     timer.blit(buf, x - timer.len() as u16, y, Some(Style::default().not_dim()));
 }
 pub fn draw_play_stop (buf: &mut Buffer, x: u16, y: u16, state: &TransportState) {

src/main.rs

@@ -43,7 +43,7 @@ fn main () -> Result<(), Box<dyn Error>> {
     let input  = ".*nanoKEY.*";
     let output = ["Komplete.*:playback_FL", "Komplete.*:playback_FR"];
     let (client, _) = Client::new("init", ClientOptions::NO_START_SERVER)?;
-    let timebase = Arc::new(Timebase::new(client.sample_rate() as f64, 125000.0, 96.0));
+    let timebase = Arc::new(Timebase::new(client.sample_rate() as f64, 60.0, 96.0));
     let ppq = timebase.ppq() as usize;
     macro_rules! play {
         ($t1:expr => [ $($msg:expr),* $(,)? ]) => {