wip: refactor into crates

crates/tek_timer/src/transport.rs

@@ -0,0 +1,234 @@
+use crate::*;
+
+/// Stores and displays time-related state.
+pub struct TransportToolbar {
+    /// Enable metronome?
+    pub metronome: bool,
+    pub focused:   bool,
+    pub entered:   bool,
+    pub selected:  TransportFocus,
+    /// Current sample rate, tempo, and PPQ.
+    pub timebase:  Arc<Timebase>,
+    /// JACK transport handle.
+    transport:     Option<Transport>,
+    /// Quantization factor
+    pub quant:     usize,
+    /// Global sync quant
+    pub sync:      usize,
+    /// Current transport state
+    pub playing:   Option<TransportState>,
+    /// Current position according to transport
+    playhead:      usize,
+    /// Global frame and usec at which playback started
+    pub started:   Option<(usize, usize)>,
+}
+
+impl TransportToolbar {
+    pub fn standalone () -> Self {
+        Self::new(None)
+    }
+    pub fn new (transport: Option<Transport>) -> Self {
+        let timebase = Arc::new(Timebase::default());
+        Self {
+            selected:  TransportFocus::BPM,
+            metronome: false,
+            focused:   false,
+            entered:   false,
+            playhead:  0,
+            playing:   Some(TransportState::Stopped),
+            started:   None,
+            quant:     24,
+            sync:      timebase.ppq() as usize * 4,
+            transport,
+            timebase,
+        }
+    }
+    pub fn toggle_play (&mut self) -> Usually<()> {
+        self.playing = match self.playing.expect("1st frame has not been processed yet") {
+            TransportState::Stopped => {
+                self.transport.as_ref().unwrap().start()?;
+                Some(TransportState::Starting)
+            },
+            _ => {
+                self.transport.as_ref().unwrap().stop()?;
+                self.transport.as_ref().unwrap().locate(0)?;
+                Some(TransportState::Stopped)
+            },
+        };
+        Ok(())
+    }
+    pub fn update (&mut self, scope: &ProcessScope) -> (bool, usize, usize, usize, usize, f64) {
+        let CycleTimes {
+            current_frames,
+            current_usecs,
+            next_usecs,
+            period_usecs
+        } = scope.cycle_times().unwrap();
+        let chunk_size = scope.n_frames() as usize;
+        let transport = self.transport.as_ref().unwrap().query().unwrap();
+        self.playhead = transport.pos.frame() as usize;
+        let mut reset = false;
+        if self.playing != Some(transport.state) {
+            match transport.state {
+                TransportState::Rolling => {
+                    self.started = Some((
+                        current_frames as usize,
+                        current_usecs  as usize,
+                    ));
+                },
+                TransportState::Stopped => {
+                    self.started = None;
+                    reset = true;
+                },
+                _ => {}
+            }
+        }
+        self.playing = Some(transport.state);
+        (
+            reset,
+            current_frames as usize,
+            chunk_size as usize,
+            current_usecs as usize,
+            next_usecs as usize,
+            period_usecs as f64
+        )
+    }
+    pub fn bpm (&self) -> usize {
+        self.timebase.bpm() as usize
+    }
+    pub fn ppq (&self) -> usize {
+        self.timebase.ppq() as usize
+    }
+    pub fn pulse (&self) -> usize {
+        self.timebase.frame_to_pulse(self.playhead as f64) as usize
+    }
+    pub fn usecs (&self) -> usize {
+        self.timebase.frame_to_usec(self.playhead as f64) as usize
+    }
+}
+
+render!(TransportToolbar |self, buf, area| {
+    let mut area     = area;
+    area.height      = 2;
+    let gray         = Style::default().gray();
+    let not_dim      = Style::default().not_dim();
+    let not_dim_bold = not_dim.bold();
+    let corners      = Corners(Style::default().green().not_dim());
+    let ppq          = self.ppq();
+    let bpm          = self.bpm();
+    let pulse        = self.pulse();
+    let usecs        = self.usecs();
+    let Self { quant, sync, focused, entered, .. } = self;
+    fill_bg(buf, area, Nord::bg_lo(*focused, *entered));
+    Split::right([
+
+        // Play/Pause button
+        &|buf: &mut Buffer, Rect { x, y, .. }: Rect|{
+            let style = Some(match self.playing {
+                Some(TransportState::Stopped)  => gray.dim().bold(),
+                Some(TransportState::Starting) => gray.not_dim().bold(),
+                Some(TransportState::Rolling)  => gray.not_dim().white().bold(),
+                _ => unreachable!(),
+            });
+            let label = match self.playing {
+                Some(TransportState::Rolling)  => "▶ PLAYING",
+                Some(TransportState::Starting) => "READY ...",
+                Some(TransportState::Stopped)  => "⏹ STOPPED",
+                _ => unreachable!(),
+            };
+            let mut result = label.blit(buf, x + 1, y, style)?;
+            result.width = result.width + 1;
+            Ok(result)
+        },
+
+        // Beats per minute
+        &|buf: &mut Buffer, Rect { x, y, .. }: Rect|{
+            "BPM".blit(buf, x, y, Some(not_dim))?;
+            let width = format!("{}.{:03}", bpm, bpm % 1).blit(buf, x, y + 1, Some(not_dim_bold))?.width;
+            let area  = Rect { x, y, width: (width + 2).max(10), height: 2 };
+            if self.focused && self.entered && self.selected == TransportFocus::BPM {
+                corners.draw(buf, Rect { x: area.x - 1, ..area })?;
+            }
+            Ok(area)
+        },
+
+        // Quantization
+        &|buf: &mut Buffer, Rect { x, y, .. }: Rect|{
+            "QUANT".blit(buf, x, y, Some(not_dim))?;
+            let width = ppq_to_name(*quant as usize).blit(buf, x, y + 1, Some(not_dim_bold))?.width;
+            let area  = Rect { x, y, width: (width + 2).max(10), height: 2 };
+            if self.focused && self.entered && self.selected == TransportFocus::Quant {
+                corners.draw(buf, Rect { x: area.x - 1, ..area })?;
+            }
+            Ok(area)
+        },
+
+        // Clip launch sync
+        &|buf: &mut Buffer, Rect { x, y, .. }: Rect|{
+            "SYNC".blit(buf, x, y, Some(not_dim))?;
+            let width = ppq_to_name(*sync as usize).blit(buf, x, y + 1, Some(not_dim_bold))?.width;
+            let area  = Rect { x, y, width: (width + 2).max(10), height: 2 };
+            if self.focused && self.entered && self.selected == TransportFocus::Sync {
+                corners.draw(buf, Rect { x: area.x - 1, ..area })?;
+            }
+            Ok(area)
+        },
+
+        // Clock
+        &|buf: &mut Buffer, Rect { x, y, width, .. }: Rect|{
+            let (beats, pulses)    = (pulse / ppq, pulse % ppq);
+            let (bars, beats)      = ((beats / 4) + 1, (beats % 4) + 1);
+            let (seconds, msecs)   = (usecs / 1000000, usecs / 1000 % 1000);
+            let (minutes, seconds) = (seconds / 60, seconds % 60);
+            let timer = format!("{minutes}:{seconds:02}:{msecs:03}  {bars}.{beats}.{pulses:02}");
+            timer.blit(buf, x + width - timer.len() as u16 - 1, y, Some(not_dim))
+        }
+
+    ]).render(buf, area)
+});
+
+/// Key bindings for transport toolbar.
+pub const KEYMAP_TRANSPORT: &'static [KeyBinding<TransportToolbar>] = keymap!(TransportToolbar {
+    [Left,  NONE, "transport_prev", "select previous control",  |transport: &mut TransportToolbar| Ok({
+        transport.selected.prev();
+        true
+    })],
+    [Right, NONE, "transport_next", "select next control",      |transport: &mut TransportToolbar| Ok({
+        transport.selected.next();
+        true
+    })],
+    [Char('.'), NONE, "transport_increment", "increment value at cursor", |transport: &mut TransportToolbar| {
+        match transport.selected {
+            TransportFocus::BPM   => {
+                transport.timebase.bpm.fetch_add(1.0, Ordering::Relaxed);
+            },
+            TransportFocus::Quant => {
+                transport.quant = next_note_length(transport.quant)
+            },
+            TransportFocus::Sync  => {
+                transport.sync = next_note_length(transport.sync)
+            },
+        };
+        Ok(true)
+    }],
+    [Char(','), NONE, "transport_decrement", "decrement value at cursor", |transport: &mut TransportToolbar| {
+        match transport.selected {
+            TransportFocus::BPM   => {
+                transport.timebase.bpm.fetch_sub(1.0, Ordering::Relaxed);
+            },
+            TransportFocus::Quant => {
+                transport.quant = prev_note_length(transport.quant);
+            },
+            TransportFocus::Sync  => {
+                transport.sync = prev_note_length(transport.sync);
+            },
+        };
+        Ok(true)
+    }],
+});
+
+handle!{
+    TransportToolbar |self, e| {
+        handle_keymap(self, e, KEYMAP_TRANSPORT)
+    }
+}