sequencer: despaghettify

crates/tek_sequencer/src/sequencer_view_h.rs

@@ -0,0 +1,161 @@
+use crate::*;
+
+impl Sequencer {
+
+    const H_KEYS_OFFSET: usize = 5;
+
+    pub(crate) fn horizontal_draw (&self, buf: &mut Buffer, mut area: Rect) -> Usually<()> {
+        SequenceStartEnd.render(buf, area)?;
+        SequenceLoop.render(buf, area)?;
+        SequenceRange.render(buf, area)?;
+        area.x = area.x + 15;
+        area.width = area.width.saturating_sub(12);
+        SequenceKeys(&self).render(buf, area)?;
+        if let Some(ref phrase) = self.phrase {
+            SequenceTimer(&self, phrase).render(buf, area)?;
+        }
+        SequenceNotes(&self).render(buf, area)?;
+        SequenceCursor(&self).render(buf, area)?;
+        SequenceZoom(&self).render(buf, area)?;
+        Ok(())
+    }
+
+}
+
+struct SequenceStartEnd;
+
+impl Render for SequenceStartEnd {
+    fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+        let frame = Rect { x: area.x, y: area.y, width: 15, height: 4 };
+        Lozenge(Style::default().fg(Nord::BG2)).draw(buf, frame)?;
+        "Start   1.1.1".blit(buf, area.x + 1, area.y + 1, None)?;
+        "End     2.1.1".blit(buf, area.x + 1, area.y + 2, None)?;
+        Ok(frame)
+    }
+}
+
+struct SequenceLoop;
+
+impl Render for SequenceLoop {
+    fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+        let range = Rect { x: area.x, y: area.y + 4, width: 15, height: 5 };
+        Lozenge(Style::default().fg(Nord::BG2)).draw(buf, range)?;
+        "[ Loop off ] ".blit(buf, area.x + 1, area.y + 5, None)?;
+        "Loop    1.1.1".blit(buf, area.x + 1, area.y + 6, None)?;
+        "Length  1.0.0".blit(buf, area.x + 1, area.y + 7, None)?;
+        Ok(range)
+    }
+}
+
+struct SequenceRange;
+
+impl Render for SequenceRange {
+    fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+        let range = Rect { x: area.x, y: area.y + 9, width: 15, height: 7 };
+        Lozenge(Style::default().fg(Nord::BG2)).draw(buf, range)?;
+        "Notes -------".blit(buf, area.x + 1, area.y + 10, None)?;
+        "[ /2 ] [ x2 ]".blit(buf, area.x + 1, area.y + 11, None)?;
+        "[ Reverse   ]".blit(buf, area.x + 1, area.y + 12, None)?;
+        "[ Invert    ]".blit(buf, area.x + 1, area.y + 13, None)?;
+        "[ Duplicate ]".blit(buf, area.x + 1, area.y + 14, None)?;
+        Ok(area)
+    }
+}
+
+struct SequenceKeys<'a>(&'a Sequencer);
+
+impl<'a> Render for SequenceKeys<'a> {
+    fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+        if area.height < 2 {
+            return Ok(area)
+        }
+        let area = Rect {
+            x: area.x,
+            y: area.y + 1,
+            width: 5,
+            height: area.height - 2
+        };
+        buffer_update(buf, area, &|cell, x, y|{
+            let y = y + self.0.note_axis.start as u16;
+            if x < self.0.keys.area.width && y < self.0.keys.area.height {
+                *cell = self.0.keys.get(x, y).clone()
+            }
+        });
+        Ok(area)
+    }
+}
+
+struct SequenceNotes<'a>(&'a Sequencer);
+
+impl<'a> Render for SequenceNotes<'a> {
+    fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+        if area.height < 2 {
+            return Ok(area)
+        }
+        let area = Rect {
+            x:      area.x + Sequencer::H_KEYS_OFFSET as u16,
+            y:      area.y + 1,
+            width:  area.width - Sequencer::H_KEYS_OFFSET as u16,
+            height: area.height - 2
+        };
+        buffer_update(buf, area, &move |cell, x, y|{
+            let src_x = ((x as usize + self.0.time_axis.start) * self.0.time_axis.scale) as usize;
+            let src_y = (y as usize + self.0.note_axis.start) as usize;
+            if src_x < self.0.buffer.width && src_y < self.0.buffer.height - 1 {
+                let src = self.0.buffer.get(src_x, self.0.buffer.height - src_y);
+                src.map(|src|{
+                    cell.set_symbol(src.symbol());
+                    cell.set_fg(src.fg);
+                });
+            }
+        });
+        Ok(area)
+    }
+}
+
+struct SequenceCursor<'a>(&'a Sequencer);
+
+impl<'a> Render for SequenceCursor<'a> {
+    fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+        if let (Some(time), Some(note)) = (self.0.time_axis.point, self.0.note_axis.point) {
+            let x = area.x + Sequencer::H_KEYS_OFFSET as u16 + time as u16;
+            let y = area.y + 1 + note as u16 / 2;
+            let c = if note % 2 == 0 { "▀" } else { "▄" };
+            c.blit(buf, x, y, self.0.style_focus())
+        } else {
+            Ok(Rect::default())
+        }
+    }
+}
+
+struct SequenceZoom<'a>(&'a Sequencer);
+
+impl<'a> Render for SequenceZoom<'a> {
+    fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+        let quant = ppq_to_name(self.0.time_axis.scale);
+        let quant_x = area.x + area.width - 1 - quant.len() as u16;
+        let quant_y = area.y + area.height - 2;
+        quant.blit(buf, quant_x, quant_y, self.0.style_focus())
+    }
+}
+
+struct SequenceTimer<'a>(&'a Sequencer, &'a Arc<RwLock<Phrase>>);
+
+impl<'a> Render for SequenceTimer<'a> {
+    fn render (&self, buf: &mut Buffer, area: Rect) -> Usually<Rect> {
+        let phrase = self.1.read().unwrap();
+        let (time0, time_z, now) = (
+            self.0.time_axis.start, self.0.time_axis.scale, self.0.now % phrase.length
+        );
+        let Rect { x, width, .. } = area;
+        let x2 = x as usize + Sequencer::H_KEYS_OFFSET;
+        let x3 = x as usize + width as usize;
+        for x in x2..x3 {
+            let step = (time0 + x2) * time_z;
+            let next_step = (time0 + x2 + 1) * time_z;
+            let style = Sequencer::style_timer_step(now, step as usize, next_step as usize);
+            "-".blit(buf, x as u16, area.y, Some(style))?;
+        }
+        return Ok(Rect { x: area.x, y: area.y, width: area.width, height: 1 })
+    }
+}