495 lines
15 KiB
Rust
495 lines
15 KiB
Rust
|
//! Interactive terminal UI — the crossterm counterpart of orca-c's
|
||
|
|
//! ncurses tui_main.c: grid editor, playback clock, selection, undo,
|
||
|
|
//! and event delivery to the configured outputs.
|
||
|
|
|
||
|
|
use std::fs::File;
|
||
|
|
use std::io::{self, Write};
|
||
|
|
use std::time::{Duration, Instant};
|
||
|
|
|
||
|
|
use crossterm::cursor::{Hide, MoveTo, Show};
|
||
|
|
use crossterm::event::{self, Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers};
|
||
|
|
use crossterm::style::{Attribute, Print, SetAttribute};
|
||
|
|
use crossterm::terminal::{
|
||
|
|
self, disable_raw_mode, enable_raw_mode, BeginSynchronizedUpdate, Clear, ClearType,
|
||
|
|
EndSynchronizedUpdate, EnterAlternateScreen, LeaveAlternateScreen,
|
||
|
|
};
|
||
|
|
use crossterm::{execute, queue};
|
||
|
|
|
||
|
|
use crate::io::EventOutputs;
|
||
|
|
use crate::sim::{
|
||
|
|
copy_subrect, fill_subrect, orca_run, Field, MarkBuffer, Oevent, MARK_HASTE, MARK_INPUT,
|
||
|
|
MARK_LOCK, MARK_OUTPUT, MARK_SLEEP,
|
||
|
|
};
|
||
|
|
|
||
|
|
const MAX_UNDO: usize = 256;
|
||
|
|
const MAX_DIM: usize = 512;
|
||
|
|
const HELP_LINE: &str =
|
||
|
|
"space play ^F step ^S save ^Z undo ^X/^C/^V clip shift+arrows select ^arrows resize < > ( ) bpm ^Q quit";
|
||
|
|
|
||
|
|
pub struct TuiConfig {
|
||
|
|
pub path: Option<String>,
|
||
|
|
pub bpm: usize,
|
||
|
|
pub seed: usize,
|
||
|
|
pub outputs: EventOutputs,
|
||
|
|
}
|
||
|
|
|
||
|
|
struct Clip {
|
||
|
|
data: Vec<u8>,
|
||
|
|
h: usize,
|
||
|
|
w: usize,
|
||
|
|
}
|
||
|
|
|
||
|
|
struct Snapshot {
|
||
|
|
data: Vec<u8>,
|
||
|
|
h: usize,
|
||
|
|
w: usize,
|
||
|
|
tick: usize,
|
||
|
|
}
|
||
|
|
|
||
|
|
struct App {
|
||
|
|
field: Field,
|
||
|
|
mbuf: MarkBuffer,
|
||
|
|
scratch: Vec<u8>,
|
||
|
|
tick: usize,
|
||
|
|
bpm: usize,
|
||
|
|
playing: bool,
|
||
|
|
cur_y: usize,
|
||
|
|
cur_x: usize,
|
||
|
|
sel_h: usize,
|
||
|
|
sel_w: usize,
|
||
|
|
clipboard: Option<Clip>,
|
||
|
|
undo: Vec<Snapshot>,
|
||
|
|
outputs: EventOutputs,
|
||
|
|
events: Vec<Oevent>,
|
||
|
|
seed: usize,
|
||
|
|
path: String,
|
||
|
|
msg: String,
|
||
|
|
needs_preview: bool,
|
||
|
|
}
|
||
|
|
|
||
|
|
fn is_valid_glyph(c: char) -> bool {
|
||
|
|
c.is_ascii_alphanumeric() || matches!(c, '!' | '#' | '%' | '*' | '.' | ':' | ';' | '=' | '?')
|
||
|
|
}
|
||
|
|
|
||
|
|
fn tick_period(bpm: usize) -> Duration {
|
||
|
|
// One Orca frame is a 16th note: 60000 ms / bpm / 4.
|
||
|
|
Duration::from_millis((60_000 / bpm.max(1) / 4).max(1) as u64)
|
||
|
|
}
|
||
|
|
|
||
|
|
impl App {
|
||
|
|
fn dims(&self) -> (usize, usize) {
|
||
|
|
(self.field.height as usize, self.field.width as usize)
|
||
|
|
}
|
||
|
|
|
||
|
|
fn clamp_cursor(&mut self) {
|
||
|
|
let (h, w) = self.dims();
|
||
|
|
self.cur_y = self.cur_y.min(h - 1);
|
||
|
|
self.cur_x = self.cur_x.min(w - 1);
|
||
|
|
self.sel_h = self.sel_h.clamp(1, h - self.cur_y);
|
||
|
|
self.sel_w = self.sel_w.clamp(1, w - self.cur_x);
|
||
|
|
}
|
||
|
|
|
||
|
|
fn do_tick(&mut self) {
|
||
|
|
let (h, w) = self.dims();
|
||
|
|
self.mbuf.ensure_size(h, w);
|
||
|
|
self.mbuf.clear(h, w);
|
||
|
|
self.outputs.begin_tick();
|
||
|
|
orca_run(
|
||
|
|
&mut self.field.buffer,
|
||
|
|
&mut self.mbuf.buffer[..h * w],
|
||
|
|
h,
|
||
|
|
w,
|
||
|
|
self.tick,
|
||
|
|
&mut self.events,
|
||
|
|
self.seed,
|
||
|
|
);
|
||
|
|
self.outputs.dispatch(&mut self.events);
|
||
|
|
self.tick += 1;
|
||
|
|
self.needs_preview = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Run the sim on a scratch copy so port highlighting stays live while
|
||
|
|
// paused, without mutating the grid or emitting events.
|
||
|
|
fn preview(&mut self) {
|
||
|
|
let (h, w) = self.dims();
|
||
|
|
self.mbuf.ensure_size(h, w);
|
||
|
|
self.mbuf.clear(h, w);
|
||
|
|
self.scratch.clear();
|
||
|
|
self.scratch.extend_from_slice(&self.field.buffer);
|
||
|
|
let mut discarded: Vec<Oevent> = Vec::new();
|
||
|
|
orca_run(
|
||
|
|
&mut self.scratch,
|
||
|
|
&mut self.mbuf.buffer[..h * w],
|
||
|
|
h,
|
||
|
|
w,
|
||
|
|
self.tick,
|
||
|
|
&mut discarded,
|
||
|
|
self.seed,
|
||
|
|
);
|
||
|
|
self.needs_preview = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
fn push_undo(&mut self) {
|
||
|
|
if self.undo.len() >= MAX_UNDO {
|
||
|
|
self.undo.remove(0);
|
||
|
|
}
|
||
|
|
let (h, w) = self.dims();
|
||
|
|
self.undo.push(Snapshot {
|
||
|
|
data: self.field.buffer.clone(),
|
||
|
|
h,
|
||
|
|
w,
|
||
|
|
tick: self.tick,
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
fn undo(&mut self) {
|
||
|
|
if let Some(s) = self.undo.pop() {
|
||
|
|
self.field.buffer = s.data;
|
||
|
|
self.field.height = s.h as u16;
|
||
|
|
self.field.width = s.w as u16;
|
||
|
|
self.tick = s.tick;
|
||
|
|
self.clamp_cursor();
|
||
|
|
self.needs_preview = true;
|
||
|
|
self.msg = "undid".into();
|
||
|
|
} else {
|
||
|
|
self.msg = "nothing to undo".into();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn fill_selection(&mut self, g: u8) {
|
||
|
|
self.push_undo();
|
||
|
|
let (h, w) = self.dims();
|
||
|
|
fill_subrect(
|
||
|
|
&mut self.field.buffer,
|
||
|
|
h,
|
||
|
|
w,
|
||
|
|
self.cur_y,
|
||
|
|
self.cur_x,
|
||
|
|
self.sel_h,
|
||
|
|
self.sel_w,
|
||
|
|
g,
|
||
|
|
);
|
||
|
|
self.needs_preview = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
fn copy_selection(&mut self) {
|
||
|
|
let (h, w) = self.dims();
|
||
|
|
let mut data = vec![b'.'; self.sel_h * self.sel_w];
|
||
|
|
copy_subrect(
|
||
|
|
&self.field.buffer,
|
||
|
|
&mut data,
|
||
|
|
h,
|
||
|
|
w,
|
||
|
|
self.sel_h,
|
||
|
|
self.sel_w,
|
||
|
|
self.cur_y,
|
||
|
|
self.cur_x,
|
||
|
|
0,
|
||
|
|
0,
|
||
|
|
self.sel_h,
|
||
|
|
self.sel_w,
|
||
|
|
);
|
||
|
|
self.clipboard = Some(Clip {
|
||
|
|
data,
|
||
|
|
h: self.sel_h,
|
||
|
|
w: self.sel_w,
|
||
|
|
});
|
||
|
|
self.msg = "copied".into();
|
||
|
|
}
|
||
|
|
|
||
|
|
fn paste(&mut self) {
|
||
|
|
let Some(clip) = self.clipboard.take() else {
|
||
|
|
self.msg = "clipboard empty".into();
|
||
|
|
return;
|
||
|
|
};
|
||
|
|
self.push_undo();
|
||
|
|
let (h, w) = self.dims();
|
||
|
|
copy_subrect(
|
||
|
|
&clip.data,
|
||
|
|
&mut self.field.buffer,
|
||
|
|
clip.h,
|
||
|
|
clip.w,
|
||
|
|
h,
|
||
|
|
w,
|
||
|
|
0,
|
||
|
|
0,
|
||
|
|
self.cur_y,
|
||
|
|
self.cur_x,
|
||
|
|
clip.h,
|
||
|
|
clip.w,
|
||
|
|
);
|
||
|
|
self.msg = "pasted".into();
|
||
|
|
self.clipboard = Some(clip);
|
||
|
|
self.needs_preview = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
fn resize_grid(&mut self, dy: isize, dx: isize) {
|
||
|
|
let (h, w) = self.dims();
|
||
|
|
let nh = (h as isize + dy).clamp(1, MAX_DIM as isize) as usize;
|
||
|
|
let nw = (w as isize + dx).clamp(1, MAX_DIM as isize) as usize;
|
||
|
|
if (nh, nw) == (h, w) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
self.push_undo();
|
||
|
|
self.field.resize(nh, nw);
|
||
|
|
self.mbuf.ensure_size(nh, nw);
|
||
|
|
self.clamp_cursor();
|
||
|
|
self.needs_preview = true;
|
||
|
|
self.msg = format!("grid {nw}x{nh}");
|
||
|
|
}
|
||
|
|
|
||
|
|
fn save(&mut self) {
|
||
|
|
let result = File::create(&self.path).and_then(|mut f| self.field.write_to(&mut f));
|
||
|
|
self.msg = match result {
|
||
|
|
Ok(()) => format!("saved {}", self.path),
|
||
|
|
Err(e) => format!("save failed: {e}"),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Restore the terminal even if we exit via error or panic.
|
||
|
|
struct TermGuard;
|
||
|
|
|
||
|
|
impl Drop for TermGuard {
|
||
|
|
fn drop(&mut self) {
|
||
|
|
let _ = disable_raw_mode();
|
||
|
|
let _ = execute!(io::stdout(), LeaveAlternateScreen, Show);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn run(cfg: TuiConfig) -> Result<(), String> {
|
||
|
|
let (path, field) = match cfg.path {
|
||
|
|
Some(p) => {
|
||
|
|
if std::path::Path::new(&p).exists() {
|
||
|
|
let f = Field::load_file(&p)
|
||
|
|
.map_err(|e| format!("cannot load {p}: {}", e.as_str()))?;
|
||
|
|
(p, f)
|
||
|
|
} else {
|
||
|
|
(p, default_field()?)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
None => ("untitled.orca".to_string(), default_field()?),
|
||
|
|
};
|
||
|
|
|
||
|
|
let mut app = App {
|
||
|
|
mbuf: MarkBuffer::new(),
|
||
|
|
scratch: Vec::new(),
|
||
|
|
tick: 0,
|
||
|
|
bpm: cfg.bpm,
|
||
|
|
playing: false,
|
||
|
|
cur_y: 0,
|
||
|
|
cur_x: 0,
|
||
|
|
sel_h: 1,
|
||
|
|
sel_w: 1,
|
||
|
|
clipboard: None,
|
||
|
|
undo: Vec::new(),
|
||
|
|
outputs: cfg.outputs,
|
||
|
|
events: Vec::new(),
|
||
|
|
seed: cfg.seed,
|
||
|
|
path,
|
||
|
|
msg: String::new(),
|
||
|
|
needs_preview: true,
|
||
|
|
field,
|
||
|
|
};
|
||
|
|
|
||
|
|
enable_raw_mode().map_err(|e| e.to_string())?;
|
||
|
|
let _guard = TermGuard;
|
||
|
|
let mut stdout = io::stdout();
|
||
|
|
execute!(stdout, EnterAlternateScreen, Hide).map_err(|e| e.to_string())?;
|
||
|
|
|
||
|
|
main_loop(&mut app, &mut stdout).map_err(|e| e.to_string())?;
|
||
|
|
app.outputs.silence();
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
|
||
|
|
fn default_field() -> Result<Field, String> {
|
||
|
|
let (cols, rows) = terminal::size().unwrap_or((80, 25));
|
||
|
|
let w = (cols as usize).clamp(20, 200);
|
||
|
|
let h = (rows.saturating_sub(3) as usize).clamp(10, 200);
|
||
|
|
Ok(Field::with_fill(h, w, b'.'))
|
||
|
|
}
|
||
|
|
|
||
|
|
fn main_loop(app: &mut App, stdout: &mut io::Stdout) -> io::Result<()> {
|
||
|
|
let mut next_tick = Instant::now();
|
||
|
|
loop {
|
||
|
|
if app.needs_preview && !app.playing {
|
||
|
|
app.preview();
|
||
|
|
}
|
||
|
|
draw(stdout, app)?;
|
||
|
|
|
||
|
|
let timeout = if app.playing {
|
||
|
|
let now = Instant::now();
|
||
|
|
if now >= next_tick {
|
||
|
|
app.do_tick();
|
||
|
|
next_tick += tick_period(app.bpm);
|
||
|
|
if next_tick < now {
|
||
|
|
next_tick = now + tick_period(app.bpm);
|
||
|
|
}
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
next_tick - now
|
||
|
|
} else {
|
||
|
|
Duration::from_millis(200)
|
||
|
|
};
|
||
|
|
|
||
|
|
if event::poll(timeout)? {
|
||
|
|
match event::read()? {
|
||
|
|
Event::Key(key)
|
||
|
|
if matches!(key.kind, KeyEventKind::Press | KeyEventKind::Repeat)
|
||
|
|
&& !handle_key(app, key, &mut next_tick) =>
|
||
|
|
{
|
||
|
|
return Ok(());
|
||
|
|
}
|
||
|
|
_ => {}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns false when the app should quit.
|
||
|
|
fn handle_key(app: &mut App, key: KeyEvent, next_tick: &mut Instant) -> bool {
|
||
|
|
let ctrl = key.modifiers.contains(KeyModifiers::CONTROL);
|
||
|
|
let shift = key.modifiers.contains(KeyModifiers::SHIFT);
|
||
|
|
let alt = key.modifiers.contains(KeyModifiers::ALT);
|
||
|
|
let (h, w) = app.dims();
|
||
|
|
|
||
|
|
match key.code {
|
||
|
|
KeyCode::Char('q') if ctrl => return false,
|
||
|
|
KeyCode::Char('s') if ctrl => app.save(),
|
||
|
|
KeyCode::Char('z') | KeyCode::Char('u') if ctrl => app.undo(),
|
||
|
|
KeyCode::Char('c') if ctrl => app.copy_selection(),
|
||
|
|
KeyCode::Char('x') if ctrl => {
|
||
|
|
app.copy_selection();
|
||
|
|
app.fill_selection(b'.');
|
||
|
|
app.msg = "cut".into();
|
||
|
|
}
|
||
|
|
KeyCode::Char('v') if ctrl => app.paste(),
|
||
|
|
KeyCode::Char('f') if ctrl
|
||
|
|
&& !app.playing => {
|
||
|
|
app.do_tick();
|
||
|
|
app.needs_preview = true;
|
||
|
|
}
|
||
|
|
KeyCode::Char('r') if ctrl => {
|
||
|
|
app.tick = 0;
|
||
|
|
app.needs_preview = true;
|
||
|
|
app.msg = "frame reset".into();
|
||
|
|
}
|
||
|
|
KeyCode::Char(' ') => {
|
||
|
|
app.playing = !app.playing;
|
||
|
|
if app.playing {
|
||
|
|
*next_tick = Instant::now();
|
||
|
|
} else {
|
||
|
|
app.outputs.silence();
|
||
|
|
app.needs_preview = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
KeyCode::Char('<') => app.bpm = (app.bpm.saturating_sub(1)).max(10),
|
||
|
|
KeyCode::Char('>') => app.bpm = (app.bpm + 1).min(999),
|
||
|
|
KeyCode::Char('(') => app.bpm = (app.bpm.saturating_sub(10)).max(10),
|
||
|
|
KeyCode::Char(')') => app.bpm = (app.bpm + 10).min(999),
|
||
|
|
KeyCode::Esc => {
|
||
|
|
app.sel_h = 1;
|
||
|
|
app.sel_w = 1;
|
||
|
|
app.msg.clear();
|
||
|
|
}
|
||
|
|
KeyCode::Backspace | KeyCode::Delete => app.fill_selection(b'.'),
|
||
|
|
KeyCode::Up | KeyCode::Down | KeyCode::Left | KeyCode::Right => {
|
||
|
|
let (dy, dx): (isize, isize) = match key.code {
|
||
|
|
KeyCode::Up => (-1, 0),
|
||
|
|
KeyCode::Down => (1, 0),
|
||
|
|
KeyCode::Left => (0, -1),
|
||
|
|
_ => (0, 1),
|
||
|
|
};
|
||
|
|
if ctrl {
|
||
|
|
app.resize_grid(dy, dx);
|
||
|
|
} else if shift {
|
||
|
|
app.sel_h = (app.sel_h as isize + dy).clamp(1, (h - app.cur_y) as isize) as usize;
|
||
|
|
app.sel_w = (app.sel_w as isize + dx).clamp(1, (w - app.cur_x) as isize) as usize;
|
||
|
|
} else {
|
||
|
|
let step: isize = if alt { 8 } else { 1 };
|
||
|
|
app.cur_y = (app.cur_y as isize + dy * step).clamp(0, h as isize - 1) as usize;
|
||
|
|
app.cur_x = (app.cur_x as isize + dx * step).clamp(0, w as isize - 1) as usize;
|
||
|
|
app.clamp_cursor();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
KeyCode::Char(c) if !ctrl && !alt && is_valid_glyph(c) => {
|
||
|
|
app.fill_selection(c as u8);
|
||
|
|
}
|
||
|
|
_ => {}
|
||
|
|
}
|
||
|
|
true
|
||
|
|
}
|
||
|
|
|
||
|
|
fn draw(out: &mut io::Stdout, app: &App) -> io::Result<()> {
|
||
|
|
let (tw, th) = terminal::size()?;
|
||
|
|
let (gh, gw) = app.dims();
|
||
|
|
let grid_rows = th.saturating_sub(2) as usize;
|
||
|
|
let vis_h = gh.min(grid_rows);
|
||
|
|
let vis_w = gw.min(tw as usize);
|
||
|
|
|
||
|
|
queue!(out, BeginSynchronizedUpdate, Hide, Clear(ClearType::All))?;
|
||
|
|
|
||
|
|
for y in 0..vis_h {
|
||
|
|
queue!(out, MoveTo(0, y as u16))?;
|
||
|
|
for x in 0..vis_w {
|
||
|
|
let g = app.field.buffer[y * gw + x];
|
||
|
|
let m = app.mbuf.buffer.get(y * gw + x).copied().unwrap_or(0);
|
||
|
|
let is_cursor = y == app.cur_y && x == app.cur_x;
|
||
|
|
let in_sel = y >= app.cur_y
|
||
|
|
&& y < app.cur_y + app.sel_h
|
||
|
|
&& x >= app.cur_x
|
||
|
|
&& x < app.cur_x + app.sel_w;
|
||
|
|
|
||
|
|
let ch = if g == b'.' {
|
||
|
|
if is_cursor {
|
||
|
|
'@'
|
||
|
|
} else if y % 8 == 0 && x % 8 == 0 {
|
||
|
|
'+'
|
||
|
|
} else {
|
||
|
|
'.'
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
g as char
|
||
|
|
};
|
||
|
|
|
||
|
|
queue!(out, SetAttribute(Attribute::Reset))?;
|
||
|
|
if is_cursor {
|
||
|
|
queue!(out, SetAttribute(Attribute::Reverse), SetAttribute(Attribute::Bold))?;
|
||
|
|
} else if in_sel {
|
||
|
|
queue!(out, SetAttribute(Attribute::Reverse))?;
|
||
|
|
} else if m & MARK_OUTPUT != 0 {
|
||
|
|
queue!(out, SetAttribute(Attribute::Reverse))?;
|
||
|
|
} else if m & (MARK_INPUT | MARK_HASTE) != 0 {
|
||
|
|
queue!(out, SetAttribute(Attribute::Bold))?;
|
||
|
|
} else if g == b'.' || m & (MARK_LOCK | MARK_SLEEP) != 0 {
|
||
|
|
queue!(out, SetAttribute(Attribute::Dim))?;
|
||
|
|
}
|
||
|
|
queue!(out, Print(ch))?;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
let state = if app.playing { "playing" } else { "paused" };
|
||
|
|
let status = format!(
|
||
|
|
"{} {}f {}bpm {} {},{} {}x{} {}",
|
||
|
|
app.path, app.tick, app.bpm, state, app.cur_x, app.cur_y, gw, gh, app.msg
|
||
|
|
);
|
||
|
|
let mut line1: String = status.chars().take(tw as usize).collect();
|
||
|
|
line1 = format!("{:<width$}", line1, width = tw as usize);
|
||
|
|
let help: String = HELP_LINE.chars().take(tw as usize).collect();
|
||
|
|
|
||
|
|
queue!(
|
||
|
|
out,
|
||
|
|
SetAttribute(Attribute::Reset),
|
||
|
|
MoveTo(0, th.saturating_sub(2)),
|
||
|
|
SetAttribute(Attribute::Reverse),
|
||
|
|
Print(line1),
|
||
|
|
SetAttribute(Attribute::Reset),
|
||
|
|
MoveTo(0, th.saturating_sub(1)),
|
||
|
|
SetAttribute(Attribute::Dim),
|
||
|
|
Print(help),
|
||
|
|
SetAttribute(Attribute::Reset),
|
||
|
|
EndSynchronizedUpdate
|
||
|
|
)?;
|
||
|
|
out.flush()
|
||
|
|
}
|