Feat: lots of things, preparing for live gig

src/views/keybindings.rs

@@ -36,6 +36,7 @@ pub fn bindings_for(page: Page) -> Vec<(&'static str, &'static str, &'static str
             bindings.push(("f", "Fill", "Toggle fill mode (hold)"));
             bindings.push(("r", "Rename", "Rename current step"));
             bindings.push(("Ctrl+R", "Run", "Run step script immediately"));
+            bindings.push((":", "Jump", "Jump to step number"));
             bindings.push(("e", "Euclidean", "Distribute linked steps using Euclidean rhythm"));
             bindings.push(("m", "Mute", "Stage mute for current pattern"));
             bindings.push(("x", "Solo", "Stage solo for current pattern"));

src/views/main_view.rs

@@ -1,12 +1,18 @@
+use std::collections::HashSet;
+
 use ratatui::layout::{Alignment, Constraint, Layout, Rect};
 use ratatui::style::{Color, Modifier, Style};
+use ratatui::text::{Line, Span};
 use ratatui::widgets::{Block, Borders, Paragraph};
 use ratatui::Frame;
 
 use crate::app::App;
 use crate::engine::SequencerSnapshot;
+use crate::model::SourceSpan;
 use crate::state::MainLayout;
 use crate::theme;
+use crate::views::highlight::highlight_line_with_runtime;
+use crate::views::render::{adjust_resolved_for_line, adjust_spans_for_line};
 use crate::widgets::{ActivePatterns, Orientation, Scope, Spectrum, VuMeter};
 
 pub fn layout(area: Rect) -> [Rect; 5] {
@@ -25,7 +31,8 @@ pub fn render(frame: &mut Frame, app: &App, snapshot: &SequencerSnapshot, area:
 
     let show_scope = app.audio.config.show_scope;
     let show_spectrum = app.audio.config.show_spectrum;
-    let has_viz = show_scope || show_spectrum;
+    let show_preview = app.audio.config.show_preview;
+    let has_viz = show_scope || show_spectrum || show_preview;
     let layout = app.audio.config.layout;
 
     let (viz_area, sequencer_area) = match layout {
@@ -70,7 +77,7 @@ pub fn render(frame: &mut Frame, app: &App, snapshot: &SequencerSnapshot, area:
     };
 
     if has_viz {
-        render_viz_area(frame, app, viz_area, layout, show_scope, show_spectrum);
+        render_viz_area(frame, app, snapshot, viz_area);
     }
 
     render_sequencer(frame, app, snapshot, sequencer_area);
@@ -78,43 +85,48 @@ pub fn render(frame: &mut Frame, app: &App, snapshot: &SequencerSnapshot, area:
     render_active_patterns(frame, app, snapshot, patterns_area);
 }
 
+enum VizPanel {
+    Scope,
+    Spectrum,
+    Preview,
+}
+
 fn render_viz_area(
     frame: &mut Frame,
     app: &App,
+    snapshot: &SequencerSnapshot,
     area: Rect,
-    layout: MainLayout,
-    show_scope: bool,
-    show_spectrum: bool,
 ) {
-    let is_vertical_layout = matches!(layout, MainLayout::Left | MainLayout::Right);
+    let is_vertical_layout = matches!(app.audio.config.layout, MainLayout::Left | MainLayout::Right);
+    let show_scope = app.audio.config.show_scope;
+    let show_spectrum = app.audio.config.show_spectrum;
+    let show_preview = app.audio.config.show_preview;
 
-    if show_scope && show_spectrum {
-        if is_vertical_layout {
-            let [scope_area, spectrum_area] = Layout::vertical([
-                Constraint::Fill(1),
-                Constraint::Fill(1),
-            ])
-            .areas(area);
-            render_scope(frame, app, scope_area, Orientation::Vertical);
-            render_spectrum(frame, app, spectrum_area);
-        } else {
-            let [scope_area, spectrum_area] = Layout::horizontal([
-                Constraint::Fill(1),
-                Constraint::Fill(1),
-            ])
-            .areas(area);
-            render_scope(frame, app, scope_area, Orientation::Horizontal);
-            render_spectrum(frame, app, spectrum_area);
+    let mut panels = Vec::new();
+    if show_scope { panels.push(VizPanel::Scope); }
+    if show_spectrum { panels.push(VizPanel::Spectrum); }
+    if show_preview { panels.push(VizPanel::Preview); }
+
+    let constraints: Vec<Constraint> = panels.iter().map(|_| Constraint::Fill(1)).collect();
+
+    let areas: Vec<Rect> = if is_vertical_layout {
+        Layout::vertical(&constraints).split(area).to_vec()
+    } else {
+        Layout::horizontal(&constraints).split(area).to_vec()
+    };
+
+    let orientation = if is_vertical_layout {
+        Orientation::Vertical
+    } else {
+        Orientation::Horizontal
+    };
+
+    for (panel, panel_area) in panels.iter().zip(areas.iter()) {
+        match panel {
+            VizPanel::Scope => render_scope(frame, app, *panel_area, orientation),
+            VizPanel::Spectrum => render_spectrum(frame, app, *panel_area),
+            VizPanel::Preview => render_script_preview(frame, app, snapshot, *panel_area),
         }
-    } else if show_scope {
-        let orientation = if is_vertical_layout {
-            Orientation::Vertical
-        } else {
-            Orientation::Horizontal
-        };
-        render_scope(frame, app, area, orientation);
-    } else if show_spectrum {
-        render_spectrum(frame, app, area);
     }
 }
 
@@ -187,6 +199,7 @@ fn render_tile(
     let pattern = app.current_edit_pattern();
     let step = pattern.step(step_idx);
     let is_active = step.map(|s| s.active).unwrap_or(false);
+    let has_content = step.map(|s| s.has_content()).unwrap_or(false);
     let is_linked = step.map(|s| s.source.is_some()).unwrap_or(false);
     let is_selected = step_idx == app.editor_ctx.step;
     let in_selection = app.editor_ctx.selection_range()
@@ -217,7 +230,10 @@ fn render_tile(
             let (r, g, b) = link_color.unwrap().1;
             (Color::Rgb(r, g, b), theme.tile.active_fg)
         }
-        (false, true, false, false, _) => (theme.tile.active_bg, theme.tile.active_fg),
+        (false, true, false, false, _) => {
+            let bg = if has_content { theme.tile.content_bg } else { theme.tile.active_bg };
+            (bg, theme.tile.active_fg)
+        }
         (false, false, true, _, _) => (theme.selection.selected, theme.selection.cursor_fg),
         (false, false, _, _, true) => (theme.selection.in_range, theme.selection.cursor_fg),
         (false, false, false, _, _) => (theme.tile.inactive_bg, theme.tile.inactive_fg),
@@ -234,6 +250,8 @@ fn render_tile(
         "▶".to_string()
     } else if let Some(source) = source_idx {
         format!("→{:02}", source + 1)
+    } else if has_content {
+        format!("·{:02}·", step_idx + 1)
     } else {
         format!("{:02}", step_idx + 1)
     };
@@ -314,6 +332,90 @@ fn render_spectrum(frame: &mut Frame, app: &App, area: Rect) {
     frame.render_widget(spectrum, inner);
 }
 
+fn render_script_preview(
+    frame: &mut Frame,
+    app: &App,
+    snapshot: &SequencerSnapshot,
+    area: Rect,
+) {
+    let theme = theme::get();
+    let user_words: HashSet<String> = app.dict.lock().keys().cloned().collect();
+
+    let pattern = app.current_edit_pattern();
+    let step_idx = app.editor_ctx.step;
+    let step = pattern.step(step_idx);
+    let source_idx = step.and_then(|s| s.source);
+    let step_name = step.and_then(|s| s.name.as_ref());
+
+    let title = match (source_idx, step_name) {
+        (Some(src), Some(name)) => format!(" {:02}: {} -> {:02} ", step_idx + 1, name, src + 1),
+        (None, Some(name)) => format!(" {:02}: {} ", step_idx + 1, name),
+        (Some(src), None) => format!(" {:02} -> {:02} ", step_idx + 1, src + 1),
+        (None, None) => format!(" Step {:02} ", step_idx + 1),
+    };
+
+    let block = Block::default()
+        .borders(Borders::ALL)
+        .title(title)
+        .border_style(Style::new().fg(theme.ui.border));
+    let inner = block.inner(area);
+    frame.render_widget(block, area);
+
+    let script = pattern.resolve_script(step_idx).unwrap_or("");
+    if script.is_empty() {
+        let empty = Paragraph::new("(empty)")
+            .alignment(Alignment::Center)
+            .style(Style::new().fg(theme.ui.text_dim));
+        let centered = Rect {
+            y: inner.y + inner.height / 2,
+            height: 1,
+            ..inner
+        };
+        frame.render_widget(empty, centered);
+        return;
+    }
+
+    let trace = if app.ui.runtime_highlight && app.playback.playing {
+        let source = pattern.resolve_source(step_idx);
+        snapshot.get_trace(app.editor_ctx.bank, app.editor_ctx.pattern, source)
+    } else {
+        None
+    };
+
+    let resolved_display: Vec<(SourceSpan, String)> = trace
+        .map(|t| {
+            t.resolved
+                .iter()
+                .map(|(s, v)| (*s, v.display()))
+                .collect()
+        })
+        .unwrap_or_default();
+
+    let mut line_start = 0usize;
+    let lines: Vec<Line> = script
+        .lines()
+        .take(inner.height as usize)
+        .map(|line_str| {
+            let tokens = if let Some(t) = trace {
+                let exec = adjust_spans_for_line(&t.executed_spans, line_start, line_str.len());
+                let sel = adjust_spans_for_line(&t.selected_spans, line_start, line_str.len());
+                let res = adjust_resolved_for_line(&resolved_display, line_start, line_str.len());
+                highlight_line_with_runtime(line_str, &exec, &sel, &res, &user_words)
+            } else {
+                highlight_line_with_runtime(line_str, &[], &[], &[], &user_words)
+            };
+            line_start += line_str.len() + 1;
+            let spans: Vec<Span> = tokens
+                .into_iter()
+                .map(|(style, text, _)| Span::styled(text, style))
+                .collect();
+            Line::from(spans)
+        })
+        .collect();
+
+    frame.render_widget(Paragraph::new(lines), inner);
+}
+
 fn render_vu_meter(frame: &mut Frame, app: &App, area: Rect) {
     let theme = theme::get();
     let block = Block::default()

src/views/options_view.rs

@@ -161,6 +161,12 @@ pub fn render(frame: &mut Frame, app: &App, link: &LinkState, area: Rect) {
             focus == OptionsFocus::ShowCompletion,
             &theme,
         ),
+        render_option_line(
+            "Show preview",
+            if app.audio.config.show_preview { "On" } else { "Off" },
+            focus == OptionsFocus::ShowPreview,
+            &theme,
+        ),
         Line::from(""),
         link_header,
         render_divider(content_width, &theme),

src/views/render.rs

@@ -38,7 +38,7 @@ fn clip_span(span: SourceSpan, line_start: usize, line_len: usize) -> Option<Sou
     })
 }
 
-fn adjust_spans_for_line(
+pub fn adjust_spans_for_line(
     spans: &[SourceSpan],
     line_start: usize,
     line_len: usize,
@@ -49,7 +49,7 @@ fn adjust_spans_for_line(
         .collect()
 }
 
-fn adjust_resolved_for_line(
+pub fn adjust_resolved_for_line(
     resolved: &[(SourceSpan, String)],
     line_start: usize,
     line_len: usize,
@@ -518,7 +518,7 @@ fn render_modal(frame: &mut Frame, app: &App, snapshot: &SequencerSnapshot, term
         }
         Modal::SetPattern { field, input } => {
             let (title, hint) = match field {
-                PatternField::Length => ("Set Length (1-128)", "Enter number"),
+                PatternField::Length => ("Set Length (1-1024)", "Enter number"),
                 PatternField::Speed => ("Set Speed", "e.g. 1/3, 2/5, 1x, 2x"),
             };
             TextInputModal::new(title, input)
@@ -527,6 +527,15 @@ fn render_modal(frame: &mut Frame, app: &App, snapshot: &SequencerSnapshot, term
                 .border_color(theme.modal.confirm)
                 .render_centered(frame, term)
         }
+        Modal::JumpToStep(input) => {
+            let pattern_len = app.current_edit_pattern().length;
+            let title = format!("Jump to Step (1-{})", pattern_len);
+            TextInputModal::new(&title, input)
+                .hint("Enter step number")
+                .width(30)
+                .border_color(theme.modal.confirm)
+                .render_centered(frame, term)
+        }
         Modal::SetTempo(input) => TextInputModal::new("Set Tempo (20-300 BPM)", input)
             .hint("Enter BPM")
             .width(30)