unspeaker/tek
1
0
Fork 0
mirror of https://codeberg.org/unspeaker/tek.git synced 2025-12-06 11:46:41 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

use main loop with input everywhere

Browse source
This commit is contained in:
🪞👃🪞 2024-05-29 11:32:26 +03:00
parent d6bf840a1f
commit 7dd5f7f488
16 changed files with 301 additions and 168 deletions
Download patch file Download diff file Expand all files Collapse all files

17
src/looper.rs
View file

@ -6,14 +6,25 @@ pub use self::jack::*;
pub use self::render::*;
use crate::prelude::*;
pub struct Looper;
pub struct Looper {
exited: bool
}
const ACTIONS: [(&'static str, &'static str);1] = [
pub const ACTIONS: [(&'static str, &'static str);1] = [
("Ins/Del", "Add/remove loop"),
];
impl Looper {
pub fn new () -> Result<Self, Box<dyn Error>> {
Ok(Self)
Ok(Self { exited: false })
}
}
impl Exitable for Looper {
fn exit (&mut self) {
self.exited = true
}
fn exited (&self) -> bool {
self.exited
}
}

4
src/looper/handle.rs
View file

@ -1,2 +1,6 @@
use crate::prelude::*;
use super::Looper;
pub fn handle (state: &mut Looper, event: &Event) -> Result<(), Box<dyn Error>> {
Ok(())
}

2
src/looper/render.rs
View file

@ -6,8 +6,6 @@ pub fn render (
stdout: &mut std::io::Stdout,
mut offset: (u16, u16),
) -> Result<(), Box<dyn Error>> {
let (w, h) = crate::render::render_toolbar_vertical(stdout, offset, &ACTIONS)?;
offset.0 = offset.0 + w + 2;
let move_to = |col, row| MoveTo(offset.0 + col, offset.1 + row);
stdout
.queue(move_to(0, 0))?.queue(Print(" Name Input Length Route"))?

294
src/main.rs
View file

@ -20,131 +20,199 @@ use crate::prelude::*;
fn main () -> Result<(), Box<dyn Error>> {
let cli = cli::Cli::parse();
if let Some(command) = cli.command {
match command {
cli::Command::Transport => main_loop(
&mut transport::Transport::new()?,
transport::render
),
cli::Command::Mixer => main_loop(
&mut mixer::Mixer::new()?,
mixer::render
),
cli::Command::Looper => main_loop(
&mut looper::Looper::new()?,
looper::render
),
cli::Command::Sampler => main_loop(
&mut sampler::Sampler::new()?,
sampler::render
),
cli::Command::Sequencer => main_loop(
&mut sequencer::Sequencer::new()?,
sequencer::render
),
}
run_one(&command)
} else {
main_loop(&mut (
transport::Transport::new()?,
mixer::Mixer::new()?,
looper::Looper::new()?,
sampler::Sampler::new()?,
sequencer::Sequencer::new()?,
), |(transport, mixer, looper, sampler, sequencer), stdout, offset| {
transport::render(transport, stdout, (1, 1))?;
render::render_box(stdout, 28, 0, 60, 6, false)?;
mixer::render(mixer, stdout, (1, 10))?;
render::render_box(stdout, 18, 9, 62, 9, false)?;
looper::render(looper, stdout, (1, 20))?;
render::render_box(stdout, 17, 19, 50, 6, false)?;
run_all()
}
}
fn run_one (command: &cli::Command) -> Result<(), Box<dyn Error>> {
match command {
cli::Command::Transport => main_loop(
&mut transport::Transport::new()?,
|state, stdout, mut offset| {
let (w, h) = render::render_toolbar_vertical(stdout, offset, &transport::ACTIONS)?;
offset.0 = offset.0 + w + 2;
transport::render(state, stdout, offset)
},
|_, _|Ok(())
),
cli::Command::Mixer => main_loop(
&mut mixer::Mixer::new()?,
|state, stdout, mut offset| {
let (w, h) = render::render_toolbar_vertical(stdout, offset, &mixer::ACTIONS)?;
offset.0 = offset.0 + w + 2;
mixer::render(state, stdout, offset)
},
|_, _|Ok(())
),
cli::Command::Looper => main_loop(
&mut looper::Looper::new()?,
|state, stdout, mut offset| {
let (w, h) = render::render_toolbar_vertical(stdout, offset, &looper::ACTIONS)?;
offset.0 = offset.0 + w + 2;
looper::render(state, stdout, offset)
},
|_, _|Ok(())
),
cli::Command::Sampler => main_loop(
&mut sampler::Sampler::new()?,
|state, stdout, mut offset| {
let (w, h) = render::render_toolbar_vertical(stdout, offset, &sampler::ACTIONS)?;
offset.0 = offset.0 + w + 2;
sampler::render(state, stdout, offset)
},
|_, _|Ok(())
),
cli::Command::Sequencer => main_loop(
&mut sequencer::Sequencer::new()?,
|state, stdout, mut offset| {
let (w, h) = render::render_toolbar_vertical(stdout, offset, &sequencer::ACTIONS)?;
offset.0 = offset.0 + w + 2;
sequencer::render(state, stdout, offset)
},
|_, _|Ok(())
),
}
}
fn run_all () -> Result<(), Box<dyn Error>> {
let mut actions = vec![];
actions.extend_from_slice(&transport::ACTIONS);
actions.extend_from_slice(&mixer::ACTIONS);
actions.extend_from_slice(&looper::ACTIONS);
main_loop(
&mut App {
exited: false,
mode: Mode::Transport,
transport: transport::Transport::new()?,
mixer: mixer::Mixer::new()?,
looper: looper::Looper::new()?,
sampler: sampler::Sampler::new()?,
sequencer: sequencer::Sequencer::new()?,
},
|state, stdout, mut offset| {
let (w, h) = render::render_toolbar_vertical(stdout, (offset.0, offset.1 + 1), &actions)?;
offset.0 = offset.0 + w + 1;
transport::render(&mut state.transport, stdout, (offset.0 + 1, 1))?;
render::render_box(stdout, offset.0, 0, 64, 4,
state.mode == Mode::Transport)?;
mixer::render(&mut state.mixer, stdout, (offset.0 + 1, 6))?;
render::render_box(stdout, offset.0, 5, 64, 9,
state.mode == Mode::Mixer)?;
looper::render(&mut state.looper, stdout, (offset.0 + 1, 16))?;
render::render_box(stdout, offset.0, 15, 64, 6,
state.mode == Mode::Looper)?;
//sampler::render(sampler, stdout, (1, 46))?;
//sequencer::render(sequencer, stdout, (1, 66))?;
Ok(())
})
},
|state, event| {
if let Event::Key(key) = event {
match key.code {
KeyCode::Char('c') => {
if key.modifiers == KeyModifiers::CONTROL {
state.exit();
}
},
KeyCode::Tab => match state.mode {
Mode::Transport => state.mode = Mode::Mixer,
Mode::Mixer => state.mode = Mode::Looper,
Mode::Looper => state.mode = Mode::Transport,
_ => {}
},
KeyCode::BackTab => match state.mode {
Mode::Transport => state.mode = Mode::Looper,
Mode::Looper => state.mode = Mode::Mixer,
Mode::Mixer => state.mode = Mode::Transport,
_ => {}
},
_ => match state.mode {
Mode::Transport => transport::handle(
&mut state.transport, event
)?,
Mode::Mixer => mixer::handle(
&mut state.mixer, event
)?,
Mode::Looper => looper::handle(
&mut state.looper, event
)?,
_ => {},
}
}
}
Ok(())
}
)
}
struct App {
exited: bool,
mode: Mode,
transport: crate::transport::Transport,
mixer: crate::mixer::Mixer,
looper: crate::looper::Looper,
sampler: crate::sampler::Sampler,
sequencer: crate::sequencer::Sequencer,
}
#[derive(PartialEq)]
enum Mode {
Transport,
Mixer,
Looper,
Sampler,
Sequencer
}
impl Exitable for App {
fn exit (&mut self) {
self.exited = true
}
fn exited (&self) -> bool {
self.exited
}
}
pub fn main_loop <T> (
pub fn main_loop <T: Exitable> (
state: &mut T,
mut render: impl FnMut(&mut T, &mut Stdout, (u16, u16)) -> Result<(), Box<dyn Error>>
mut render: impl FnMut(&mut T, &mut Stdout, (u16, u16)) -> Result<(), Box<dyn Error>>,
mut handle: impl FnMut(&mut T, &Event) -> Result<(), Box<dyn Error>>,
) -> Result<(), Box<dyn Error>> {
let mut stdout = stdout();
let sleep = std::time::Duration::from_millis(16);
let mut stdout = std::io::stdout();
crossterm::terminal::enable_raw_mode()?;
let (tx, input) = channel::<crossterm::event::Event>();
let exited = Arc::new(AtomicBool::new(false));
let exit_input_thread = exited.clone();
spawn(move || {
loop {
// Exit if flag is set
if exit_input_thread.fetch_and(true, Ordering::Relaxed) {
break
}
// Listen for events and send them to the main thread
if crossterm::event::poll(Duration::from_millis(100)).is_ok() {
if tx.send(crossterm::event::read().unwrap()).is_err() {
break
}
}
}
});
stdout.queue(Clear(ClearType::All))?.queue(Hide)?.flush()?;
loop {
stdout.queue(Clear(ClearType::All))?.queue(Hide)?;
render(state, &mut stdout, (0, 0))?;
stdout.flush()?;
std::thread::sleep(sleep);
handle(state, &input.recv()?)?;
if state.exited() {
crossterm::terminal::disable_raw_mode()?;
stdout.queue(Clear(ClearType::All))?.queue(Show)?.flush()?;
break
}
}
Ok(())
}
//pub fn run_tui () -> Result<(), Box<dyn Error>> {
//let mut stdout = stdout();
//let mut app = Mixer::new()?;
//let sleep = std::time::Duration::from_millis(16);
//crossterm::terminal::enable_raw_mode()?;
//let (tx, input) = channel::<crossterm::event::Event>();
//let exited = Arc::new(AtomicBool::new(false));
//let exit_input_thread = exited.clone();
//spawn(move || {
//loop {
//// Exit if flag is set
//if exit_input_thread.fetch_and(true, Ordering::Relaxed) {
//break
//}
//// Listen for events and send them to the main thread
//if crossterm::event::poll(Duration::from_millis(100)).is_ok() {
//if tx.send(crossterm::event::read().unwrap()).is_err() {
//break
//}
//}
//}
//});
//loop {
//render(&mut app, &mut stdout, (0, 0))?;
//handle(&mut app, input.recv()?)?;
//if app.exit {
//app.stdout.queue(cursor::Show)?.flush()?;
//crossterm::terminal::disable_raw_mode()?;
//break
//}
//}
//Ok(())
//}
//pub fn run_tui () -> Result<(), Box<dyn Error>> {
//let mut app = Self::new()?;
//let mut stdout = std::io::stdout();
//let sleep = std::time::Duration::from_millis(16);
//crossterm::terminal::enable_raw_mode()?;
//let (tx, input) = channel::<crossterm::event::Event>();
//let exited = Arc::new(AtomicBool::new(false));
//// Spawn the input thread
//let exit_input_thread = exited.clone();
//spawn(move || {
//loop {
//// Exit if flag is set
//if exit_input_thread.fetch_and(true, Ordering::Relaxed) {
//break
//}
//// Listen for events and send them to the main thread
//if crossterm::event::poll(Duration::from_millis(100)).is_ok() {
//if tx.send(crossterm::event::read().unwrap()).is_err() {
//break
//}
//}
//}
//});
//loop {
//use crossterm::{*, terminal::{Clear, ClearType}, cursor::Hide};
//stdout.queue(Clear(ClearType::All))?.queue(Hide)?;
//render(&mut app, &mut stdout, (0, 0))?;
//stdout.flush()?;
//handle(&mut app, input.recv()?)?;
//if app.exit {
//stdout.queue(cursor::Hide)?.flush()?;
//crossterm::terminal::disable_raw_mode()?;
//break
//}
//}
//Ok(())
//}

15
src/mixer.rs
View file

@ -11,14 +11,14 @@ use crate::prelude::*;
// - If one stage clips, all stages after it are marked red
// - If one track clips, all tracks that feed from it are marked red?
const ACTIONS: [(&'static str, &'static str);2] = [
pub const ACTIONS: [(&'static str, &'static str);2] = [
("+/-", "Adjust"),
("Ins/Del", "Add/remove track"),
];
pub struct Mixer {
exited: bool,
jack: Jack<Notifications>,
exit: bool,
tracks: Vec<Track>,
selected_track: usize,
selected_column: usize,
@ -57,7 +57,7 @@ impl Mixer {
)
)?;
Ok(Self {
exit: false,
exited: false,
selected_column: 0,
selected_track: 1,
tracks: vec![
@ -108,3 +108,12 @@ impl Track {
})
}
}
impl Exitable for Mixer {
fn exit (&mut self) {
self.exited = true
}
fn exited (&self) -> bool {
self.exited
}
}

14
src/mixer/handle.rs
View file

@ -1,16 +1,14 @@
use crate::prelude::*;
use super::Mixer;
pub fn handle (
state: &mut Mixer,
event: crossterm::event::Event
) -> Result<(), Box<dyn Error>> {
use crossterm::event::{Event, KeyCode, KeyModifiers};
pub fn handle (state: &mut Mixer, event: &Event) -> Result<(), Box<dyn Error>> {
if let Event::Key(event) = event {
match event.code {
KeyCode::Char('c') => {
if event.modifiers == KeyModifiers::CONTROL {
state.exit = true;
state.exit();
}
},
KeyCode::Down => {
@ -40,9 +38,11 @@ pub fn handle (
}
},
_ => {
println!("{event:?}");
println!("\n{event:?}");
}
}
}
Ok(())
}

2
src/mixer/render.rs
View file

@ -6,8 +6,6 @@ pub fn render (
stdout: &mut Stdout,
mut offset: (u16, u16)
) -> Result<(), Box<dyn Error>> {
let (w, h) = crate::render::render_toolbar_vertical(stdout, offset, &ACTIONS)?;
offset.0 = offset.0 + w + 2;
render_table(state, stdout, offset)?;
render_meters(state, stdout, offset)?;
stdout.flush()?;

7
src/prelude.rs
View file

@ -9,7 +9,8 @@ pub use std::sync::{
};
pub use crossterm::{
QueueableCommand,
cursor::{self, MoveTo, Hide},
event::{Event, KeyCode, KeyModifiers},
cursor::{self, MoveTo, Show, Hide},
terminal::{self, Clear, ClearType},
style::*,
};
@ -32,3 +33,7 @@ pub type Jack<N> = AsyncClient<
N,
ClosureProcessHandler<Box<dyn FnMut(&Client, &ProcessScope)-> Control + Send>>
>;
pub trait Exitable {
fn exit (&mut self);
fn exited (&self) -> bool;
}

20
src/render.rs
View file

@ -5,7 +5,6 @@ pub fn render_toolbar_vertical (
offset: (u16, u16),
actions: &[(&str, &str)],
) -> Result<(u16, u16), Box<dyn Error>> {
use crossterm::{*, style::{Stylize, PrintStyledContent}, cursor::MoveTo};
let move_to = |col, row| MoveTo(offset.0 + col, offset.1 + row);
let mut x: u16 = 1;
let mut y: u16 = 0;
@ -31,11 +30,20 @@ pub fn render_box (
) -> Result<(), Box<dyn Error>> {
let edge: String = std::iter::repeat("─").take(w.saturating_sub(2) as usize).collect();
let back: String = std::iter::repeat(" ").take(w.saturating_sub(2) as usize).collect();
stdout.queue(MoveTo(x, y))?.queue(Print(&format!("┌{edge}┐")))?;
for row in y+1..y+h {
stdout.queue(MoveTo(x, row))?.queue(Print("│"))?;
stdout.queue(MoveTo(x+w-1, row))?.queue(Print("│"))?;
if active {
stdout.queue(MoveTo(x, y))?.queue(PrintStyledContent(format!("┌{edge}┐").bold().yellow()))?;
for row in y+1..y+h {
stdout.queue(MoveTo(x, row))?.queue(PrintStyledContent("│".bold().yellow()))?;
stdout.queue(MoveTo(x+w-1, row))?.queue(PrintStyledContent("│".bold().yellow()))?;
}
stdout.queue(MoveTo(x, y+h))?.queue(PrintStyledContent(format!("└{edge}┘").bold().yellow()))?;
} else {
stdout.queue(MoveTo(x, y))?.queue(Print(&format!("┌{edge}┐")))?;
for row in y+1..y+h {
stdout.queue(MoveTo(x, row))?.queue(Print("│"))?;
stdout.queue(MoveTo(x+w-1, row))?.queue(Print("│"))?;
}
stdout.queue(MoveTo(x, y+h))?.queue(Print(&format!("└{edge}┘")))?;
}
stdout.queue(MoveTo(x, y+h))?.queue(Print(&format!("└{edge}┘")))?;
Ok(())
}

15
src/sampler.rs
View file

@ -6,9 +6,11 @@ pub use self::jack::*;
pub use self::render::*;
use crate::prelude::*;
pub const ACTIONS: [(&'static str, &'static str);0] = [];
pub struct Sampler {
exited: bool,
jack: Jack<Notifications>,
exit: bool,
samples: Vec<Sample>,
selected_sample: usize,
selected_column: usize,
@ -29,7 +31,7 @@ impl Sampler {
)
)?;
Ok(Self {
exit: false,
exited: false,
selected_sample: 0,
selected_column: 0,
samples: vec![
@ -62,3 +64,12 @@ impl Sample {
}
}
impl Exitable for Sampler {
fn exit (&mut self) {
self.exited = true
}
fn exited (&self) -> bool {
self.exited
}
}

2
src/sampler/handle.rs
View file

@ -10,7 +10,7 @@ pub fn handle (
match event.code {
KeyCode::Char('c') => {
if event.modifiers == KeyModifiers::CONTROL {
state.exit = true;
state.exit();
}
},
KeyCode::Down => {

21
src/sequencer.rs
View file

@ -1,15 +1,16 @@
mod handle;
mod render;
mod jack;
mod render;
pub use self::handle::*;
pub use self::render::*;
pub use self::jack::*;
pub use self::render::*;
use crate::prelude::*;
pub const ACTIONS: [(&'static str, &'static str);0] = [];
pub struct Sequencer {
exited: bool,
jack: Jack<Notifications>,
exit: bool,
stdout: Stdout,
cursor: (u16, u16),
duration: u16,
}
@ -29,11 +30,19 @@ impl Sequencer {
)
)?;
Ok(Self {
exit: false,
stdout: std::io::stdout(),
exited: false,
cursor: (0, 0),
duration: 0,
jack,
})
}
}
impl Exitable for Sequencer {
fn exit (&mut self) {
self.exited = true
}
fn exited (&self) -> bool {
self.exited
}
}

2
src/sequencer/handle.rs
View file

@ -10,7 +10,7 @@ fn handle (
match event.code {
KeyCode::Char('c') => {
if event.modifiers == KeyModifiers::CONTROL {
state.exit = true;
state.exit();
}
},
KeyCode::Char('[') => {

26
src/transport.rs
View file

@ -6,17 +6,27 @@ pub use self::jack::*;
pub use self::render::*;
use crate::prelude::*;
pub struct Transport;
pub const ACTIONS: [(&'static str, &'static str);2] = [
("(Shift-)Tab, Arrows ", "Navigate"),
//("Home", "⏹ Stop and rewind"),
("(Shift-)Space", "⏮ Play/pause"),
];
pub struct Transport {
exited: bool
}
impl Transport {
pub fn new () -> Result<Self, Box<dyn Error>> {
Ok(Self)
Ok(Self { exited: false })
}
}
const ACTIONS: [(&'static str, &'static str);3] = [
("Tab/Shift-Tab, Arrows", "Navigate"),
//("Home", "⏹ Stop and rewind"),
("Space", "⏮ Play from cursor/pause"),
("Shift-Space", "⯈ Play from start/rewind"),
];
impl Exitable for Transport {
fn exit (&mut self) {
self.exited = true
}
fn exited (&self) -> bool {
self.exited
}
}

5
src/transport/handle.rs
View file

@ -1 +1,6 @@
use crate::prelude::*;
use super::*;
pub fn handle (state: &mut Transport, event: &Event) -> Result<(), Box<dyn Error>> {
Ok(())
}

23
src/transport/render.rs
View file

@ -6,33 +6,30 @@ pub fn render (
stdout: &mut Stdout,
mut offset: (u16, u16)
) -> Result<(), Box<dyn Error>> {
use crossterm::{*, cursor::{Hide, MoveTo}, style::{*, Stylize}};
let (w, h) = crate::render::render_toolbar_vertical(stdout, offset, &ACTIONS)?;
offset.0 = offset.0 + w + 2;
let move_to = |col, row| MoveTo(offset.0 + col, offset.1 + row);
stdout.queue(move_to( 1, 0))?.queue(
Print("Project: ")
)?.queue(move_to(10, 0))?.queue(
PrintStyledContent("The Quick Brown Fox - Jumping Over Lazy Dogs".white().bold())
)?.queue(move_to( 1, 2))?.queue(
)?.queue(move_to( 1, 1))?.queue(
Print("Rate: ")
)?.queue(move_to( 7, 2))?.queue(
)?.queue(move_to( 7, 1))?.queue(
PrintStyledContent("48000Hz".white().bold())
)?.queue(move_to(20, 2))?.queue(
)?.queue(move_to(20, 1))?.queue(
Print("BPM: ")
)?.queue(move_to(25, 2))?.queue(
)?.queue(move_to(25, 1))?.queue(
PrintStyledContent("120.34".white().bold())
)?.queue(move_to(35, 2))?.queue(
)?.queue(move_to(35, 1))?.queue(
Print("Signature: ")
)?.queue(move_to(46, 2))?.queue(
)?.queue(move_to(46, 1))?.queue(
PrintStyledContent("4 / 4".white().bold())
)?.queue(move_to( 1, 4))?.queue(
)?.queue(move_to( 1, 2))?.queue(
Print("Time: ")
)?.queue(move_to( 7, 4))?.queue(
)?.queue(move_to( 7, 2))?.queue(
PrintStyledContent("1m 23.456s".white().bold())
)?.queue(move_to(20, 4))?.queue(
)?.queue(move_to(20, 2))?.queue(
Print("Beat: ")
)?.queue(move_to(26, 4))?.queue(
)?.queue(move_to(26, 2))?.queue(
PrintStyledContent("30x 3/4".white().bold())
)?;
Ok(())