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

api: compact

Browse source
This commit is contained in:
🪞👃🪞 2025-04-26 21:20:06 +03:00
parent e4808f8fc1
commit 3ef3d5eb6f
22 changed files with 441 additions and 558 deletions
Download patch file Download diff file Expand all files Collapse all files

2
crates/app/edn/groovebox_keys.edn
View file

@ -11,4 +11,4 @@
(@q launch)
(@r record/begin :note-pos)
(@r sampler record/begin :pitch)

507
crates/app/src/api.rs
View file

@ -1,174 +1,181 @@
use crate::*;
expose!([self: Tek] {
[bool] => {}
[isize] => {}
[Color] => {}
[Arc<RwLock<MidiClip>>] => {}
[u16] => { ":w-sidebar" => self.w_sidebar(), }
[usize] => { ":scene-last" => self.scenes.len(),
":track-last" => self.tracks.len(), }
[Option<usize>] => { ":scene" => self.selected.scene(),
":track" => self.selected.track(), }
[Option<Arc<RwLock<MidiClip>>>] => {
":clip" => match self.selected {
Selection::Clip(t, s) => self.scenes[s].clips[t].clone(),
_ => None
}
}
[Selection] => {
":scene-next" => self.selected.scene_next(self.scenes.len()),
":scene-prev" => self.selected.scene_prev(),
":track-next" => self.selected.track_next(self.tracks.len()),
":track-prev" => self.selected.track_prev(),
}
type MaybeClip = Option<Arc<RwLock<MidiClip>>>;
macro_rules! ns { ($C:ty, $s:expr, $a:expr, $W:expr) => { <$C>::try_from_expr($s, $a).map($W) } }
macro_rules! cmd { ($cmd:expr) => {{ $cmd; None }}; }
macro_rules! cmd_todo { ($msg:literal) => {{ println!($msg); None }}; }
view!(TuiOut: |self: Tek| self.size.of(View(self, self.view)); {
":nil" => Box::new("nil"),
":modal" => self.view_modal(),
":status" => self.view_status(),
":transport" => self.view_transport(),
":arranger" => self.view_arranger(),
":pool" => self.view_pool(),
":editor" => self.editor().map(|e|Bsp::n(Bsp::e(e.clip_status(), e.edit_status()), e)),
":samples-keys" => self.sampler().map(|s|s.view_list(false, self.editor().unwrap())),
":samples-grid" => self.sampler().map(|s|s.view_grid()),
":sample-viewer" => self.sampler().map(|s|s.view_sample(self.editor().unwrap().note_pos())),
});
impose!([app: Tek] {
expose!([self: Tek]
([bool])
([isize])
([Color])
([Arc<RwLock<MidiClip>>])
([u7] (":pitch" (self.editor().map(|e|e.note_pos()).unwrap() as u8).into()))
([u16] (":w-sidebar" self.w_sidebar()))
([usize] (":scene-last" self.scenes.len())
(":track-last" self.tracks.len()))
([Option<usize>] (":scene" self.selected.scene())
(":track" self.selected.track()))
([MaybeClip]
(":clip" match self.selected {
Selection::Clip(t, s) => self.scenes[s].clips[t].clone(),
_ => None
}))
([Selection]
(":scene-next" self.selected.scene_next(self.scenes.len()))
(":scene-prev" self.selected.scene_prev())
(":track-next" self.selected.track_next(self.tracks.len()))
(":track-prev" self.selected.track_prev())));
TekCommand => {
impose!([app: Tek]
(TekCommand:
("menu" [] Some(Self::ToggleMenu))
("help" [] Some(Self::ToggleHelp))
("stop" [] Some(Self::StopAll))
("undo" [d: usize] Some(Self::History(-(d.unwrap_or(0)as isize))))
("undo" [d: usize] Some(Self::History(-(d.unwrap_or(0) as isize))))
("redo" [d: usize] Some(Self::History(d.unwrap_or(0) as isize)))
("zoom" [z: usize] Some(Self::Zoom(z)))
("edit" [] Some(Self::Edit(None)))
("edit" [c: bool] Some(Self::Edit(c)))
("color" [] Some(Self::Color(ItemPalette::random())))
("color" [c: Color] Some(Self::Color(c.map(ItemPalette::from).expect("no color"))))
("color" [] Some(Self::Color(ItemTheme::random())))
("color" [c: Color] Some(Self::Color(c.map(ItemTheme::from).expect("no color"))))
("enqueue" [c: Arc<RwLock<MidiClip>>] Some(Self::Enqueue(c)))
("launch" [] Some(Self::Launch))
("scene" [,..a] SceneCommand::try_from_expr(app, a).map(Self::Scene))
("track" [,..a] TrackCommand::try_from_expr(app, a).map(Self::Track))
("input" [,..a] InputCommand::try_from_expr(app, a).map(Self::Input))
("output" [,..a] OutputCommand::try_from_expr(app, a).map(Self::Output))
("select" [t: Selection] Some(t.map(Self::Select).expect("no selection")))
("clip" [,..a] ClipCommand::try_from_expr(app, a)
.map(Self::Clip))
("clock" [,..a] ClockCommand::try_from_expr(app.clock(), a)
.map(Self::Clock))
("editor" [,..a] MidiEditCommand::try_from_expr(app.editor.as_ref().expect("no editor"), a)
.map(Self::Editor))
("pool" [,..a] PoolCommand::try_from_expr(app.pool.as_ref().expect("no pool"), a)
.map(Self::Pool))
("clock" [,..a] ns!(ClockCommand, app.clock(), a, Self::Clock))
("scene" [,..a] ns!(SceneCommand, app, a, Self::Scene))
("track" [,..a] ns!(TrackCommand, app, a, Self::Track))
("input" [,..a] ns!(InputCommand, app, a, Self::Input))
("output" [,..a] ns!(OutputCommand, app, a, Self::Output))
("clip" [,..a] ns!(ClipCommand, app, a, Self::Clip))
("pool" [,..a] app.pool.as_ref().map(|p|ns!(PoolCommand, p, a, Self::Pool)).flatten())
("editor" [,..a] app.editor().map(|e|ns!(MidiEditCommand, e, a, Self::Editor)).flatten())
("sampler" [,..a] app.sampler().map(|s|ns!(SamplerCommand, s, a, Self::Sampler)).flatten())
("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::Clip(t, s)),
}))
//("sampler" [,..a]
// Self::Sampler( //SamplerCommand::try_from_expr(app.sampler().as_ref().expect("no sampler"), a).expect("invalid command")))
}
ClipCommand => {
("get" [a: usize, b: usize] Some(Self::Get(a.unwrap(), b.unwrap())))
("put" [a: usize, b: usize, c: Option<Arc<RwLock<MidiClip>>>] Some(Self::Put(a.unwrap(), b.unwrap(), c.unwrap())))
(t, s) => Self::Select(Selection::Clip(t, s)) })))
(ClipCommand:
("edit" [a: MaybeClip] Some(Self::Edit(a.unwrap())))
("color" [a: usize, b: usize] Some(Self::SetColor(a.unwrap(), b.unwrap(), ItemTheme::random())))
("enqueue" [a: usize, b: usize] Some(Self::Enqueue(a.unwrap(), b.unwrap())))
("edit" [a: Option<Arc<RwLock<MidiClip>>>] Some(Self::Edit(a.unwrap())))
("get" [a: usize, b: usize] Some(Self::Get(a.unwrap(), b.unwrap())))
("loop" [a: usize, b: usize, c: bool] Some(Self::SetLoop(a.unwrap(), b.unwrap(), c.unwrap())))
("color" [a: usize, b: usize] Some(Self::SetColor(a.unwrap(), b.unwrap(), ItemPalette::random())))
}
("put" [a: usize, b: usize, c: MaybeClip] Some(Self::Put(a.unwrap(), b.unwrap(), c.unwrap()))))
InputCommand => {
("add" [] Some(Self::Add))
}
(InputCommand:
("add" [] Some(Self::Add)))
OutputCommand => {
("add" [] Some(Self::Add))
}
(OutputCommand:
("add" [] Some(Self::Add)))
SceneCommand => {
(SceneCommand:
("add" [] Some(Self::Add))
("del" [a: usize] Some(Self::Del(0)))
("zoom" [a: usize] Some(Self::SetZoom(a.unwrap())))
("color" [a: usize] Some(Self::SetColor(a.unwrap(), ItemPalette::G[128])))
("color" [a: usize] Some(Self::SetColor(a.unwrap(), ItemTheme::G[128])))
("enqueue" [a: usize] Some(Self::Enqueue(a.unwrap())))
("swap" [a: usize, b: usize] Some(Self::Swap(a.unwrap(), b.unwrap())))
}
("swap" [a: usize, b: usize] Some(Self::Swap(a.unwrap(), b.unwrap()))))
TrackCommand => {
(TrackCommand:
("add" [] Some(Self::Add))
("size" [a: usize] Some(Self::SetSize(a.unwrap())))
("zoom" [a: usize] Some(Self::SetZoom(a.unwrap())))
("color" [a: usize] Some(Self::SetColor(a.unwrap(), ItemPalette::random())))
("color" [a: usize] Some(Self::SetColor(a.unwrap(), ItemTheme::random())))
("del" [a: usize] Some(Self::Del(a.unwrap())))
("stop" [a: usize] Some(Self::Stop(a.unwrap())))
("swap" [a: usize, b: usize] Some(Self::Swap(a.unwrap(), b.unwrap())))
("play" [] Some(Self::TogglePlay))
("solo" [] Some(Self::ToggleSolo))
("rec" [] Some(Self::ToggleRecord))
("mon" [] Some(Self::ToggleMonitor))
}
("rec" [] Some(Self::ToggleRec))
("mon" [] Some(Self::ToggleMon))));
});
defcom!([self, app: Tek]
defcom! { |self, app: Tek|
(TekCommand
(Sampler [cmd: SamplerCommand] cmd_todo!("\n\rtodo: sampler {cmd:?}"))
(Scene [cmd: SceneCommand] cmd.delegate(app, Self::Scene)?)
(Track [cmd: TrackCommand] cmd.delegate(app, Self::Track)?)
(Output [cmd: OutputCommand] cmd.delegate(app, Self::Output)?)
(Input [cmd: InputCommand] cmd.delegate(app, Self::Input)?)
(Clip [cmd: ClipCommand] cmd.delegate(app, Self::Clip)?)
(Clock [cmd: ClockCommand] cmd.delegate(app, Self::Clock)?)
(Editor [cmd: MidiEditCommand] delegate_to_editor(app, cmd)?)
(Pool [cmd: PoolCommand] delegate_to_pool(app, cmd)?)
(ToggleHelp [] cmd!({ app.modal = match app.modal { Some(Modal::Help) => None, _ => Some(Modal::Help) }}))
(ToggleMenu [] cmd!({ app.modal = match app.modal { Some(Modal::Menu) => None, _ => Some(Modal::Menu) }}))
(Color [p: ItemTheme] app.set_color(Some(p)).map(Self::Color))
(Enqueue [c: MaybeClip] cmd_todo!("\n\rtodo: enqueue {c:?}"))
(History [d: isize] cmd_todo!("\n\rtodo: history {d:?}"))
(Zoom [z: Option<usize>] cmd_todo!("\n\rtodo: zoom {z:?}"))
(Edit [value: Option<bool>] cmd!(app.toggle_editor(value)))
(Launch [] cmd!(app.launch()))
(Select [s: Selection] cmd!(app.select(s)))
(StopAll [] cmd!(app.stop_all())))
TekCommand {
(InputCommand
(Add [] cmd!(app.add_midi_in()?)))
ToggleHelp => {
app.modal = match app.modal {
Some(Modal::Help) => None,
_ => Some(Modal::Help)
};
None
}
(OutputCommand
(Add [] cmd!(app.add_midi_out()?)))
ToggleMenu => {
app.modal = match app.modal {
Some(Modal::Menu) => None,
_ => Some(Modal::Menu)
};
None
}
(TrackCommand
(TogglePlay [] Some(Self::TogglePlay))
(ToggleSolo [] Some(Self::ToggleSolo))
(SetSize [t: usize] cmd_todo!("\n\rtodo: {self:?}"))
(SetZoom [z: usize] cmd_todo!("\n\rtodo: {self:?}"))
(Swap [a: usize, b: usize] cmd_todo!("\n\rtodo: {self:?}"))
(Del [index: usize] cmd!(app.track_del(index)))
(Stop [index: usize] cmd!(app.tracks[index].player.enqueue_next(None)))
(Add [] Some(Self::Del(app.track_add_focus()?)))
(SetColor [i: usize, c: ItemTheme] Some(Self::SetColor(i, app.track_set_color(i, c))))
(ToggleRec [] { app.track_toggle_record(); Some(Self::ToggleRec) })
(ToggleMon [] { app.track_toggle_monitor(); Some(Self::ToggleMon) }))
Sampler(cmd: SamplerCommand) => {
println!("\n\rtodo: {cmd:?}");
None
}
(SceneCommand
(Swap [a: usize, b: usize] cmd_todo!("\n\rtodo: {self:?}"))
(SetSize [index: usize] cmd_todo!("\n\rtodo: {self:?}"))
(SetZoom [zoom: usize] cmd_todo!("\n\rtodo: {self:?}"))
(Enqueue [scene: usize] cmd!(app.scene_enqueue(scene)))
(Del [index: usize] cmd!(app.scene_del(index)))
(Add [] Some(Self::Del(app.scene_add_focus()?)))
(SetColor [i: usize, c: ItemTheme] Some(Self::SetColor(i, app.scene_set_color(i, c)))))
Enqueue(clip: Option<Arc<RwLock<MidiClip>>>) => {
println!("\n\rtodo: enqueue {clip:?}");
None
}
(ClipCommand
(Get [a: usize, b: usize] cmd_todo!("\n\rtodo: clip: get: {a} {b}"))
(Edit [clip: MaybeClip] cmd_todo!("\n\rtodo: clip: edit: {clip:?}"))
(SetLoop [t: usize, s: usize, l: bool] cmd_todo!("\n\rtodo: {self:?}"))
(Put [t: usize, s: usize, c: MaybeClip]
Some(Self::Put(t, s, app.clip_put(t, s, c))))
(Enqueue [t: usize, s: usize]
cmd!(app.tracks[t].player.enqueue_next(app.scenes[s].clips[t].as_ref())))
(SetColor [t: usize, s: usize, c: ItemTheme]
app.clip_set_color(t, s, c).map(|o|Self::SetColor(t, s, o)))));
History(delta: isize) => {
println!("\n\rtodo: {self:?}");
None
}
Zoom(zoom: Option<usize>) => {
println!("\n\rtodo: {self:?}");
None
}
Scene(cmd: SceneCommand) =>
cmd.delegate(app, Self::Scene)?
Track(cmd: TrackCommand) =>
cmd.delegate(app, Self::Track)?
Output(cmd: OutputCommand) =>
cmd.delegate(app, Self::Output)?
Input(cmd: InputCommand) =>
cmd.delegate(app, Self::Input)?
Clip(cmd: ClipCommand) =>
cmd.delegate(app, Self::Clip)?
Clock(cmd: ClockCommand) =>
cmd.delegate(app, Self::Clock)?
Editor(cmd: MidiEditCommand) => app.editor.as_mut()
.map(|editor|cmd.delegate(editor, Self::Editor))
fn delegate_to_editor (app: &mut Tek, cmd: MidiEditCommand) -> Perhaps<TekCommand> {
Ok(app.editor.as_mut().map(|editor|cmd.delegate(editor, TekCommand::Editor))
.transpose()?
.flatten()
.flatten())
}
Pool(cmd: PoolCommand) => if let Some(pool) = app.pool.as_mut() {
let undo = cmd.clone().delegate(pool, Self::Pool)?;
fn delegate_to_pool (app: &mut Tek, cmd: PoolCommand) -> Perhaps<TekCommand> {
Ok(if let Some(pool) = app.pool.as_mut() {
let undo = cmd.clone().delegate(pool, TekCommand::Pool)?;
if let Some(editor) = app.editor.as_mut() {
match cmd {
// autoselect: automatically load selected clip in editor
@ -181,257 +188,5 @@ defcom! { |self, app: Tek|
undo
} else {
None
}
Color(palette: ItemPalette) => {
use Selection::*;
Some(Self::Color(match app.selected {
Mix => {
let old = app.color;
app.color = palette;
old
},
Track(t) => {
let old = app.tracks[t].color;
app.tracks[t].color = palette;
old
}
Scene(s) => {
let old = app.scenes[s].color;
app.scenes[s].color = palette;
old
}
Clip(t, s) => {
if let Some(ref clip) = app.scenes[s].clips[t] {
let mut clip = clip.write().unwrap();
let old = clip.color;
clip.color = palette;
old
} else {
return Ok(None)
}
}
}))
}
Edit(value: Option<bool>) => {
let editing = app.is_editing();
let value = value.unwrap_or_else(||!app.is_editing());
app.editing.store(value, Relaxed);
if value {
app.clip_auto_create();
} else {
app.clip_auto_remove();
}
None
}
Launch => {
use Selection::*;
match app.selected {
Track(t) => app.tracks[t].player.enqueue_next(None),
Clip(t, s) => app.tracks[t].player.enqueue_next(app.scenes[s].clips[t].as_ref()),
Scene(s) => {
for t in 0..app.tracks.len() {
app.tracks[t].player.enqueue_next(app.scenes[s].clips[t].as_ref())
}
},
_ => {}
};
None
}
Select(s: Selection) => {
app.selected = s;
// autoedit: load focused clip in editor.
if let Some(ref mut editor) = app.editor {
editor.set_clip(match app.selected {
Selection::Clip(t, s) if let Some(Some(Some(clip))) = app
.scenes.get(s).map(|s|s.clips.get(t)) => Some(clip),
_ => None
});
}
None
}
StopAll => {
for track in 0..app.tracks.len(){app.tracks[track].player.enqueue_next(None);}
None
}
}
InputCommand {
Add => {
app.midi_ins.push(JackMidiIn::new(&app.jack, &format!("M/{}", app.midi_ins.len()), &[])?);
None
}
}
OutputCommand {
Add => {
app.midi_outs.push(JackMidiOut::new(&app.jack, &format!("{}/M", app.midi_outs.len()), &[])?);
None
}
}
TrackCommand {
Swap(a: usize, b: usize) => {
println!("\n\rtodo: {self:?}");
None
}
SetSize(t: usize) => {
println!("\n\rtodo: {self:?}");
None
}
SetZoom(z: usize) => {
println!("\n\rtodo: {self:?}");
None
}
Add => {
use Selection::*;
let index = app.track_add(None, None, &[], &[])?.0;
app.selected = match app.selected {
Track(t) => Track(index),
Clip(t, s) => Clip(index, s),
_ => app.selected
};
Some(Self::Del(index))
}
Del(index: usize) => {
app.track_del(index);
None
}
Stop(index: usize) => {
app.tracks[index].player.enqueue_next(None);
None
}
SetColor(index: usize, color: ItemPalette) => {
let old = app.tracks[index].color;
app.tracks[index].color = color;
Some(Self::SetColor(index, old))
}
TogglePlay => {
Some(Self::TogglePlay)
}
ToggleSolo => {
Some(Self::ToggleSolo)
}
ToggleRecord => {
if let Some(t) = app.selected.track() {
app.tracks[t-1].player.recording = !app.tracks[t-1].player.recording;
}
Some(Self::ToggleRecord)
}
ToggleMonitor => {
if let Some(t) = app.selected.track() {
app.tracks[t-1].player.monitoring = !app.tracks[t-1].player.monitoring;
}
Some(Self::ToggleMonitor)
}
}
SceneCommand {
Swap(a: usize, b: usize) => {
println!("\n\rtodo: {self:?}");
None
}
SetSize(index: usize) => {
println!("\n\rtodo: {self:?}");
None
}
SetZoom(zoom: usize) => {
println!("\n\rtodo: {self:?}");
None
}
Add => {
use Selection::*;
let index = app.scene_add(None, None)?.0;
app.selected = match app.selected {
Scene(s) => Scene(index),
Clip(t, s) => Clip(t, index),
_ => app.selected
};
Some(Self::Del(index))
}
Del(index: usize) => {
app.scene_del(index);
None
}
SetColor(index: usize, color: ItemPalette) => {
let old = app.scenes[index].color;
app.scenes[index].color = color;
Some(Self::SetColor(index, old))
}
Enqueue(scene: usize) => {
for track in 0..app.tracks.len() {
app.tracks[track].player.enqueue_next(app.scenes[scene].clips[track].as_ref());
}
None
}
}
ClipCommand {
Get(a: usize, b: usize) => {
println!("\n\rtodo: {self:?}");
None
}
Edit(clip: Option<Arc<RwLock<MidiClip>>>) => {
println!("\n\rtodo: edit {clip:?}");
None
}
SetLoop(track: usize, scene: usize, looped: bool) => {
println!("\n\rtodo: {self:?}");
None
}
Put(track: usize, scene: usize, clip: Option<Arc<RwLock<MidiClip>>>) => {
let old = app.scenes[scene].clips[track].clone();
app.scenes[scene].clips[track] = clip;
Some(Self::Put(track, scene, old))
}
Enqueue(track: usize, scene: usize) => {
app.tracks[track].player.enqueue_next(app.scenes[scene].clips[track].as_ref());
None
}
SetColor(track: usize, scene: usize, color: ItemPalette) => {
app.scenes[scene].clips[track].as_ref().map(|clip|{
let mut clip = clip.write().unwrap();
let old = clip.color.clone();
clip.color = color.clone();
panic!("{color:?} {old:?}");
Self::SetColor(track, scene, old)
})
}
}
}

1
crates/app/src/device.rs
View file

@ -1 +0,0 @@
use crate::*;

2
crates/app/src/lib.rs
View file

@ -38,7 +38,6 @@ pub(crate) use std::sync::{Arc, RwLock, atomic::{AtomicBool, Ordering::Relaxed}}
mod api; pub use self::api::*;
mod audio; pub use self::audio::*;
mod device; pub use self::device::*;
mod model; pub use self::model::*;
mod view; pub use self::view::*;
mod keys; pub use self::keys::*;
@ -47,7 +46,6 @@ mod keys; pub use self::keys::*;
let mut tek = Tek::default();
let _ = tek.clip();
let _ = tek.toggle_loop();
let _ = tek.activate();
}
#[cfg(test)] #[test] fn test_model_scene () {
let mut app = Tek::default();

230
crates/app/src/model.rs
View file

@ -7,7 +7,7 @@ pub struct Tek {
/// Source of time
pub clock: Clock,
/// Theme
pub color: ItemPalette,
pub color: ItemTheme,
/// Contains all clips in the project
pub pool: Option<MidiPool>,
/// Contains the currently edited MIDI clip
@ -63,15 +63,15 @@ impl Tek {
&mut self,
count: usize,
width: Option<usize>,
midi_from: &[PortConnect],
midi_to: &[PortConnect],
mins: &[PortConnect],
mouts: &[PortConnect],
) -> Usually<()> {
let jack = self.jack().clone();
let track_color_1 = ItemColor::random();
let track_color_2 = ItemColor::random();
for i in 0..count {
let color = track_color_1.mix(track_color_2, i as f32 / count as f32).into();
let mut track = self.track_add(None, Some(color), midi_from, midi_to)?.1;
let mut track = self.track_add(None, Some(color), mins, mouts)?.1;
if let Some(width) = width {
track.width = width;
}
@ -83,21 +83,16 @@ impl Tek {
pub fn track_add (
&mut self,
name: Option<&str>,
color: Option<ItemPalette>,
midi_froms: &[PortConnect],
midi_tos: &[PortConnect],
color: Option<ItemTheme>,
mins: &[PortConnect],
mouts: &[PortConnect],
) -> Usually<(usize, &mut Track)> {
let name = name.map_or_else(||self.track_next_name(), |x|x.to_string().into());
let mut track = Track {
width: (name.len() + 2).max(12),
color: color.unwrap_or_else(ItemPalette::random),
color: color.unwrap_or_else(ItemTheme::random),
player: MidiPlayer::new(
&format!("{name}"),
self.jack(),
Some(self.clock()),
None,
midi_froms,
midi_tos
&format!("{name}"), self.jack(), Some(self.clock()), None, mins, mouts
)?,
name,
..Default::default()
@ -113,6 +108,17 @@ impl Tek {
Ok((index, &mut self.tracks_mut()[index]))
}
/// Add and focus a track
pub(crate) fn track_add_focus (&mut self) -> Usually<usize> {
let index = self.track_add(None, None, &[], &[])?.0;
self.selected = match self.selected {
Selection::Track(t) => Selection::Track(index),
Selection::Clip(t, s) => Selection::Clip(index, s),
_ => self.selected
};
Ok(index)
}
/// Delete a track
pub fn track_del (&mut self, index: usize) {
self.tracks_mut().remove(index);
@ -134,22 +140,46 @@ impl Tek {
}
/// Add a scene
pub fn scene_add (&mut self, name: Option<&str>, color: Option<ItemPalette>)
pub fn scene_add (&mut self, name: Option<&str>, color: Option<ItemTheme>)
-> Usually<(usize, &mut Scene)>
{
let scene = Scene {
name: name.map_or_else(||self.scene_default_name(), |x|x.to_string().into()),
clips: vec![None;self.tracks().len()],
color: color.unwrap_or_else(ItemPalette::random),
color: color.unwrap_or_else(ItemTheme::random),
};
self.scenes_mut().push(scene);
let index = self.scenes().len() - 1;
Ok((index, &mut self.scenes_mut()[index]))
}
/// Generate the default name for a new scene
pub fn scene_default_name (&self) -> Arc<str> {
format!("Sc{:3>}", self.scenes().len() + 1).into()
/// Add and focus an empty scene
pub fn scene_add_focus (&mut self) -> Usually<usize> {
let index = self.scene_add(None, None)?.0;
self.selected = match self.selected {
Selection::Scene(s) => Selection::Scene(index),
Selection::Clip(t, s) => Selection::Clip(t, index),
_ => self.selected
};
Ok(index)
}
/// Enqueue clips from a scene across all tracks
pub fn scene_enqueue (&mut self, scene: usize) {
for track in 0..self.tracks.len() {
self.tracks[track].player.enqueue_next(self.scenes[scene].clips[track].as_ref());
}
}
pub fn toggle_editor (&mut self, value: Option<bool>) {
let editing = self.is_editing();
let value = value.unwrap_or_else(||!self.is_editing());
self.editing.store(value, Relaxed);
if value {
self.clip_auto_create();
} else {
self.clip_auto_remove();
}
}
// Create new clip in pool when entering empty cell
@ -194,11 +224,43 @@ impl Tek {
}
}
/// Put a clip in a slot
pub(crate) fn clip_put (
&mut self, track: usize, scene: usize, clip: Option<Arc<RwLock<MidiClip>>>
) -> Option<Arc<RwLock<MidiClip>>> {
let old = self.scenes[scene].clips[track].clone();
self.scenes[scene].clips[track] = clip;
old
}
/// Change the color of a clip, returning the previous one
pub(crate) fn clip_set_color (
&self, track: usize, scene: usize, color: ItemTheme
) -> Option<ItemTheme> {
self.scenes[scene].clips[track].as_ref().map(|clip|{
let mut clip = clip.write().unwrap();
let old = clip.color.clone();
clip.color = color.clone();
panic!("{color:?} {old:?}");
old
})
}
/// Get the clip pool, if present
pub(crate) fn pool (&self) -> Option<&MidiPool> {
self.pool.as_ref()
}
/// Get the active clip
pub(crate) fn clip (&self) -> Option<Arc<RwLock<MidiClip>>> {
self.scene()?.clips.get(self.selected().track()?)?.clone()
}
/// Get the active editor
pub(crate) fn editor (&self) -> Option<&MidiEditor> {
self.editor.as_ref()
}
/// Toggle looping for the active clip
pub(crate) fn toggle_loop (&mut self) {
if let Some(clip) = self.clip() {
@ -206,30 +268,88 @@ impl Tek {
}
}
/// Set the selection
pub(crate) fn select (&mut self, s: Selection) {
self.selected = s;
// autoedit: load focused clip in editor.
if let Some(ref mut editor) = self.editor {
editor.set_clip(match self.selected {
Selection::Clip(t, s) if let Some(Some(Some(clip))) = self
.scenes.get(s).map(|s|s.clips.get(t)) => Some(clip),
_ => None
});
}
}
/// Stop all playing clips
pub(crate) fn stop_all (&mut self) {
for track in 0..self.tracks.len() {
self.tracks[track].player.enqueue_next(None);
}
}
/// Launch a clip or scene
pub(crate) fn activate (&mut self) -> Usually<()> {
let selected = self.selected().clone();
match selected {
Selection::Scene(s) => {
let mut clips = vec![];
for (t, _) in self.tracks().iter().enumerate() {
clips.push(self.scenes()[s].clips[t].clone());
}
for (t, track) in self.tracks_mut().iter_mut().enumerate() {
if track.player.play_clip.is_some() || clips[t].is_some() {
track.player.enqueue_next(clips[t].as_ref());
}
}
if self.clock().is_stopped() {
self.clock().play_from(Some(0))?;
}
pub(crate) fn launch (&mut self) {
match self.selected {
Selection::Track(t) => {
self.tracks[t].player.enqueue_next(None)
},
Selection::Clip(t, s) => {
let clip = self.scenes()[s].clips[t].clone();
self.tracks_mut()[t].player.enqueue_next(clip.as_ref());
self.tracks[t].player.enqueue_next(self.scenes[s].clips[t].as_ref())
},
Selection::Scene(s) => {
for t in 0..self.tracks.len() {
self.tracks[t].player.enqueue_next(self.scenes[s].clips[t].as_ref())
}
},
_ => {}
};
}
/// Get the first sampler of the active track
pub fn sampler (&self) -> Option<&Sampler> {
self.tracks.get(0).map(|t|t.sampler(0)).flatten()
}
/// Set the color of the selected entity
pub fn set_color (&mut self, palette: Option<ItemTheme>) -> Option<ItemTheme> {
let palette = palette.unwrap_or_else(||ItemTheme::random());
Some(match self.selected {
Selection::Mix => {
let old = self.color;
self.color = palette;
old
},
Selection::Track(t) => {
let old = self.tracks[t].color;
self.tracks[t].color = palette;
old
}
Selection::Scene(s) => {
let old = self.scenes[s].color;
self.scenes[s].color = palette;
old
}
Selection::Clip(t, s) => {
if let Some(ref clip) = self.scenes[s].clips[t] {
let mut clip = clip.write().unwrap();
let old = clip.color;
clip.color = palette;
old
} else {
return None
}
}
})
}
pub(crate) fn add_midi_in (&mut self) -> Usually<()> {
self.midi_ins.push(JackMidiIn::new(&self.jack, &format!("M/{}", self.midi_ins.len()), &[])?);
Ok(())
}
pub(crate) fn add_midi_out (&mut self) -> Usually<()> {
self.midi_outs.push(JackMidiOut::new(&self.jack, &format!("{}/M", self.midi_outs.len()), &[])?);
Ok(())
}
@ -379,6 +499,17 @@ pub trait HasScenes: HasSelection + HasEditor + Send + Sync {
fn scene_del (&mut self, index: usize) {
self.selected().scene().and_then(|s|Some(self.scenes_mut().remove(index)));
}
/// Set the color of a scene, returning the previous one.
fn scene_set_color (&mut self, index: usize, color: ItemTheme) -> ItemTheme {
let scenes = self.scenes_mut();
let old = scenes[index].color;
scenes[index].color = color;
old
}
/// Generate the default name for a new scene
fn scene_default_name (&self) -> Arc<str> {
format!("Sc{:3>}", self.scenes().len() + 1).into()
}
}
#[derive(Debug, Default)] pub struct Scene {
@ -387,7 +518,7 @@ pub trait HasScenes: HasSelection + HasEditor + Send + Sync {
/// Clips in scene, one per track
pub clips: Vec<Option<Arc<RwLock<MidiClip>>>>,
/// Identifying color of scene
pub color: ItemPalette,
pub color: ItemTheme,
}
impl Scene {
@ -443,6 +574,27 @@ pub trait HasTracks: HasSelection + HasClock + HasJack + HasEditor + Send + Sync
fn track_mut (&mut self) -> Option<&mut Track> {
self.selected().track().and_then(|s|self.tracks_mut().get_mut(s))
}
/// Set the color of a track
fn track_set_color (&mut self, index: usize, color: ItemTheme) -> ItemTheme {
let tracks = self.tracks_mut();
let old = tracks[index].color;
tracks[index].color = color;
old
}
/// Toggle track recording
fn track_toggle_record (&mut self) {
if let Some(t) = self.selected().track() {
let tracks = self.tracks_mut();
tracks[t-1].player.recording = !tracks[t-1].player.recording;
}
}
/// Toggle track monitoring
fn track_toggle_monitor (&mut self) {
if let Some(t) = self.selected().track() {
let tracks = self.tracks_mut();
tracks[t-1].player.monitoring = !tracks[t-1].player.monitoring;
}
}
}
#[derive(Debug, Default)] pub struct Track {
@ -451,7 +603,7 @@ pub trait HasTracks: HasSelection + HasClock + HasJack + HasEditor + Send + Sync
/// Preferred width of track column
pub width: usize,
/// Identifying color of track
pub color: ItemPalette,
pub color: ItemTheme,
/// MIDI player state
pub player: MidiPlayer,
/// Device chain

58
crates/app/src/view.rs
View file

@ -2,37 +2,6 @@ use crate::*;
pub(crate) use std::fmt::Write;
pub(crate) use ::tengri::tui::ratatui::prelude::Position;
view!(TuiOut: |self: Tek| {
self.size.of(View(self, self.view))
}; {
":nil" =>
Box::new("nil"),
":modal" =>
When::new(self.modal.is_some(), Bsp::b(
Fill::xy(Tui::fg_bg(Color::Rgb(64,64,64), Color::Rgb(32,32,32), "")),
Fixed::xy(30, 15, Tui::fg_bg(Color::Rgb(255,255,255), Color::Rgb(16,16,16), self.modal))
)).boxed(),
":transport" =>
self.view_transport().boxed(),
":arranger" =>
ArrangerView::new(self).boxed(),
":editor" =>
self.editor.as_ref()
.map(|e|Bsp::n(Bsp::e(e.clip_status(), e.edit_status()), e))
.boxed(),
":samples-keys" =>
self.tracks[0].sampler(0).map(|s|s.view_list(false, self.editor.as_ref().unwrap())).boxed(),
":samples-grid" =>
self.tracks[0].sampler(0).map(|s|s.view_grid()).boxed(),
":sample-viewer" =>
self.tracks[0].sampler(0).map(|s|s.view_sample(self.editor.as_ref().unwrap().note_pos())).boxed(),
":status" =>
self.view_status().boxed(),
":pool" => self.pool.as_ref()
.map(|pool|Fixed::x(self.w_sidebar(), PoolView(self.is_editing(), pool)))
.boxed(),
});
pub(crate) struct ArrangerView<'a> {
app: &'a Tek,
@ -317,7 +286,7 @@ impl<'a> ArrangerView<'a> {
let clip = clip.read().unwrap();
(Some(clip.name.clone()), clip.color)
} else {
(None, ItemPalette::G[32])
(None, ItemTheme::G[32])
};
let height = (1 + y2 - y1) as u16;
let content = Fill::x(Align::w(Tui::bold(true, Bsp::e(" ⏹ ", name))));
@ -392,7 +361,7 @@ impl<'a> ArrangerView<'a> {
} else {
Some(self.app.scenes[s-1].clips[track].as_ref()
.map(|c|c.read().unwrap().color)
.unwrap_or(ItemPalette::G[32]))
.unwrap_or(ItemTheme::G[32]))
}))
}
)
@ -402,7 +371,7 @@ impl<'a> ArrangerView<'a> {
trait ScenesColors<'a> = Iterator<Item=SceneWithColor<'a>>;
type SceneWithColor<'a> = (usize, &'a Scene, usize, usize, Option<ItemPalette>);
type SceneWithColor<'a> = (usize, &'a Scene, usize, usize, Option<ItemTheme>);
impl Tek {
/// Spacing between tracks.
@ -537,6 +506,21 @@ impl Tek {
)
}
pub fn view_modal (&self) -> impl Content<TuiOut> + use<'_> {
When::new(self.modal.is_some(), Bsp::b(
Fill::xy(Tui::fg_bg(Color::Rgb(64,64,64), Color::Rgb(32,32,32), "")),
Fixed::xy(30, 15, Tui::fg_bg(Color::Rgb(255,255,255), Color::Rgb(16,16,16), self.modal))
))
}
pub fn view_arranger (&self) -> impl Content<TuiOut> + use<'_> {
ArrangerView::new(self)
}
pub fn view_pool (&self) -> impl Content<TuiOut> + use<'_> {
self.pool().map(|p|Fixed::x(self.w_sidebar(), PoolView(self.is_editing(), p)))
}
}
/// Define a type alias for iterators of sized items (columns).
@ -563,7 +547,7 @@ fn view_transport (
beat: Arc<RwLock<String>>,
time: Arc<RwLock<String>>,
) -> impl Content<TuiOut> {
let theme = ItemPalette::G[96];
let theme = ItemTheme::G[96];
Tui::bg(Black, row!(Bsp::a(
Fill::xy(Align::w(button_play_pause(play))),
Fill::xy(Align::e(row!(
@ -580,7 +564,7 @@ fn view_status (
buf: Arc<RwLock<String>>,
lat: Arc<RwLock<String>>,
) -> impl Content<TuiOut> {
let theme = ItemPalette::G[96];
let theme = ItemTheme::G[96];
Tui::bg(Black, row!(Bsp::a(
Fill::xy(Align::w(FieldH(theme, "Selected", sel))),
Fill::xy(Align::e(row!(
@ -610,7 +594,7 @@ pub(crate) fn button_play_pause (playing: bool) -> impl Content<TuiOut> {
pub (crate) fn view_meter <'a> (label: &'a str, value: f32) -> impl Content<TuiOut> + 'a {
col!(
FieldH(ItemPalette::G[128], label, format!("{:>+9.3}", value)),
FieldH(ItemTheme::G[128], label, format!("{:>+9.3}", value)),
Fixed::xy(if value >= 0.0 { 13 }
else if value >= -1.0 { 12 }
else if value >= -2.0 { 11 }

2
crates/cli/tek.rs
View file

@ -103,7 +103,7 @@ impl Cli {
}
let mut app = Tek {
jack: jack.clone(),
color: ItemPalette::random(),
color: ItemTheme::random(),
clock: Clock::new(jack, self.bpm)?,
view: SourceIter(match mode {
LaunchMode::Clock => include_str!("./edn/transport.edn"),

6
crates/midi/midi.scratch.rs
View file

@ -35,14 +35,14 @@
//return None
//},
//kpat!(Char('a')) | kpat!(Shift-Char('A')) => Cmd::Clip(PoolClipCommand::Add(count, MidiClip::new(
//"Clip", true, 4 * PPQ, None, Some(ItemPalette::random())
//"Clip", true, 4 * PPQ, None, Some(ItemTheme::random())
//))),
//kpat!(Char('i')) => Cmd::Clip(PoolClipCommand::Add(index + 1, MidiClip::new(
//"Clip", true, 4 * PPQ, None, Some(ItemPalette::random())
//"Clip", true, 4 * PPQ, None, Some(ItemTheme::random())
//))),
//kpat!(Char('d')) | kpat!(Shift-Char('D')) => {
//let mut clip = state.clips()[index].read().unwrap().duplicate();
//clip.color = ItemPalette::random_near(clip.color, 0.25);
//clip.color = ItemTheme::random_near(clip.color, 0.25);
//Cmd::Clip(PoolClipCommand::Add(index + 1, clip))
//},
//_ => return None

2
crates/midi/src/clip.rs
View file

@ -1,5 +1,3 @@
use crate::*;
mod clip_editor; pub use self::clip_editor::*;
mod clip_launch; pub use self::clip_launch::*;
mod clip_model; pub use self::clip_model::*;

4
crates/midi/src/clip/clip_editor.rs
View file

@ -115,7 +115,7 @@ impl MidiEditor {
pub fn clip_status (&self) -> impl Content<TuiOut> + '_ {
let (color, name, length, looped) = if let Some(clip) = self.clip().as_ref().map(|p|p.read().unwrap()) {
(clip.color, clip.name.clone(), clip.length, clip.looped)
} else { (ItemPalette::G[64], String::new().into(), 0, false) };
} else { (ItemTheme::G[64], String::new().into(), 0, false) };
Bsp::e(
FieldH(color, "Edit", format!("{name} ({length})")),
FieldH(color, "Loop", looped.to_string())
@ -125,7 +125,7 @@ impl MidiEditor {
pub fn edit_status (&self) -> impl Content<TuiOut> + '_ {
let (color, length) = if let Some(clip) = self.clip().as_ref().map(|p|p.read().unwrap()) {
(clip.color, clip.length)
} else { (ItemPalette::G[64], 0) };
} else { (ItemTheme::G[64], 0) };
let time_pos = self.time_pos();
let time_zoom = self.time_zoom().get();
let time_lock = if self.time_lock().get() { "[lock]" } else { " " };

4
crates/midi/src/clip/clip_launch.rs
View file

@ -39,7 +39,7 @@ pub trait HasPlayClip: HasClock {
}
fn play_status (&self) -> impl Content<TuiOut> {
let (name, color): (Arc<str>, ItemPalette) = if let Some((_, Some(clip))) = self.play_clip() {
let (name, color): (Arc<str>, ItemTheme) = if let Some((_, Some(clip))) = self.play_clip() {
let MidiClip { ref name, color, .. } = *clip.read().unwrap();
(name.clone(), color)
} else {
@ -54,7 +54,7 @@ pub trait HasPlayClip: HasClock {
fn next_status (&self) -> impl Content<TuiOut> {
let mut time: Arc<str> = String::from("--.-.--").into();
let mut name: Arc<str> = String::from("").into();
let mut color = ItemPalette::G[64];
let mut color = ItemTheme::G[64];
let clock = self.clock();
if let Some((t, Some(clip))) = self.next_clip() {
let clip = clip.read().unwrap();

6
crates/midi/src/clip/clip_model.rs
View file

@ -34,7 +34,7 @@ pub struct MidiClip {
/// All notes are displayed with minimum length
pub percussive: bool,
/// Identifying color of clip
pub color: ItemPalette,
pub color: ItemTheme,
}
/// MIDI message structural
@ -46,7 +46,7 @@ impl MidiClip {
looped: bool,
length: usize,
notes: Option<MidiData>,
color: Option<ItemPalette>,
color: Option<ItemTheme>,
) -> Self {
Self {
uuid: uuid::Uuid::new_v4(),
@ -58,7 +58,7 @@ impl MidiClip {
loop_start: 0,
loop_length: length,
percussive: true,
color: color.unwrap_or_else(ItemPalette::random)
color: color.unwrap_or_else(ItemTheme::random)
}
}
pub fn count_midi_messages (&self) -> usize {

2
crates/midi/src/mode.rs
View file

@ -1,8 +1,8 @@
use crate::*;
mod mode_browse; pub use self::mode_browse::*;
mod mode_length; pub use self::mode_length::*;
mod mode_rename; pub use self::mode_rename::*;
mod mode_browse;
/// Modes for clip pool
#[derive(Debug, Clone)]

6
crates/midi/src/piano/piano_h.rs
View file

@ -13,7 +13,7 @@ pub struct PianoHorizontal {
/// The note cursor
pub point: MidiPointModel,
/// The highlight color palette
pub color: ItemPalette,
pub color: ItemTheme,
/// Width of the keyboard
pub keys_width: u16,
}
@ -31,7 +31,7 @@ impl PianoHorizontal {
buffer: RwLock::new(Default::default()).into(),
point: MidiPointModel::default(),
clip: clip.cloned(),
color: clip.as_ref().map(|p|p.read().unwrap().color).unwrap_or(ItemPalette::G[64]),
color: clip.as_ref().map(|p|p.read().unwrap().color).unwrap_or(ItemTheme::G[64]),
};
piano.redraw();
piano
@ -281,7 +281,7 @@ impl MidiViewer for PianoHorizontal {
fn set_clip (&mut self, clip: Option<&Arc<RwLock<MidiClip>>>) {
*self.clip_mut() = clip.cloned();
self.color = clip.map(|p|p.read().unwrap().color)
.unwrap_or(ItemPalette::G[64]);
.unwrap_or(ItemTheme::G[64]);
self.redraw();
}
}

2
crates/midi/src/pool/pool_api.rs
View file

@ -168,7 +168,7 @@ impl<T: HasClips> Command<T> for PoolClipCommand {
Some(Self::SetLength(index, old_len))
},
SetColor(index, color) => {
let mut color = ItemPalette::from(color);
let mut color = ItemTheme::from(color);
std::mem::swap(&mut color, &mut model.clips()[index].write().unwrap().color);
Some(Self::SetColor(index, color.base))
},

4
crates/midi/src/pool/pool_model.rs
View file

@ -85,12 +85,12 @@ impl MidiPool {
Ok(())
}
pub fn new_clip (&self) -> MidiClip {
MidiClip::new("Clip", true, 4 * PPQ, None, Some(ItemPalette::random()))
MidiClip::new("Clip", true, 4 * PPQ, None, Some(ItemTheme::random()))
}
pub fn cloned_clip (&self) -> MidiClip {
let index = self.clip_index();
let mut clip = self.clips()[index].read().unwrap().duplicate();
clip.color = ItemPalette::random_near(clip.color, 0.25);
clip.color = ItemTheme::random_near(clip.color, 0.25);
clip
}
pub fn add_new_clip (&self) -> (usize, Arc<RwLock<MidiClip>>) {

2
crates/sampler/sampler_scratch.rs
View file

@ -127,7 +127,7 @@
//});
//struct SamplesTui {
//color: ItemPalette,
//color: ItemTheme,
//note_hi: usize,
//note_pt: usize,
//height: usize,

5
crates/sampler/src/lib.rs
View file

@ -22,12 +22,13 @@ pub(crate) use symphonia::{
pub(crate) use ratatui::{prelude::Rect, widgets::{Widget, canvas::{Canvas, Line}}};
mod sampler_api; pub use self::sampler_api::*;
mod sampler_data; pub use self::sampler_data::*;
mod sampler_audio; pub use self::sampler_audio::*;
mod sampler_browse; pub use self::sampler_browse::*;
mod sampler_midi; pub use self::sampler_midi::*;
mod sampler_model; pub use self::sampler_model::*;
mod sampler_view; pub use self::sampler_view::*;
mod sampler_data;
mod sampler_view;
#[cfg(test)] #[test] fn test_sampler () {
// TODO!

84
crates/sampler/src/sampler_api.rs
View file

@ -1,25 +1,48 @@
use crate::*;
expose! {
[self: Sampler] {
[Arc<str>] => {}
[Option<Arc<RwLock<Sample>>>] => {}
[PathBuf] => {}
[f32] => {}
[u7] => {
":sample" => (self.note_pos() as u8).into(),
}
[usize] => {
":sample-up" => self.note_pos().min(119) + 8,
":sample-down" => self.note_pos().max(8) - 8,
":sample-left" => self.note_pos().min(126) + 1,
":sample-right" => self.note_pos().max(1) - 1,
}
}
}
expose!([self: Sampler]
([Arc<str>])
([Option<Arc<RwLock<Sample>>>])
([PathBuf])
([f32])
([u7] (":pitch" (self.note_pos() as u8).into()) // TODO
(":sample" (self.note_pos() as u8).into()))
([usize] (":sample-up" self.note_pos().min(119) + 8)
(":sample-down" self.note_pos().max(8) - 8)
(":sample-left" self.note_pos().min(126) + 1)
(":sample-right" self.note_pos().max(1) - 1)));
impose!([state: Sampler]
(FileBrowserCommand:
("begin" [] Some(Self::Begin))
("cancel" [] Some(Self::Cancel))
("confirm" [] Some(Self::Confirm))
("select" [i: usize] Some(Self::Select(i.expect("no index"))))
("chdir" [p: PathBuf] Some(Self::Chdir(p.expect("no path"))))
("filter" [f: Arc<str>] Some(Self::Filter(f.expect("no filter")))))
(SamplerCommand:
("import" [,..a]
FileBrowserCommand::try_from_expr(state, a).map(Self::Import))
("select" [i: usize]
Some(Self::Select(i.expect("no index"))))
("record/begin" [i: u7]
Some(Self::RecordBegin(i.expect("no index"))))
("record/cancel" []
Some(Self::RecordCancel))
("record/finish" []
Some(Self::RecordFinish))
("set/sample" [i: u7, s: Option<Arc<RwLock<Sample>>>]
Some(Self::SetSample(i.expect("no index"), s.expect("no sampler"))))
("set/start" [i: u7, s: usize]
Some(Self::SetStart(i.expect("no index"), s.expect("no start"))))
("set/gain" [i: u7, g: f32]
Some(Self::SetGain(i.expect("no index"), g.expect("no gain"))))
("note/on" [p: u7, v: u7]
Some(Self::NoteOn(p.expect("no pitch"), v.expect("no velocity"))))
("note/off" [p: u7]
Some(Self::NoteOff(p.expect("no pitch"))))));
defcom! { |self, state: Sampler|
SamplerCommand {
Import(cmd: FileBrowserCommand) => match cmd {
@ -86,28 +109,3 @@ defcom! { |self, state: Sampler|
}
}
atom_command!(FileBrowserCommand: |state: Sampler| {
("begin" [] Some(Self::Begin))
("cancel" [] Some(Self::Cancel))
("confirm" [] Some(Self::Confirm))
("select" [i: usize] Some(Self::Select(i.expect("no index"))))
("chdir" [p: PathBuf] Some(Self::Chdir(p.expect("no path"))))
("filter" [f: Arc<str>] Some(Self::Filter(f.expect("no filter")))) });
atom_command!(SamplerCommand: |state: Sampler| {
("import" [,..a] FileBrowserCommand::try_from_expr(state, a).map(Self::Import))
("select" [i: usize] Some(Self::Select(i.expect("no index"))))
("record/begin" [i: u7] Some(Self::RecordBegin(i.expect("no index"))))
("record/cancel" [] Some(Self::RecordCancel))
("record/finish" [] Some(Self::RecordFinish))
("set/sample" [i: u7, s: Option<Arc<RwLock<Sample>>>]
Some(Self::SetSample(i.expect("no index"), s.expect("no sampler"))))
("set/start" [i: u7, s: usize]
Some(Self::SetStart(i.expect("no index"), s.expect("no start"))))
("set/gain" [i: u7, g: f32]
Some(Self::SetGain(i.expect("no index"), g.expect("no garin"))))
("note/on" [p: u7, v: u7]
Some(Self::NoteOn(p.expect("no pitch"), v.expect("no velocity"))))
("note/off" [p: u7]
Some(Self::NoteOff(p.expect("no pitch")))) });

2
crates/sampler/src/sampler_model.rs
View file

@ -24,7 +24,7 @@ pub struct Sampler {
pub note_pt: AtomicUsize,
/// Selected note as row/col
pub cursor: (AtomicUsize, AtomicUsize),
pub color: ItemPalette
pub color: ItemTheme
}
impl Default for Sampler {

2
crates/time/src/clock.rs
View file

@ -1,5 +1,3 @@
use crate::*;
mod clock_api; pub use self::clock_api::*;
mod clock_model; pub use self::clock_model::*;

2
deps/tengri vendored

@ -1 +1 @@
Subproject commit 844681d6add6838a173ddc2a5c3bb9d51451d2e1
Subproject commit 7ba37f3f0255c2c61ed3371e2c437514f27f6d6d