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

Compare commits

base: unspeaker:c0add81ff4043703fb63a8b6f6b79e5359a2ad33
Branches Tags
unspeaker:main
unspeaker:refactor/arranger-device
unspeaker:0.2
unspeaker:refactor/api
unspeaker:0.3.0-rc.1
unspeaker:0.2.2
unspeaker:0.2.1
unspeaker:0.2.0
unspeaker:test-release
unspeaker:0.2.0-rc.7
unspeaker:0.2.0-rc.6
unspeaker:0.2.0-rc.5
unspeaker:0.2.0-rc.4
unspeaker:0.2.0-rc.3
unspeaker:0.2.0-rc2
unspeaker:0.2.0-alpha1
...
compare: unspeaker:0c97f68754187b9a0bb33e5316cc114ac7c54bd3
Branches Tags
unspeaker:main
unspeaker:refactor/arranger-device
unspeaker:0.2
unspeaker:refactor/api
unspeaker:0.3.0-rc.1
unspeaker:0.2.2
unspeaker:0.2.1
unspeaker:0.2.0
unspeaker:test-release
unspeaker:0.2.0-rc.7
unspeaker:0.2.0-rc.6
unspeaker:0.2.0-rc.5
unspeaker:0.2.0-rc.4
unspeaker:0.2.0-rc.3
unspeaker:0.2.0-rc2
unspeaker:0.2.0-alpha1

1 commit
c0add81ff4 ... 0c97f68754

Author SHA1 Message Date
unspeaker
0c97f68754 wip: unified dsl_ns macro
Some checks are pending
/ build (push) Waiting to run
Details
2025-08-16 13:56:55 +03:00
8 changed files with 187 additions and 192 deletions
Download patch file Download diff file Expand all files Collapse all files

338
crates/app/app.rs
View file

@ -14,10 +14,7 @@
#![feature(type_alias_impl_trait)]
#![feature(trait_alias)]
#![feature(type_changing_struct_update)]
#![feature(let_chains)]
#![feature(closure_lifetime_binder)]
#![feature(generic_const_exprs)]
#![feature(generic_arg_infer)]
pub use ::tek_engine:: *;
pub use ::tek_device::{self, *};
pub use ::tengri::{Usually, Perhaps, Has, MaybeHas};
@ -38,7 +35,6 @@ use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::Relaxed};
use std::error::Error;
use std::collections::BTreeMap;
use std::fmt::Write;
use ::tengri::tui::ratatui::prelude::Position;
use xdg::BaseDirectories;
mod app_jack; pub use self::app_jack::*;
#[cfg(test)] mod app_test;
@ -214,19 +210,14 @@ impl App {
ViewCache::update_clock(&self.project.clock.view_cache, self.clock(), self.size.w() > 80)
}
}
fn render_dsl <'t, S> (state: &'t S, src: &str) -> Box<dyn Render<TuiOut>>
where S: DslSymNs<'t, Box<dyn Render<TuiOut>>> + DslExpNs<'t, Box<dyn Render<TuiOut>>>
{
let sym_err: Option<Box<dyn Error>> = match state.from_sym(src) {
Ok(Some(value)) => return value,
Ok(None) => None,
Err(e) => Some(e),
Ok(Some(value)) => return value, Ok(None) => None, Err(e) => Some(e),
};
let exp_err = match state.from_exp(src) {
Ok(Some(value)) => return value,
Ok(None) => None,
Err(e) => Some(e),
Ok(Some(value)) => return value, Ok(None) => None, Err(e) => Some(e),
};
let (err_fg_1, err_bg_1) = (Color::Rgb(240, 160, 100), Color::Rgb(48, 0, 0));
let (err_fg_2, err_bg_2) = (Color::Rgb(250, 200, 120), Color::Rgb(32, 0, 0));
@ -237,18 +228,20 @@ fn render_dsl <'t, S> (state: &'t S, src: &str) -> Box<dyn Render<TuiOut>>
Fill::x(Margin::x(1, Tui::fg_bg(err_fg_2, err_bg_2, format!("{exp_err:?}")))),
}))
}
dsl_exp_ns!(|app: App| -> Box<dyn Render<TuiOut>> {
dsl_ns!(|app: App| -> Box<dyn Render<TuiOut>> {
("bold", value: bool, x: Box<dyn Render<TuiOut>>) => Box::new(Tui::bold(value, x)),
("fg", color: Color, x: Box<dyn Render<TuiOut>>) => Box::new(Tui::fg(color, x)),
("bg", color: Color, x: Box<dyn Render<TuiOut>>) => Box::new(Tui::bg(color, x)),
("fg", color: Color, x: Box<dyn Render<TuiOut>>) => Box::new(Tui::fg(color, x)),
("bg", color: Color, x: Box<dyn Render<TuiOut>>) => Box::new(Tui::bg(color, x)),
("fg/bg", fg: Color, bg: Color, x: Box<dyn Render<TuiOut>>) => Box::new(Tui::fg_bg(fg, bg, x)),
("bsp/n", a: Box<dyn Render<TuiOut>>, b: Box<dyn Render<TuiOut>>) => Box::new(Bsp::n(a, b)),
("bsp/s", a: Box<dyn Render<TuiOut>>, b: Box<dyn Render<TuiOut>>) => Box::new(Bsp::s(a, b)),
("bsp/e", a: Box<dyn Render<TuiOut>>, b: Box<dyn Render<TuiOut>>) => Box::new(Bsp::e(a, b)),
("bsp/w", a: Box<dyn Render<TuiOut>>, b: Box<dyn Render<TuiOut>>) => Box::new(Bsp::w(a, b)),
("bsp/a", a: Box<dyn Render<TuiOut>>, b: Box<dyn Render<TuiOut>>) => Box::new(Bsp::a(a, b)),
("bsp/b", a: Box<dyn Render<TuiOut>>, b: Box<dyn Render<TuiOut>>) => Box::new(Bsp::b(a, b)),
("align/n", x: Box<dyn Render<TuiOut>>) => Box::new(Align::n(x)),
("align/s", x: Box<dyn Render<TuiOut>>) => Box::new(Align::s(x)),
("align/e", x: Box<dyn Render<TuiOut>>) => Box::new(Align::e(x)),
@ -256,36 +249,49 @@ dsl_exp_ns!(|app: App| -> Box<dyn Render<TuiOut>> {
("align/x", x: Box<dyn Render<TuiOut>>) => Box::new(Align::x(x)),
("align/y", x: Box<dyn Render<TuiOut>>) => Box::new(Align::y(x)),
("align/c", x: Box<dyn Render<TuiOut>>) => Box::new(Align::c(x)),
("fill/x", x: Box<dyn Render<TuiOut>>) => Box::new(Fill::x(x)),
("fill/y", x: Box<dyn Render<TuiOut>>) => Box::new(Fill::y(x)),
("fill/xy", x: Box<dyn Render<TuiOut>>) => Box::new(Fill::xy(x)),
});
dsl_exp_ns!(|app: App| -> Color {
("g", n: u8) =>
Color::Rgb(n, n, n),
("rgb", r: u8, g: u8, b: u8) =>
Color::Rgb(r, g, b),
});
("fixed/x", x: u16, c: Box<dyn Render<TuiOut>>) => Box::new(Fixed::x(x, c)),
("fixed/y", y: u16, c: Box<dyn Render<TuiOut>>) => Box::new(Fixed::y(y, c)),
("fixed/xy", x: u16, y: u16, c: Box<dyn Render<TuiOut>>) => Box::new(Fixed::xy(x, y, c)),
dsl_sym_ns!(|app: App| -> Box<dyn Render<TuiOut>> {
("min/x", x: u16, c: Box<dyn Render<TuiOut>>) => Box::new(Min::x(x, c)),
("min/y", y: u16, c: Box<dyn Render<TuiOut>>) => Box::new(Min::y(y, c)),
("min/xy", x: u16, y: u16, c: Box<dyn Render<TuiOut>>) => Box::new(Min::xy(x, y, c)),
":view/menu" => app.view(stringify!((bg (rgb 0 0 0)
(bsp/s :view/ports/outs (bsp/s (bg (rgb 33 33 33) (bold :true "tek 0.3.0-rc.0")))
(bsp/n :view/ports/ins (bsp/n (bg (rgb 33 33 33) (bsp/e (fg (rgb 255 192 48) "[Enter]") " new session"))
(align/n (fill/xy :view/modes)))))))),
":view/ports/outs" => app.view(stringify!((fill/x (fixed/y 3
(bsp/a (fill/x (align/w "L AUDIO OUT")
(bsp/a "MIDI OUT" (fill/x (align/e "AUDIO OUT R"))))))))),
":view/ports/ins" => app.view(stringify!(fill/x (fixed/y 3
(bsp/a (fill/x (align/w "L AUDIO IN ")
(bsp/a "MIDI IN " (fill/x (align/e "AUDIO IN R")))))))),
":view/browse" => app.view(stringify!(bsp/s
(padding/xy 3 1 :view/browse-title) (enclose (fg (g 96)) :view/browser))),
("max/x", x: u16, c: Box<dyn Render<TuiOut>>) => Box::new(Max::x(x, c)),
("max/y", y: u16, c: Box<dyn Render<TuiOut>>) => Box::new(Max::y(y, c)),
("max/xy", x: u16, y: u16, c: Box<dyn Render<TuiOut>>) => Box::new(Max::xy(x, y, c)),
":view/menu" =>
app.view(stringify!((bg (rgb 0 0 0)
(bsp/s :view/ports/outs (bsp/s (bg (rgb 33 33 33) (bold :true "tek 0.3.0-rc.0")))
(bsp/n :view/ports/ins (bsp/n (bg (rgb 33 33 33) (bsp/e (fg (rgb 255 192 48) "[Enter]") " new session"))
(align/n (fill/xy :view/modes)))))))),
":view/ports/outs" =>
app.view(stringify!((fill/x (fixed/y 3
(bsp/a (fill/x (align/w "L AUDIO OUT")
(bsp/a "MIDI OUT" (fill/x (align/e "AUDIO OUT R"))))))))),
":view/ports/ins" =>
app.view(stringify!(fill/x (fixed/y 3
(bsp/a (fill/x (align/w "L AUDIO IN ")
(bsp/a "MIDI IN " (fill/x (align/e "AUDIO IN R")))))))),
":view/browse" =>
app.view(stringify!(bsp/s
(padding/xy 3 1 :view/browse-title) (enclose (fg (g 96)) :view/browser))),
":view/browse/title" =>
Box::new(Fill::x(Align::w(FieldV(Default::default(),
match app.dialog.browser_target().unwrap() {
BrowserTarget::SaveProject => "Save project:",
BrowserTarget::LoadProject => "Load project:",
BrowserTarget::ImportSample(_) => "Import sample:",
BrowserTarget::ExportSample(_) => "Export sample:",
BrowserTarget::ImportClip(_) => "Import clip:",
BrowserTarget::ExportClip(_) => "Export clip:",
}, Shrink::x(3, Fixed::y(1, Tui::fg(Tui::g(96), RepeatH("🭻")))))))),
":view/modes" => Box::new({
let modes = app.config.modes.clone();
Stack::south(move|add: &mut dyn FnMut(&dyn Render<TuiOut>)|{
@ -299,19 +305,6 @@ dsl_sym_ns!(|app: App| -> Box<dyn Render<TuiOut>> {
//(fill/x (align/w #info))))))));
}
}) }),
":view/browse/title" => {
let title = match app.dialog.browser_target().unwrap() {
BrowserTarget::SaveProject => "Save project:",
BrowserTarget::LoadProject => "Load project:",
BrowserTarget::ImportSample(_) => "Import sample:",
BrowserTarget::ExportSample(_) => "Export sample:",
BrowserTarget::ImportClip(_) => "Import clip:",
BrowserTarget::ExportClip(_) => "Export clip:",
};
Box::new(Fill::x(Align::w(FieldV(Default::default(), title, Shrink::x(3, Fixed::y(1, Tui::fg(Tui::g(96), RepeatH("🭻"))))))))
},
":view/device" => {
let selected = app.dialog.device_kind().unwrap();
Box::new(Bsp::s(Tui::bold(true, "Add device"), Map::south(1,
@ -321,9 +314,13 @@ dsl_sym_ns!(|app: App| -> Box<dyn Render<TuiOut>> {
let lb = if i == selected { "[ " } else { " " };
let rb = if i == selected { " ]" } else { " " };
Fill::x(Tui::bg(bg, Bsp::e(lb, Bsp::w(rb, "FIXME device name")))) }))) },
//(":view/options", view_options),
});
dsl_ns!(|app: App| -> Color {
("g", n: u8) => Color::Rgb(n, n, n),
("rgb", r: u8, g: u8, b: u8) => Color::Rgb(r, g, b),
});
fn wrap_dialog (dialog: impl Content<TuiOut>) -> impl Content<TuiOut> {
Fixed::xy(70, 23, Tui::fg_bg(Rgb(255,255,255), Rgb(16,16,16), Bsp::b(
Repeat(" "), Outer(true, Style::default().fg(Tui::g(96))).enclose(dialog))))
@ -579,39 +576,39 @@ handle!(TuiIn:|self: App, input|{
//None
//})
});
dsl_sym_ns!(|app: App| -> isize {
":_isize_stub" => -1
});
dsl_sym_ns!(|app: App| -> ItemTheme {
":_theme_stub" => Default::default()
});
dsl_sym_ns!(|app: App| -> u16{
dsl_ns!(|app: App| -> u8
{ ":_u8_stub" => 1 });
dsl_ns!(|app: App| -> isize
{ ":_isize_stub" => -1 });
dsl_ns!(|app: App| -> ItemTheme
{ ":_theme_stub" => Default::default() });
dsl_ns!(|app: App| -> u16{
":w/sidebar" => app.project.w_sidebar(app.editor().is_some()),
":h/sample-detail" => 6.max(app.height() as u16 * 3 / 9),
});
dsl_sym_ns!(|app: App| -> usize {
dsl_ns!(|app: App| -> usize {
":scene-count" => app.scenes().len(),
":track-count" => app.tracks().len(),
":device-kind" => app.dialog.device_kind().unwrap_or(0),
":device-kind/next" => app.dialog.device_kind_next().unwrap_or(0),
":device-kind/prev" => app.dialog.device_kind_prev().unwrap_or(0),
});
dsl_sym_ns!(|app: App| -> bool {
dsl_ns!(|app: App| -> bool {
":focused/editor" => app.project.editor.is_some(),
":focused/dialog" => !matches!(app.dialog, Dialog::None),
":focused/message" => matches!(app.dialog, Dialog::Message(..)),
":focused/add_device" => matches!(app.dialog, Dialog::Device(..)),
":focused/browser" => app.dialog.browser().is_some(),
":focused/clip" => !app.focused_editor() && matches!(app.selection(), Selection::TrackClip{..}),
":focused/track" => !app.focused_editor() && matches!(app.selection(), Selection::Track(..)),
":focused/scene" => !app.focused_editor() && matches!(app.selection(), Selection::Scene(..)),
":focused/mix" => !app.focused_editor() && matches!(app.selection(), Selection::Mix),
":focused/clip" => !app.editor_focused() && matches!(app.selection(), Selection::TrackClip{..}),
":focused/track" => !app.editor_focused() && matches!(app.selection(), Selection::Track(..)),
":focused/scene" => !app.editor_focused() && matches!(app.selection(), Selection::Scene(..)),
":focused/mix" => !app.editor_focused() && matches!(app.selection(), Selection::Mix),
":focused/pool/import" => matches!(app.pool.mode, Some(PoolMode::Import(..))),
":focused/pool/export" => matches!(app.pool.mode, Some(PoolMode::Export(..))),
":focused/pool/rename" => matches!(app.pool.mode, Some(PoolMode::Rename(..))),
":focused/pool/length" => matches!(app.pool.mode, Some(PoolMode::Length(..))),
});
dsl_sym_ns!(|app: App| -> Dialog {
dsl_ns!(|app: App| -> Dialog {
":dialog/none" => Dialog::None,
":dialog/options" => Dialog::Options,
":dialog/device" => Dialog::Device(0),
@ -626,7 +623,7 @@ dsl_sym_ns!(|app: App| -> Dialog {
":dialog/import/sample" => Dialog::Browser(BrowserTarget::ImportSample(Default::default()), Browser::new(None).unwrap().into()),
":dialog/export/sample" => Dialog::Browser(BrowserTarget::ExportSample(Default::default()), Browser::new(None).unwrap().into()),
});
dsl_sym_ns!(|app: App| -> Selection {
dsl_ns!(|app: App| -> Selection {
":select/scene" => app.selection().select_scene(app.tracks().len()),
":select/scene/next" => app.selection().select_scene_next(app.scenes().len()),
":select/scene/prev" => app.selection().select_scene_prev(),
@ -634,14 +631,14 @@ dsl_sym_ns!(|app: App| -> Selection {
":select/track/next" => app.selection().select_track_next(app.tracks().len()),
":select/track/prev" => app.selection().select_track_prev(),
});
dsl_sym_ns!(|app: App| -> Option<u7> {
dsl_ns!(|app: App| -> Option<u7> {
":editor/pitch" => Some((app.editor().as_ref().map(|e|e.get_note_pos()).unwrap() as u8).into())
});
dsl_sym_ns!(|app: App| -> Option<usize> {
dsl_ns!(|app: App| -> Option<usize> {
":selected/scene" => app.selection().scene(),
":selected/track" => app.selection().track(),
});
dsl_sym_ns!(|app: App| -> Option<Arc<RwLock<MidiClip>>> {
dsl_ns!(|app: App| -> Option<Arc<RwLock<MidiClip>>> {
":selected/clip" => if let Selection::TrackClip { track, scene } = app.selection() {
app.scenes()[*scene].clips[*track].clone()
} else {
@ -649,9 +646,8 @@ dsl_sym_ns!(|app: App| -> Option<Arc<RwLock<MidiClip>>> {
}
});
#[derive(Debug)]
pub enum AppCommand {
}
dsl_exp_ns!(|app: App| -> AppCommand {
pub enum AppCommand { /* TODO */ }
dsl_ns!(|app: App| -> AppCommand {
("stop-all") => todo!(),//app.project.stop_all(),
("enqueue", clip: Option<Arc<RwLock<MidiClip>>>) => todo!(),
("history", delta: isize) => todo!(),
@ -664,14 +660,14 @@ dsl_exp_ns!(|app: App| -> AppCommand {
("pool" / command: PoolCommand) => todo!(),
("pool" / editor: MidiEditCommand) => todo!(),
});
dsl_exp_ns!(|app: App| -> DialogCommand {});
dsl_exp_ns!(|app: App| -> ArrangementCommand {});
dsl_exp_ns!(|app: App| -> ClockCommand {});
dsl_exp_ns!(|app: App| -> SamplerCommand {});
dsl_exp_ns!(|app: App| -> PoolCommand {});
dsl_exp_ns!(|app: App| -> MidiEditCommand {});
dsl_ns!(|app: App| -> DialogCommand {});
dsl_ns!(|app: App| -> ArrangementCommand {});
dsl_ns!(|app: App| -> ClockCommand {});
dsl_ns!(|app: App| -> SamplerCommand {});
dsl_ns!(|app: App| -> PoolCommand {});
dsl_ns!(|app: App| -> MidiEditCommand {});
impl App {
pub fn focused_editor (&self) -> bool {
pub fn editor_focused (&self) -> bool {
false
}
}
@ -698,97 +694,6 @@ impl Dialog {
todo!()
}
}
//dsl_bind!(AppCommand: App {
//enqueue = |app, clip: Option<Arc<RwLock<MidiClip>>>| { todo!() };
//history = |app, delta: isize| { todo!() };
//zoom = |app, zoom: usize| { todo!() };
//stop_all = |app| { app.tracks_stop_all(); Ok(None) };
////dialog = |app, command: DialogCommand|
////Ok(command.delegate(&mut app.dialog, |c|Self::Dialog{command: c})?);
//project = |app, command: ArrangementCommand|
//Ok(command.delegate(&mut app.project, |c|Self::Project{command: c})?);
//clock = |app, command: ClockCommand|
//Ok(command.execute(app.clock_mut())?.map(|c|Self::Clock{command: c}));
//sampler = |app, command: SamplerCommand|
//Ok(app.project.sampler_mut().map(|s|command.delegate(s, |command|Self::Sampler{command}))
//.transpose()?.flatten());
//pool = |app, command: PoolCommand| {
//let undo = command.clone().delegate(&mut app.pool, |command|AppCommand::Pool{command})?;
//// update linked editor after pool action
//match command {
//// autoselect: automatically load selected clip in editor
//PoolCommand::Select { .. } |
//// autocolor: update color in all places simultaneously
//PoolCommand::Clip { command: PoolClipCommand::SetColor { .. } } => {
//let clip = app.pool.clip().clone();
//app.editor_mut().map(|editor|editor.set_clip(clip.as_ref()))
//},
//_ => None
//};
//Ok(undo)
//};
//select = |app, selection: Selection| {
//*app.project.selection_mut() = selection;
////todo!
////if let Some(ref mut editor) = app.editor_mut() {
////editor.set_clip(match selection {
////Selection::TrackClip { track, scene } if let Some(Some(Some(clip))) = app
////.project
////.scenes.get(scene)
////.map(|s|s.clips.get(track))
////=>
////Some(clip),
////_ =>
////None
////});
////}
//Ok(None)
////("select" [t: usize, s: usize] Some(match (t.expect("no track"), s.expect("no scene")) {
////(0, 0) => Self::Select(Selection::Mix),
////(t, 0) => Self::Select(Selection::Track(t)),
////(0, s) => Self::Select(Selection::Scene(s)),
////(t, s) => Self::Select(Selection::TrackClip { track: t, scene: s }) })))
//// autoedit: load focused clip in editor.
//};
////fn color (app: &mut App, theme: ItemTheme) -> Perhaps<Self> {
////Ok(app.set_color(Some(theme)).map(|theme|Self::Color{theme}))
////}
////fn launch (app: &mut App) -> Perhaps<Self> {
////app.project.launch();
////Ok(None)
////}
//toggle_editor = |app, value: bool|{ app.toggle_editor(Some(value)); Ok(None) };
//editor = |app, command: MidiEditCommand| Ok(if let Some(editor) = app.editor_mut() {
//let undo = command.clone().delegate(editor, |command|AppCommand::Editor{command})?;
//// update linked sampler after editor action
//app.project.sampler_mut().map(|sampler|match command {
//// autoselect: automatically select sample in sampler
//MidiEditCommand::SetNotePos { pos } => { sampler.set_note_pos(pos); },
//_ => {}
//});
//undo
//} else {
//None
//});
//});
//take!(ClockCommand |state: App, iter|Take::take(state.clock(), iter));
//take!(MidiEditCommand |state: App, iter|Ok(state.editor().map(|x|Take::take(x, iter)).transpose()?.flatten()));
//take!(PoolCommand |state: App, iter|Take::take(&state.pool, iter));
//take!(SamplerCommand |state: App, iter|Ok(state.project.sampler().map(|x|Take::take(x, iter)).transpose()?.flatten()));
//take!(ArrangementCommand |state: App, iter|Take::take(&state.project, iter));
//take!(DialogCommand |state: App, iter|Take::take(&state.dialog, iter));
//has_editor!(|self: App|{
//editor = self.editor;
//editor_w = {
//let size = self.size.w();
//let editor = self.editor.as_ref().expect("missing editor");
//let time_len = editor.time_len().get();
//let time_zoom = editor.time_zoom().get().max(1);
//(5 + (time_len / time_zoom)).min(size.saturating_sub(20)).max(16)
//};
//editor_h = 15;
//is_editing = self.editor.is_some();
//});
#[tengri_proc::command(Option<Dialog>)] impl DialogCommand {
fn open (dialog: &mut Option<Dialog>, new: Dialog) -> Perhaps<Self> {
*dialog = Some(new);
@ -916,3 +821,94 @@ impl App {
//}
//}
//
//dsl_bind!(AppCommand: App {
//enqueue = |app, clip: Option<Arc<RwLock<MidiClip>>>| { todo!() };
//history = |app, delta: isize| { todo!() };
//zoom = |app, zoom: usize| { todo!() };
//stop_all = |app| { app.tracks_stop_all(); Ok(None) };
////dialog = |app, command: DialogCommand|
////Ok(command.delegate(&mut app.dialog, |c|Self::Dialog{command: c})?);
//project = |app, command: ArrangementCommand|
//Ok(command.delegate(&mut app.project, |c|Self::Project{command: c})?);
//clock = |app, command: ClockCommand|
//Ok(command.execute(app.clock_mut())?.map(|c|Self::Clock{command: c}));
//sampler = |app, command: SamplerCommand|
//Ok(app.project.sampler_mut().map(|s|command.delegate(s, |command|Self::Sampler{command}))
//.transpose()?.flatten());
//pool = |app, command: PoolCommand| {
//let undo = command.clone().delegate(&mut app.pool, |command|AppCommand::Pool{command})?;
//// update linked editor after pool action
//match command {
//// autoselect: automatically load selected clip in editor
//PoolCommand::Select { .. } |
//// autocolor: update color in all places simultaneously
//PoolCommand::Clip { command: PoolClipCommand::SetColor { .. } } => {
//let clip = app.pool.clip().clone();
//app.editor_mut().map(|editor|editor.set_clip(clip.as_ref()))
//},
//_ => None
//};
//Ok(undo)
//};
//select = |app, selection: Selection| {
//*app.project.selection_mut() = selection;
////todo!
////if let Some(ref mut editor) = app.editor_mut() {
////editor.set_clip(match selection {
////Selection::TrackClip { track, scene } if let Some(Some(Some(clip))) = app
////.project
////.scenes.get(scene)
////.map(|s|s.clips.get(track))
////=>
////Some(clip),
////_ =>
////None
////});
////}
//Ok(None)
////("select" [t: usize, s: usize] Some(match (t.expect("no track"), s.expect("no scene")) {
////(0, 0) => Self::Select(Selection::Mix),
////(t, 0) => Self::Select(Selection::Track(t)),
////(0, s) => Self::Select(Selection::Scene(s)),
////(t, s) => Self::Select(Selection::TrackClip { track: t, scene: s }) })))
//// autoedit: load focused clip in editor.
//};
////fn color (app: &mut App, theme: ItemTheme) -> Perhaps<Self> {
////Ok(app.set_color(Some(theme)).map(|theme|Self::Color{theme}))
////}
////fn launch (app: &mut App) -> Perhaps<Self> {
////app.project.launch();
////Ok(None)
////}
//toggle_editor = |app, value: bool|{ app.toggle_editor(Some(value)); Ok(None) };
//editor = |app, command: MidiEditCommand| Ok(if let Some(editor) = app.editor_mut() {
//let undo = command.clone().delegate(editor, |command|AppCommand::Editor{command})?;
//// update linked sampler after editor action
//app.project.sampler_mut().map(|sampler|match command {
//// autoselect: automatically select sample in sampler
//MidiEditCommand::SetNotePos { pos } => { sampler.set_note_pos(pos); },
//_ => {}
//});
//undo
//} else {
//None
//});
//});
//take!(ClockCommand |state: App, iter|Take::take(state.clock(), iter));
//take!(MidiEditCommand |state: App, iter|Ok(state.editor().map(|x|Take::take(x, iter)).transpose()?.flatten()));
//take!(PoolCommand |state: App, iter|Take::take(&state.pool, iter));
//take!(SamplerCommand |state: App, iter|Ok(state.project.sampler().map(|x|Take::take(x, iter)).transpose()?.flatten()));
//take!(ArrangementCommand |state: App, iter|Take::take(&state.project, iter));
//take!(DialogCommand |state: App, iter|Take::take(&state.dialog, iter));
//has_editor!(|self: App|{
//editor = self.editor;
//editor_w = {
//let size = self.size.w();
//let editor = self.editor.as_ref().expect("missing editor");
//let time_len = editor.time_len().get();
//let time_zoom = editor.time_zoom().get().max(1);
//(5 + (time_len / time_zoom)).min(size.saturating_sub(20)).max(16)
//};
//editor_h = 15;
//is_editing = self.editor.is_some();
//});

11
crates/cli/tek.rs
View file

@ -1,5 +1,4 @@
pub(crate) use tek::*;
pub(crate) use std::sync::{Arc, RwLock};
pub(crate) use clap::{self, Parser, Subcommand};
/// Application entrypoint.
@ -56,16 +55,16 @@ impl Cli {
let empty = &[] as &[&str];
let mut midi_ins = vec![];
let mut midi_outs = vec![];
let mut tracks = vec![];
let mut scenes = vec![];
let tracks = vec![];
let scenes = vec![];
let midi_froms = Connect::collect(&self.midi_from, empty, &self.midi_from_re);
let midi_tos = Connect::collect(&self.midi_to, empty, &self.midi_to_re);
let left_froms = Connect::collect(&self.left_from, empty, empty);
let left_tos = Connect::collect(&self.left_to, empty, empty);
let right_froms = Connect::collect(&self.right_from, empty, empty);
let right_tos = Connect::collect(&self.right_to, empty, empty);
let audio_froms = &[left_froms.as_slice(), right_froms.as_slice()];
let audio_tos = &[left_tos.as_slice(), right_tos.as_slice()];
let _audio_froms = &[left_froms.as_slice(), right_froms.as_slice()];
let _audio_tos = &[left_tos.as_slice(), right_tos.as_slice()];
Tui::new()?.run(&Jack::new_run(&name, move|jack|{
for (index, connect) in midi_froms.iter().enumerate() {
midi_ins.push(jack.midi_in(&format!("M/{index}"), &[connect.clone()])?);
@ -74,7 +73,7 @@ impl Cli {
midi_outs.push(jack.midi_out(&format!("{index}/M"), &[connect.clone()])?);
};
let clock = Clock::new(&jack, self.bpm)?;
let mut app = App {
let app = App {
config,
jack: jack.clone(),
color: ItemTheme::random(),

2
crates/device/src/arranger/arranger_scenes.rs
View file

@ -25,7 +25,7 @@ impl HasSceneScroll for Arrangement {
fn scene_scroll (&self) -> usize { self.scene_scroll }
}
pub type SceneWith<'a, T: Send + Sync> = (usize, &'a Scene, usize, usize, T);
pub type SceneWith<'a, T> = (usize, &'a Scene, usize, usize, T);
impl<T: HasScenes + HasTracks> AddScene for T {}

8
crates/device/src/arranger/arranger_tracks.rs
View file

@ -139,10 +139,10 @@ impl TrackCommand {
std::mem::swap(&mut color, &mut track.color);
Ok(Some(Self::SetColor { color }))
}
fn set_mute (track: &mut Track, value: Option<bool>) -> Perhaps<Self> {
fn set_mute (_track: &mut Track, _value: Option<bool>) -> Perhaps<Self> {
todo!()
}
fn set_solo (track: &mut Track, value: Option<bool>) -> Perhaps<Self> {
fn set_solo (_track: &mut Track, _value: Option<bool>) -> Perhaps<Self> {
todo!()
}
fn set_rec (track: &mut Track, value: Option<bool>) -> Perhaps<Self> {
@ -155,10 +155,10 @@ impl TrackCommand {
let value = value.unwrap_or(!current);
Ok((value != current).then_some(Self::SetRec { value: Some(current) }))
}
fn set_size (track: &mut Track, size: usize) -> Perhaps<Self> {
fn set_size (_track: &mut Track, _size: usize) -> Perhaps<Self> {
todo!()
}
fn set_zoom (track: &mut Track, zoom: usize) -> Perhaps<Self> {
fn set_zoom (_track: &mut Track, _zoom: usize) -> Perhaps<Self> {
todo!()
}
fn stop (track: &mut Track) -> Perhaps<Self> {

6
crates/device/src/clock/clock_view.rs
View file

@ -63,11 +63,11 @@ pub(crate) fn button_play_pause (playing: bool) -> impl Content<TuiOut> {
impl Default for ViewCache {
fn default () -> Self {
let mut beat = String::with_capacity(16);
write!(beat, "{}", Self::BEAT_EMPTY);
let _ = write!(beat, "{}", Self::BEAT_EMPTY);
let mut time = String::with_capacity(16);
write!(time, "{}", Self::TIME_EMPTY);
let _ = write!(time, "{}", Self::TIME_EMPTY);
let mut bpm = String::with_capacity(16);
write!(bpm, "{}", Self::BPM_EMPTY);
let _ = write!(bpm, "{}", Self::BPM_EMPTY);
Self {
beat: Memo::new(None, beat),
time: Memo::new(None, time),

10
crates/device/src/pool/pool_api.rs
View file

@ -127,7 +127,7 @@ impl PoolClipCommand {
Ok(Self::Add { index, clip }.execute(pool)?)
}
fn export (pool: &mut Pool, index: usize, path: PathBuf) -> Perhaps<Self> {
fn export (_pool: &mut Pool, _index: usize, _path: PathBuf) -> Perhaps<Self> {
todo!("export clip to midi file");
}
@ -155,7 +155,7 @@ impl PoolClipCommand {
#[tengri_proc::command(Pool)]
impl RenameCommand {
fn begin (pool: &mut Pool) -> Perhaps<Self> {
fn begin (_pool: &mut Pool) -> Perhaps<Self> {
unreachable!();
}
fn cancel (pool: &mut Pool) -> Perhaps<Self> {
@ -165,7 +165,7 @@ impl RenameCommand {
return Ok(None)
}
fn confirm (pool: &mut Pool) -> Perhaps<Self> {
if let Some(PoolMode::Rename(clip, ref mut old_name)) = pool.mode_mut().clone() {
if let Some(PoolMode::Rename(_clip, ref mut old_name)) = pool.mode_mut().clone() {
let old_name = old_name.clone();
*pool.mode_mut() = None;
return Ok(Some(Self::Set { value: old_name }))
@ -173,7 +173,7 @@ impl RenameCommand {
return Ok(None)
}
fn set (pool: &mut Pool, value: Arc<str>) -> Perhaps<Self> {
if let Some(PoolMode::Rename(clip, ref mut old_name)) = pool.mode_mut().clone() {
if let Some(PoolMode::Rename(clip, ref mut _old_name)) = pool.mode_mut().clone() {
pool.clips()[clip].write().unwrap().name = value;
}
return Ok(None)
@ -182,7 +182,7 @@ impl RenameCommand {
#[tengri_proc::command(Pool)]
impl CropCommand {
fn begin (pool: &mut Pool) -> Perhaps<Self> {
fn begin (_pool: &mut Pool) -> Perhaps<Self> {
unreachable!()
}
fn cancel (pool: &mut Pool) -> Perhaps<Self> {

2
crates/device/src/sampler/sampler_api.rs
View file

@ -52,7 +52,7 @@ impl Sampler {
impl SamplerCommand {
fn record_toggle (sampler: &mut Sampler, slot: usize) -> Perhaps<Self> {
let recording = sampler.recording.as_ref().map(|x|x.0);
Self::record_finish(sampler);
Self::record_finish(sampler)?;
// autoslice: continue recording at next slot
if recording != Some(slot) {
Self::record_begin(sampler, slot)

2
deps/tengri vendored

@ -1 +1 @@
Subproject commit d7884f6289ac6c7a88f806f4453fb7c246c87f0b
Subproject commit 4c312ac8d75f9c6d1579e3882f7aba68a16a0f69