264 lines
9.0 KiB
Rust
264 lines
9.0 KiB
Rust
use ratatui::layout::{Alignment, Constraint, Layout, Rect};
|
|
use ratatui::style::{Color, Modifier, Style};
|
|
use ratatui::widgets::Paragraph;
|
|
use ratatui::Frame;
|
|
|
|
use crate::app::App;
|
|
use crate::engine::SequencerSnapshot;
|
|
use crate::widgets::{Orientation, Scope, Spectrum, VuMeter};
|
|
|
|
pub fn render(frame: &mut Frame, app: &App, snapshot: &SequencerSnapshot, area: Rect) {
|
|
let [left_area, _spacer, vu_area] = Layout::horizontal([
|
|
Constraint::Fill(1),
|
|
Constraint::Length(2),
|
|
Constraint::Length(8),
|
|
])
|
|
.areas(area);
|
|
|
|
let show_scope = app.audio.config.show_scope;
|
|
let show_spectrum = app.audio.config.show_spectrum;
|
|
let viz_height = if show_scope || show_spectrum { 14 } else { 0 };
|
|
|
|
let [viz_area, sequencer_area] = Layout::vertical([
|
|
Constraint::Length(viz_height),
|
|
Constraint::Fill(1),
|
|
])
|
|
.areas(left_area);
|
|
|
|
if show_scope && show_spectrum {
|
|
let [scope_area, _, spectrum_area] = Layout::horizontal([
|
|
Constraint::Percentage(50),
|
|
Constraint::Length(2),
|
|
Constraint::Percentage(50),
|
|
])
|
|
.areas(viz_area);
|
|
render_scope(frame, app, scope_area);
|
|
render_spectrum(frame, app, spectrum_area);
|
|
} else if show_scope {
|
|
render_scope(frame, app, viz_area);
|
|
} else if show_spectrum {
|
|
render_spectrum(frame, app, viz_area);
|
|
}
|
|
|
|
render_sequencer(frame, app, snapshot, sequencer_area);
|
|
|
|
// Calculate actual grid height to align VU meter
|
|
let pattern = app.current_edit_pattern();
|
|
let page = app.editor_ctx.step / STEPS_PER_PAGE;
|
|
let page_start = page * STEPS_PER_PAGE;
|
|
let steps_on_page = (page_start + STEPS_PER_PAGE).min(pattern.length) - page_start;
|
|
let num_rows = steps_on_page.div_ceil(8);
|
|
let spacing = num_rows.saturating_sub(1) as u16;
|
|
let row_height = sequencer_area.height.saturating_sub(spacing) / num_rows as u16;
|
|
let actual_grid_height = row_height * num_rows as u16 + spacing;
|
|
|
|
let aligned_vu_area = Rect {
|
|
y: sequencer_area.y,
|
|
height: actual_grid_height,
|
|
..vu_area
|
|
};
|
|
|
|
render_vu_meter(frame, app, aligned_vu_area);
|
|
}
|
|
|
|
const STEPS_PER_PAGE: usize = 32;
|
|
|
|
fn render_sequencer(frame: &mut Frame, app: &App, snapshot: &SequencerSnapshot, area: Rect) {
|
|
if area.width < 50 {
|
|
let msg = Paragraph::new("Terminal too narrow")
|
|
.alignment(Alignment::Center)
|
|
.style(Style::new().fg(Color::Rgb(120, 125, 135)));
|
|
frame.render_widget(msg, area);
|
|
return;
|
|
}
|
|
|
|
let pattern = app.current_edit_pattern();
|
|
let length = pattern.length;
|
|
let page = app.editor_ctx.step / STEPS_PER_PAGE;
|
|
let page_start = page * STEPS_PER_PAGE;
|
|
let steps_on_page = (page_start + STEPS_PER_PAGE).min(length) - page_start;
|
|
|
|
let num_rows = steps_on_page.div_ceil(8);
|
|
let steps_per_row = steps_on_page.div_ceil(num_rows);
|
|
|
|
let spacing = num_rows.saturating_sub(1) as u16;
|
|
let row_height = area.height.saturating_sub(spacing) / num_rows as u16;
|
|
|
|
let row_constraints: Vec<Constraint> = (0..num_rows * 2 - 1)
|
|
.map(|i| {
|
|
if i % 2 == 0 {
|
|
Constraint::Length(row_height)
|
|
} else {
|
|
Constraint::Length(1)
|
|
}
|
|
})
|
|
.collect();
|
|
let rows = Layout::vertical(row_constraints).split(area);
|
|
|
|
for row_idx in 0..num_rows {
|
|
let row_area = rows[row_idx * 2];
|
|
let start_step = row_idx * steps_per_row;
|
|
let end_step = (start_step + steps_per_row).min(steps_on_page);
|
|
let cols_in_row = end_step - start_step;
|
|
|
|
let col_constraints: Vec<Constraint> = (0..cols_in_row * 2 - 1)
|
|
.map(|i| {
|
|
if i % 2 == 0 {
|
|
Constraint::Fill(1)
|
|
} else if i == cols_in_row - 1 {
|
|
Constraint::Length(2)
|
|
} else {
|
|
Constraint::Length(1)
|
|
}
|
|
})
|
|
.collect();
|
|
let cols = Layout::horizontal(col_constraints).split(row_area);
|
|
|
|
for col_idx in 0..cols_in_row {
|
|
let step_idx = page_start + start_step + col_idx;
|
|
if step_idx < length {
|
|
render_tile(frame, cols[col_idx * 2], app, snapshot, step_idx);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
fn render_tile(
|
|
frame: &mut Frame,
|
|
area: Rect,
|
|
app: &App,
|
|
snapshot: &SequencerSnapshot,
|
|
step_idx: usize,
|
|
) {
|
|
let pattern = app.current_edit_pattern();
|
|
let step = pattern.step(step_idx);
|
|
let is_active = step.map(|s| s.active).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()
|
|
.map(|r| r.contains(&step_idx))
|
|
.unwrap_or(false);
|
|
|
|
let is_playing = if app.playback.playing {
|
|
snapshot.get_step(app.editor_ctx.bank, app.editor_ctx.pattern) == Some(step_idx)
|
|
} else {
|
|
false
|
|
};
|
|
|
|
let link_color = step.and_then(|s| s.source).map(|src| {
|
|
const BRIGHT: [(u8, u8, u8); 5] = [
|
|
(180, 140, 220),
|
|
(220, 140, 170),
|
|
(220, 180, 130),
|
|
(130, 180, 220),
|
|
(170, 220, 140),
|
|
];
|
|
const DIM: [(u8, u8, u8); 5] = [
|
|
(90, 70, 120),
|
|
(120, 70, 85),
|
|
(120, 90, 65),
|
|
(65, 90, 120),
|
|
(85, 120, 70),
|
|
];
|
|
let i = src % 5;
|
|
(BRIGHT[i], DIM[i])
|
|
});
|
|
|
|
let (bg, fg) = match (is_playing, is_active, is_selected, is_linked, in_selection) {
|
|
(true, true, _, _, _) => (Color::Rgb(195, 85, 65), Color::White),
|
|
(true, false, _, _, _) => (Color::Rgb(180, 120, 45), Color::Black),
|
|
(false, true, true, true, _) => {
|
|
let (r, g, b) = link_color.unwrap().0;
|
|
(Color::Rgb(r, g, b), Color::Black)
|
|
}
|
|
(false, true, true, false, _) => (Color::Rgb(0, 220, 180), Color::Black),
|
|
(false, true, _, _, true) => (Color::Rgb(0, 170, 140), Color::Black),
|
|
(false, true, false, true, _) => {
|
|
let (r, g, b) = link_color.unwrap().1;
|
|
(Color::Rgb(r, g, b), Color::White)
|
|
}
|
|
(false, true, false, false, _) => (Color::Rgb(45, 106, 95), Color::White),
|
|
(false, false, true, _, _) => (Color::Rgb(80, 180, 255), Color::Black),
|
|
(false, false, _, _, true) => (Color::Rgb(60, 140, 200), Color::Black),
|
|
(false, false, false, _, _) => (Color::Rgb(45, 48, 55), Color::Rgb(120, 125, 135)),
|
|
};
|
|
|
|
let source_idx = step.and_then(|s| s.source);
|
|
let symbol = if is_playing {
|
|
"▶".to_string()
|
|
} else if let Some(source) = source_idx {
|
|
format!("→{:02}", source + 1)
|
|
} else {
|
|
format!("{:02}", step_idx + 1)
|
|
};
|
|
|
|
// For linked steps, get the name from the source step
|
|
let step_name = if let Some(src) = source_idx {
|
|
pattern.step(src).and_then(|s| s.name.as_ref())
|
|
} else {
|
|
step.and_then(|s| s.name.as_ref())
|
|
};
|
|
let num_lines = if step_name.is_some() { 2u16 } else { 1u16 };
|
|
let content_height = num_lines;
|
|
let y_offset = area.height.saturating_sub(content_height) / 2;
|
|
|
|
// Fill background for entire tile
|
|
let bg_fill = Paragraph::new("").style(Style::new().bg(bg));
|
|
frame.render_widget(bg_fill, area);
|
|
|
|
if let Some(name) = step_name {
|
|
let name_area = Rect {
|
|
x: area.x,
|
|
y: area.y + y_offset,
|
|
width: area.width,
|
|
height: 1,
|
|
};
|
|
let name_widget = Paragraph::new(name.as_str())
|
|
.alignment(Alignment::Center)
|
|
.style(Style::new().bg(bg).fg(fg).add_modifier(Modifier::BOLD));
|
|
frame.render_widget(name_widget, name_area);
|
|
|
|
let symbol_area = Rect {
|
|
x: area.x,
|
|
y: area.y + y_offset + 1,
|
|
width: area.width,
|
|
height: 1,
|
|
};
|
|
let symbol_widget = Paragraph::new(symbol)
|
|
.alignment(Alignment::Center)
|
|
.style(Style::new().bg(bg).fg(fg).add_modifier(Modifier::BOLD));
|
|
frame.render_widget(symbol_widget, symbol_area);
|
|
} else {
|
|
let centered_area = Rect {
|
|
x: area.x,
|
|
y: area.y + y_offset,
|
|
width: area.width,
|
|
height: 1,
|
|
};
|
|
let tile = Paragraph::new(symbol)
|
|
.alignment(Alignment::Center)
|
|
.style(Style::new().bg(bg).fg(fg).add_modifier(Modifier::BOLD));
|
|
frame.render_widget(tile, centered_area);
|
|
}
|
|
}
|
|
|
|
fn render_scope(frame: &mut Frame, app: &App, area: Rect) {
|
|
let scope = Scope::new(&app.metrics.scope)
|
|
.orientation(Orientation::Horizontal)
|
|
.color(Color::Green);
|
|
frame.render_widget(scope, area);
|
|
}
|
|
|
|
fn render_spectrum(frame: &mut Frame, app: &App, area: Rect) {
|
|
let area = Rect { height: area.height.saturating_sub(1), ..area };
|
|
let spectrum = Spectrum::new(&app.metrics.spectrum);
|
|
frame.render_widget(spectrum, area);
|
|
}
|
|
|
|
fn render_vu_meter(frame: &mut Frame, app: &App, area: Rect) {
|
|
let vu = VuMeter::new(app.metrics.peak_left, app.metrics.peak_right);
|
|
frame.render_widget(vu, area);
|
|
}
|
|
|