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

switch around ownership of pool and editort

Browse source
This commit is contained in:
🪞👃🪞 2025-05-17 13:23:31 +03:00
parent 3f1a2fee80
commit c7e7c9f68c
8 changed files with 157 additions and 150 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -24,9 +24,10 @@ handle!(TuiIn: |self: App, input|Ok(if let Some(command) = self.config.keys.comm
Selection::TrackClip { track, scene } => { Selection::TrackClip { track, scene } => {
let clip = &mut app.scenes_mut()[scene].clips[track]; let clip = &mut app.scenes_mut()[scene].clips[track];
if clip.is_none() { if clip.is_none() {
//app.clip_auto_create();
*clip = Some(Default::default()); *clip = Some(Default::default());
} }
app.editor = clip.as_ref().map(|c|c.into()); app.project.editor = clip.as_ref().map(|c|c.into());
None None
} }
_ => None _ => None
@ -62,18 +63,19 @@ handle!(TuiIn: |self: App, input|Ok(if let Some(command) = self.config.keys.comm
//} //}
fn select (app: &mut App, selection: Selection) -> Perhaps<Self> { fn select (app: &mut App, selection: Selection) -> Perhaps<Self> {
*app.project.selection_mut() = selection; *app.project.selection_mut() = selection;
if let Some(ref mut editor) = app.editor { //todo!
editor.set_clip(match app.project.selection() { //if let Some(ref mut editor) = app.editor_mut() {
Selection::TrackClip { track, scene } if let Some(Some(Some(clip))) = app //editor.set_clip(match selection {
.project //Selection::TrackClip { track, scene } if let Some(Some(Some(clip))) = app
.scenes.get(*scene) //.project
.map(|s|s.clips.get(*track)) //.scenes.get(scene)
=> //.map(|s|s.clips.get(track))
Some(clip), //=>
_ => //Some(clip),
None //_ =>
}); //None
} //});
//}
Ok(None) Ok(None)
//("select" [t: usize, s: usize] Some(match (t.expect("no track"), s.expect("no scene")) { //("select" [t: usize, s: usize] Some(match (t.expect("no track"), s.expect("no scene")) {
//(0, 0) => Self::Select(Selection::Mix), //(0, 0) => Self::Select(Selection::Mix),
@ -102,7 +104,7 @@ handle!(TuiIn: |self: App, input|Ok(if let Some(command) = self.config.keys.comm
Ok(command.delegate(app, |command|Self::Message{command})?) Ok(command.delegate(app, |command|Self::Message{command})?)
} }
fn editor (app: &mut App, command: MidiEditCommand) -> Perhaps<Self> { fn editor (app: &mut App, command: MidiEditCommand) -> Perhaps<Self> {
Ok(if let Some(editor) = app.editor.as_mut() { Ok(if let Some(editor) = app.editor_mut() {
let undo = command.clone().delegate(editor, |command|AppCommand::Editor{command})?; let undo = command.clone().delegate(editor, |command|AppCommand::Editor{command})?;
// update linked sampler after editor action // update linked sampler after editor action
app.project.sampler_mut().map(|sampler|match command { app.project.sampler_mut().map(|sampler|match command {
@ -117,18 +119,20 @@ handle!(TuiIn: |self: App, input|Ok(if let Some(command) = self.config.keys.comm
} }
fn pool (app: &mut App, command: PoolCommand) -> Perhaps<Self> { fn pool (app: &mut App, command: PoolCommand) -> Perhaps<Self> {
let undo = command.clone().delegate( let undo = command.clone().delegate(
&mut app.project.pool, &mut app.pool,
|command|AppCommand::Pool{command} |command|AppCommand::Pool{command}
)?; )?;
// update linked editor after pool action // update linked editor after pool action
app.editor.as_mut().map(|editor|match command { match command {
// autoselect: automatically load selected clip in editor // autoselect: automatically load selected clip in editor
PoolCommand::Select { .. } | PoolCommand::Select { .. } |
// autocolor: update color in all places simultaneously // autocolor: update color in all places simultaneously
PoolCommand::Clip { command: PoolClipCommand::SetColor { .. } } => PoolCommand::Clip { command: PoolClipCommand::SetColor { .. } } => {
editor.set_clip(app.project.pool.clip().as_ref()), let clip = app.pool.clip().clone();
_ => {} app.editor_mut().map(|editor|editor.set_clip(clip.as_ref()))
}); },
_ => None
};
Ok(undo) Ok(undo)
} }
} }
@ -147,7 +151,7 @@ impl<'state> Context<'state, MidiEditCommand> for App {
impl<'state> Context<'state, PoolCommand> for App { impl<'state> Context<'state, PoolCommand> for App {
fn get <'source> (&'state self, iter: &mut TokenIter<'source>) -> Option<PoolCommand> { fn get <'source> (&'state self, iter: &mut TokenIter<'source>) -> Option<PoolCommand> {
Context::get(&self.project.pool, iter) Context::get(&self.pool, iter)
} }
} }

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

@ -5,7 +5,7 @@ audio!(
let t0 = self.perf.get_t0(); let t0 = self.perf.get_t0();
self.clock().update_from_scope(scope).unwrap(); self.clock().update_from_scope(scope).unwrap();
let midi_in = self.project.midi_input_collect(scope); let midi_in = self.project.midi_input_collect(scope);
if let Some(editor) = &self.editor { if let Some(editor) = &self.editor() {
let mut pitch: Option<u7> = None; let mut pitch: Option<u7> = None;
for port in midi_in.iter() { for port in midi_in.iter() {
for event in port.iter() { for event in port.iter() {

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

@ -20,23 +20,22 @@ pub struct App {
pub history: Vec<AppCommand>, pub history: Vec<AppCommand>,
// Dialog overlay // Dialog overlay
pub dialog: Option<Dialog>, pub dialog: Option<Dialog>,
/// Contains the currently edited MIDI clip
pub editor: Option<MidiEditor>,
// Cache of formatted strings // Cache of formatted strings
pub view_cache: Arc<RwLock<ViewCache>>, pub view_cache: Arc<RwLock<ViewCache>>,
/// Base color. /// Base color.
pub color: ItemTheme, pub color: ItemTheme,
} }
has!(Jack: |self: App|self.jack); has!(Jack: |self: App|self.jack);
has!(Pool: |self: App|self.pool); has!(Pool: |self: App|self.pool);
has!(Clock: |self: App|self.project.clock); has!(Clock: |self: App|self.project.clock);
has!(Selection: |self: App|self.project.selection); has!(Option<MidiEditor>: |self: App|self.project.editor);
has!(Vec<JackMidiIn>: |self: App|self.project.midi_ins); has!(Selection: |self: App|self.project.selection);
has!(Vec<JackMidiOut>: |self: App|self.project.midi_outs); has!(Vec<JackMidiIn>: |self: App|self.project.midi_ins);
has!(Vec<Scene>: |self: App|self.project.scenes); has!(Vec<JackMidiOut>: |self: App|self.project.midi_outs);
has!(Vec<Track>: |self: App|self.project.tracks); has!(Vec<Scene>: |self: App|self.project.scenes);
has!(Measure<TuiOut>: |self: App|self.size); has!(Vec<Track>: |self: App|self.project.tracks);
has!(Measure<TuiOut>: |self: App|self.size);
maybe_has!(Track: |self: App| maybe_has!(Track: |self: App|
{ MaybeHas::<Track>::get(&self.project) }; { MaybeHas::<Track>::get(&self.project) };
{ MaybeHas::<Track>::get_mut(&mut self.project) }); { MaybeHas::<Track>::get_mut(&mut self.project) });
@ -49,19 +48,19 @@ maybe_has!(Scene: |self: App|
impl HasSceneScroll for App { impl HasSceneScroll for App {
fn scene_scroll (&self) -> usize { self.project.scene_scroll() } fn scene_scroll (&self) -> usize { self.project.scene_scroll() }
} }
has_clips!(|self: App|self.project.pool.clips); has_clips!(|self: App|self.pool.clips);
has_editor!(|self: App|{ //has_editor!(|self: App|{
editor = self.editor; //editor = self.editor;
editor_w = { //editor_w = {
let size = self.size.w(); //let size = self.size.w();
let editor = self.editor.as_ref().expect("missing editor"); //let editor = self.editor.as_ref().expect("missing editor");
let time_len = editor.time_len().get(); //let time_len = editor.time_len().get();
let time_zoom = editor.time_zoom().get().max(1); //let time_zoom = editor.time_zoom().get().max(1);
(5 + (time_len / time_zoom)).min(size.saturating_sub(20)).max(16) //(5 + (time_len / time_zoom)).min(size.saturating_sub(20)).max(16)
}; //};
editor_h = 15; //editor_h = 15;
is_editing = self.editor.is_some(); //is_editing = self.editor.is_some();
}); //});
impl App { impl App {
pub fn toggle_dialog (&mut self, mut dialog: Option<Dialog>) -> Option<Dialog> { pub fn toggle_dialog (&mut self, mut dialog: Option<Dialog>) -> Option<Dialog> {
@ -70,7 +69,7 @@ impl App {
} }
pub fn toggle_editor (&mut self, value: Option<bool>) { pub fn toggle_editor (&mut self, value: Option<bool>) {
//FIXME: self.editing.store(value.unwrap_or_else(||!self.is_editing()), Relaxed); //FIXME: self.editing.store(value.unwrap_or_else(||!self.is_editing()), Relaxed);
let value = value.unwrap_or_else(||!self.editor.is_some()); let value = value.unwrap_or_else(||!self.editor().is_some());
if value { if value {
self.clip_auto_create(); self.clip_auto_create();
} else { } else {
@ -130,11 +129,11 @@ impl App {
&& slot.is_none() && slot.is_none()
&& let Some(track) = self.project.tracks.get_mut(track) && let Some(track) = self.project.tracks.get_mut(track)
{ {
let (index, mut clip) = self.project.pool.add_new_clip(); let (index, mut clip) = self.pool.add_new_clip();
// autocolor: new clip colors from scene and track color // autocolor: new clip colors from scene and track color
let color = track.color.base.mix(scene.color.base, 0.5); let color = track.color.base.mix(scene.color.base, 0.5);
clip.write().unwrap().color = ItemColor::random_near(color, 0.2).into(); clip.write().unwrap().color = ItemColor::random_near(color, 0.2).into();
if let Some(ref mut editor) = self.editor { if let Some(ref mut editor) = &mut self.project.editor {
editor.set_clip(Some(&clip)); editor.set_clip(Some(&clip));
} }
*slot = Some(clip.clone()); *slot = Some(clip.clone());
@ -155,7 +154,7 @@ impl App {
std::mem::swap(&mut swapped, slot); std::mem::swap(&mut swapped, slot);
} }
if let Some(clip) = swapped { if let Some(clip) = swapped {
self.project.pool.delete_clip(&clip.read().unwrap()); self.pool.delete_clip(&clip.read().unwrap());
} }
} }
} }
@ -199,7 +198,7 @@ impl App {
todo!() todo!()
} }
fn w_sidebar (&self) -> u16 { fn w_sidebar (&self) -> u16 {
self.project.w_sidebar(self.editor.is_some()) self.project.w_sidebar(self.editor().is_some())
} }
fn h_sample_detail (&self) -> u16 { fn h_sample_detail (&self) -> u16 {
6.max(self.height() as u16 * 3 / 9) 6.max(self.height() as u16 * 3 / 9)
@ -232,16 +231,16 @@ impl App {
!self.is_editing() && self.selection().is_mix() !self.is_editing() && self.selection().is_mix()
} }
fn focus_pool_import (&self) -> bool { fn focus_pool_import (&self) -> bool {
matches!(self.project.pool.mode, Some(PoolMode::Import(..))) matches!(self.pool.mode, Some(PoolMode::Import(..)))
} }
fn focus_pool_export (&self) -> bool { fn focus_pool_export (&self) -> bool {
matches!(self.project.pool.mode, Some(PoolMode::Export(..))) matches!(self.pool.mode, Some(PoolMode::Export(..)))
} }
fn focus_pool_rename (&self) -> bool { fn focus_pool_rename (&self) -> bool {
matches!(self.project.pool.mode, Some(PoolMode::Rename(..))) matches!(self.pool.mode, Some(PoolMode::Rename(..)))
} }
fn focus_pool_length (&self) -> bool { fn focus_pool_length (&self) -> bool {
matches!(self.project.pool.mode, Some(PoolMode::Length(..))) matches!(self.pool.mode, Some(PoolMode::Length(..)))
} }
fn dialog_none (&self) -> Option<Dialog> { fn dialog_none (&self) -> Option<Dialog> {
None None

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

@ -83,7 +83,7 @@ impl App {
self.project.view_scenes_names() self.project.view_scenes_names()
} }
pub fn view_arranger_scenes_clips (&self) -> impl Content<TuiOut> + use<'_> { pub fn view_arranger_scenes_clips (&self) -> impl Content<TuiOut> + use<'_> {
self.project.view_scenes_clips(&self.editor) self.project.view_scenes_clips()
} }
pub fn view_arranger_track_names (&self) -> impl Content<TuiOut> + use<'_> { pub fn view_arranger_track_names (&self) -> impl Content<TuiOut> + use<'_> {
self.project.view_track_names(self.color) self.project.view_track_names(self.color)
@ -117,7 +117,7 @@ impl App {
Fixed::x(20, Bsp::s( Fixed::x(20, Bsp::s(
Fill::x(Align::w(FieldH(self.color, "Clip pool:", ""))), Fill::x(Align::w(FieldH(self.color, "Clip pool:", ""))),
Fill::y(Align::n(Tui::bg(Rgb(0, 0, 0), Outer(true, Style::default().fg(Tui::g(96))) Fill::y(Align::n(Tui::bg(Rgb(0, 0, 0), Outer(true, Style::default().fg(Tui::g(96)))
.enclose(PoolView(&self.project.pool))))))) .enclose(PoolView(&self.pool)))))))
} }
pub fn view_samples_keys (&self) -> impl Content<TuiOut> + use<'_> { pub fn view_samples_keys (&self) -> impl Content<TuiOut> + use<'_> {
self.project.sampler().map(|s|s.view_list(true, self.editor().unwrap())) self.project.sampler().map(|s|s.view_list(true, self.editor().unwrap()))
@ -243,20 +243,14 @@ impl ScenesView for App {
fn arrangement (&self) -> &Arrangement { fn arrangement (&self) -> &Arrangement {
&self.project &self.project
} }
fn scenes_height (&self) -> u16 { fn h_scenes (&self) -> u16 {
(self.height() as u16).saturating_sub(20) (self.height() as u16).saturating_sub(20)
} }
fn width_side (&self) -> u16 { fn w_side (&self) -> u16 {
20 20
} }
fn width_mid (&self) -> u16 { fn w_mid (&self) -> u16 {
(self.width() as u16).saturating_sub(self.width_side()) (self.width() as u16).saturating_sub(self.w_side())
}
fn scene_selected (&self) -> Option<usize> {
self.project.selection.scene()
}
fn track_selected (&self) -> Option<usize> {
self.project.selection.track()
} }
} }

12
crates/cli/tek.rs
View file

@ -122,9 +122,9 @@ impl Cli {
jack: jack.clone(), jack: jack.clone(),
config, config,
color: ItemTheme::random(), color: ItemTheme::random(),
editor: match self.mode { pool: match self.mode {
LaunchMode::Sequencer | LaunchMode::Groovebox => Some((&clip).into()), LaunchMode::Sequencer | LaunchMode::Groovebox => (&clip).into(),
_ => None _ => Default::default()
}, },
project: Arrangement { project: Arrangement {
name: Default::default(), name: Default::default(),
@ -136,9 +136,9 @@ impl Cli {
selection: Selection::TrackClip { track: 0, scene: 0 }, selection: Selection::TrackClip { track: 0, scene: 0 },
midi_ins, midi_ins,
midi_outs, midi_outs,
pool: match self.mode { editor: match self.mode {
LaunchMode::Sequencer | LaunchMode::Groovebox => (&clip).into(), LaunchMode::Sequencer | LaunchMode::Groovebox => Some((&clip).into()),
_ => Default::default() _ => None
}, },
..Default::default() ..Default::default()
}, },

35
crates/device/src/arranger/arranger_model.rs
View file

@ -10,6 +10,8 @@ pub struct Arrangement {
pub jack: Jack, pub jack: Jack,
/// Source of time /// Source of time
pub clock: Clock, pub clock: Clock,
/// Allows one MIDI clip to be edited
pub editor: Option<MidiEditor>,
/// List of global midi inputs /// List of global midi inputs
pub midi_ins: Vec<JackMidiIn>, pub midi_ins: Vec<JackMidiIn>,
/// List of global midi outputs /// List of global midi outputs
@ -35,18 +37,17 @@ pub struct Arrangement {
pub arranger: Arc<RwLock<Buffer>>, pub arranger: Arc<RwLock<Buffer>>,
/// Display size /// Display size
pub size: Measure<TuiOut>, pub size: Measure<TuiOut>,
/// Contains all clips in arrangement
pub pool: Pool,
} }
has!(Jack: |self: Arrangement|self.jack); has!(Jack: |self: Arrangement|self.jack);
has!(Clock: |self: Arrangement|self.clock); has!(Clock: |self: Arrangement|self.clock);
has!(Selection: |self: Arrangement|self.selection); has!(Selection: |self: Arrangement|self.selection);
has!(Vec<JackMidiIn>: |self: Arrangement|self.midi_ins); has!(Vec<JackMidiIn>: |self: Arrangement|self.midi_ins);
has!(Vec<JackMidiOut>: |self: Arrangement|self.midi_outs); has!(Vec<JackMidiOut>: |self: Arrangement|self.midi_outs);
has!(Vec<Scene>: |self: Arrangement|self.scenes); has!(Vec<Scene>: |self: Arrangement|self.scenes);
has!(Vec<Track>: |self: Arrangement|self.tracks); has!(Vec<Track>: |self: Arrangement|self.tracks);
has!(Measure<TuiOut>: |self: Arrangement|self.size); has!(Measure<TuiOut>: |self: Arrangement|self.size);
has!(Option<MidiEditor>: |self: Arrangement|self.editor);
maybe_has!(Track: |self: Arrangement| maybe_has!(Track: |self: Arrangement|
{ Has::<Selection>::get(self).track().map(|index|Has::<Vec<Track>>::get(self).get(index)).flatten() }; { Has::<Selection>::get(self).track().map(|index|Has::<Vec<Track>>::get(self).get(index)).flatten() };
{ Has::<Selection>::get(self).track().map(|index|Has::<Vec<Track>>::get_mut(self).get_mut(index)).flatten() }); { Has::<Selection>::get(self).track().map(|index|Has::<Vec<Track>>::get_mut(self).get_mut(index)).flatten() });
@ -215,19 +216,13 @@ impl ScenesView for Arrangement {
fn arrangement (&self) -> &Arrangement { fn arrangement (&self) -> &Arrangement {
self self
} }
fn scenes_height (&self) -> u16 { fn h_scenes (&self) -> u16 {
(self.height() as u16).saturating_sub(20) (self.height() as u16).saturating_sub(20)
} }
fn width_side (&self) -> u16 { fn w_side (&self) -> u16 {
(self.width() as u16 * 2 / 10).max(20) (self.width() as u16 * 2 / 10).max(20)
} }
fn width_mid (&self) -> u16 { fn w_mid (&self) -> u16 {
(self.width() as u16).saturating_sub(2 * self.width_side()).max(40) (self.width() as u16).saturating_sub(2 * self.w_side()).max(40)
}
fn scene_selected (&self) -> Option<usize> {
self.selection().scene()
}
fn track_selected (&self) -> Option<usize> {
self.selection().track()
} }
} }

105
crates/device/src/arranger/arranger_view.rs
View file

@ -9,7 +9,7 @@ impl Content<TuiOut> for Arrangement {
let bg = |x|Tui::bg(Reset, x); let bg = |x|Tui::bg(Reset, x);
//let track_scroll = |x|Bsp::s(&self.track_scroll, x); //let track_scroll = |x|Bsp::s(&self.track_scroll, x);
//let scene_scroll = |x|Bsp::e(&self.scene_scroll, x); //let scene_scroll = |x|Bsp::e(&self.scene_scroll, x);
self.size.of(outs(tracks(devices(ins(bg(self.view_scenes_clips(&None))))))) self.size.of(outs(tracks(devices(ins(bg(self.view_scenes_clips()))))))
} }
} }
@ -34,7 +34,7 @@ impl Arrangement {
let mon = track.sequencer.monitoring; let mon = track.sequencer.monitoring;
let rec = if rec { White } else { track.color.darkest.rgb }; let rec = if rec { White } else { track.color.darkest.rgb };
let mon = if mon { White } else { track.color.darkest.rgb }; let mon = if mon { White } else { track.color.darkest.rgb };
let bg = if self.track_selected() == Some(t) { let bg = if self.arrangement().selection().track() == Some(t) {
track.color.light.rgb track.color.light.rgb
} else { } else {
track.color.base.rgb track.color.base.rgb
@ -48,18 +48,18 @@ impl Arrangement {
} }
fn view_input_routes (&self) -> impl Content<TuiOut> + '_ { fn view_input_routes (&self) -> impl Content<TuiOut> + '_ {
Tryptich::top(self.h_inputs()) Tryptich::top(self.h_inputs())
.left(self.width_side(), .left(self.w_side(),
io_ports(Tui::g(224), Tui::g(32), ||self.midi_ins_with_sizes())) io_ports(Tui::g(224), Tui::g(32), ||self.midi_ins_with_sizes()))
.middle(self.width_mid(), .middle(self.w_mid(),
per_track_top(||self.tracks_with_sizes_scrolled(), per_track_top(||self.tracks_with_sizes_scrolled(),
move|_, &Track { color, .. }|io_conns( move|_, &Track { color, .. }|io_conns(
color.dark.rgb, color.darker.rgb, ||self.midi_ins_with_sizes()))) color.dark.rgb, color.darker.rgb, ||self.midi_ins_with_sizes())))
} }
fn view_input_intos (&self) -> impl Content<TuiOut> + '_ { fn view_input_intos (&self) -> impl Content<TuiOut> + '_ {
Tryptich::top(2) Tryptich::top(2)
.left(self.width_side(), .left(self.w_side(),
Bsp::s(Align::e("Input:"), Align::e("Into clip:"))) Bsp::s(Align::e("Input:"), Align::e("Into clip:")))
.middle(self.width_mid(), .middle(self.w_mid(),
per_track_top(||self.tracks_with_sizes_scrolled(), per_track_top(||self.tracks_with_sizes_scrolled(),
|_, _|Tui::bg(Reset, Align::c(Bsp::s(OctaveVertical::default(), " ------ "))))) |_, _|Tui::bg(Reset, Align::c(Bsp::s(OctaveVertical::default(), " ------ ")))))
} }
@ -72,9 +72,9 @@ impl Arrangement {
} }
fn view_output_ports (&self) -> impl Content<TuiOut> + '_ { fn view_output_ports (&self) -> impl Content<TuiOut> + '_ {
Tryptich::top(1) Tryptich::top(1)
.left(self.width_side(), self.view_output_count()) .left(self.w_side(), self.view_output_count())
.right(self.width_side(), self.view_output_add()) .right(self.w_side(), self.view_output_add())
.middle(self.width_mid(), self.view_output_map()) .middle(self.w_mid(), self.view_output_map())
} }
fn view_output_count (&self) -> impl Content<TuiOut> { fn view_output_count (&self) -> impl Content<TuiOut> {
button_3( button_3(
@ -93,7 +93,7 @@ impl Arrangement {
let solo = false; let solo = false;
let mute = if mute { White } else { t.color.darkest.rgb }; let mute = if mute { White } else { t.color.darkest.rgb };
let solo = if solo { White } else { t.color.darkest.rgb }; let solo = if solo { White } else { t.color.darkest.rgb };
let bg_1 = if self.track_selected() == Some(i) { let bg_1 = if self.arrangement().selection().track() == Some(i) {
t.color.light.rgb t.color.light.rgb
} else { } else {
t.color.base.rgb t.color.base.rgb
@ -106,9 +106,9 @@ impl Arrangement {
} }
fn view_output_conns (&self) -> impl Content<TuiOut> + '_ { fn view_output_conns (&self) -> impl Content<TuiOut> + '_ {
Tryptich::top(self.h_outputs()) Tryptich::top(self.h_outputs())
.left(self.width_side(), io_ports( .left(self.w_side(), io_ports(
Tui::g(224), Tui::g(32), ||self.midi_outs_with_sizes())) Tui::g(224), Tui::g(32), ||self.midi_outs_with_sizes()))
.middle(self.width_mid(), per_track_top(||self.tracks_with_sizes_scrolled(), .middle(self.w_mid(), per_track_top(||self.tracks_with_sizes_scrolled(),
|_, t|io_conns( |_, t|io_conns(
t.color.dark.rgb, t.color.dark.rgb,
t.color.darker.rgb, t.color.darker.rgb,
@ -116,14 +116,14 @@ impl Arrangement {
))) )))
} }
fn view_output_nexts (&self) -> impl Content<TuiOut> + '_ { fn view_output_nexts (&self) -> impl Content<TuiOut> + '_ {
Tryptich::top(2).left(self.width_side(), Align::ne("From clip:")) Tryptich::top(2).left(self.w_side(), Align::ne("From clip:"))
.middle(self.width_mid(), per_track_top(||self.tracks_with_sizes_scrolled(), .middle(self.w_mid(), per_track_top(||self.tracks_with_sizes_scrolled(),
|_, _|Tui::bg(Reset, Align::c(Bsp::s(" ------ ", OctaveVertical::default()))))) |_, _|Tui::bg(Reset, Align::c(Bsp::s(" ------ ", OctaveVertical::default())))))
} }
fn view_output_froms (&self) -> impl Content<TuiOut> + '_ { fn view_output_froms (&self) -> impl Content<TuiOut> + '_ {
let label = Align::ne("Next clip:"); let label = Align::ne("Next clip:");
Tryptich::top(2).left(self.width_side(), label) Tryptich::top(2).left(self.w_side(), label)
.middle(self.width_mid(), per_track_top( .middle(self.w_mid(), per_track_top(
||self.tracks_with_sizes_scrolled(), |t, track|{ ||self.tracks_with_sizes_scrolled(), |t, track|{
let queued = track.sequencer.next_clip.is_some(); let queued = track.sequencer.next_clip.is_some();
let queued_blank = Thunk::new(||Tui::bg(Reset, " ------ ")); let queued_blank = Thunk::new(||Tui::bg(Reset, " ------ "));
@ -143,15 +143,15 @@ impl Arrangement {
} }
/// Render track headers /// Render track headers
fn view_tracks_0 (&self) -> impl Content<TuiOut> + '_ { fn view_tracks_0 (&self) -> impl Content<TuiOut> + '_ {
let width_side = self.width_side(); let w_side = self.w_side();
let width_mid = self.width_mid(); let w_mid = self.w_mid();
let is_editing = false; // FIXME let is_editing = false; // FIXME
let track_selected = self.track_selected(); let track_selected = self.arrangement().selection().track();
Tryptich::center(3) Tryptich::center(3)
.left(width_side, .left(w_side,
button_3("t", "track", format!("{}", self.tracks().len()), is_editing)) button_3("t", "track", format!("{}", self.tracks().len()), is_editing))
.right(width_side, button_2("T", "add track", is_editing)) .right(w_side, button_2("T", "add track", is_editing))
.middle(width_mid, per_track(||self.tracks_with_sizes_scrolled(), .middle(w_mid, per_track(||self.tracks_with_sizes_scrolled(),
move|index, track|wrap( move|index, track|wrap(
if track_selected == Some(index) { if track_selected == Some(index) {
track.color.light track.color.light
@ -164,14 +164,14 @@ impl Arrangement {
} }
/// Render device switches. /// Render device switches.
fn view_devices_0 (&self) -> impl Content<TuiOut> + '_ { fn view_devices_0 (&self) -> impl Content<TuiOut> + '_ {
let width_side = self.width_side(); let w_side = self.w_side();
let width_mid = self.width_mid(); let w_mid = self.w_mid();
let is_editing = false; // FIXME let is_editing = false; // FIXME
let track_selected = self.track_selected(); let track_selected = self.arrangement().selection().track();
Tryptich::top(1) Tryptich::top(1)
.left(width_side, button_3("d", "devices", format!("{}", 0), is_editing)) .left(w_side, button_3("d", "devices", format!("{}", 0), is_editing))
.right(width_side, button_2("D", "add device", is_editing)) .right(w_side, button_2("D", "add device", is_editing))
.middle(width_mid, per_track_top(||self.tracks_with_sizes_scrolled(), .middle(w_mid, per_track_top(||self.tracks_with_sizes_scrolled(),
move|index, track|{ move|index, track|{
let bg = if track_selected == Some(index) { let bg = if track_selected == Some(index) {
track.color.light track.color.light
@ -185,12 +185,13 @@ impl Arrangement {
} }
impl<T> TracksView for T impl<T> TracksView for T
where T: HasSize<TuiOut> + HasTrackScroll + HasSelection + HasMidiIns {} where T: HasSize<TuiOut> + HasTrackScroll + HasSelection + HasMidiIns + HasEditor {}
impl ClipsView for Arrangement {} impl ClipsView for Arrangement {}
pub trait TracksView: HasSize<TuiOut> + HasTrackScroll + HasSelection + HasMidiIns { pub trait TracksView:
fn is_editing (&self) -> bool { false } HasSize<TuiOut> + HasTrackScroll + HasSelection + HasMidiIns + HasEditor
{
fn tracks_width_available (&self) -> u16 { fn tracks_width_available (&self) -> u16 {
(self.width() as u16).saturating_sub(40) (self.width() as u16).saturating_sub(40)
} }
@ -230,19 +231,23 @@ pub trait TracksView: HasSize<TuiOut> + HasTrackScroll + HasSelection + HasMidiI
for track in self.tracks().iter() { for track in self.tracks().iter() {
max_outputs = max_outputs.max(track.sequencer.midi_outs.len() as u16); max_outputs = max_outputs.max(track.sequencer.midi_outs.len() as u16);
} }
let content = Align::w(Fixed::y(max_outputs + 1, let content = Align::w(Fixed::y(1 + max_outputs*2,
Tui::bg(theme.darker.rgb, Align::w(Fill::x( Tui::bg(theme.darker.rgb, Align::w(Fill::x(
Stack::east(move|add: &mut dyn FnMut(&dyn Render<TuiOut>)|{ Stack::east(move|add: &mut dyn FnMut(&dyn Render<TuiOut>)|{
for (index, track, x1, x2) in self for (index, track, x1, x2) in self
.tracks_with_sizes(&self.selection(), None) .tracks_with_sizes(&self.selection(), None)
.skip(self.track_scroll()) .skip(self.track_scroll())
{ {
(add)(&Fixed::x(track.width as u16, Align::nw(Bsp::s( add(&Fixed::x(track.width as u16, Align::nw(Bsp::s(
Tui::bg(track.color.base.rgb, Fill::x(Align::w(format!("[mut] [sol]")))), Tui::bg(if self.selection().track() == Some(index) {
Map::south(1, ||track.sequencer.midi_outs.iter(), track.color.light.rgb
} else {
track.color.base.rgb
}, Fill::x(Align::w(format!("[mut] [sol]")))),
Map::south(2, ||track.sequencer.midi_outs.iter(),
|port, index|Tui::fg(Rgb(255, 255, 255), |port, index|Tui::fg(Rgb(255, 255, 255),
Tui::bg(track.color.dark.rgb, Fill::x(Align::w( Fixed::y(2, Tui::bg(track.color.dark.rgb, Fill::x(Align::w(
format!("{index}: {}", port.name())))))))))); format!("o{index}: {}", port.name())))))))))));
} }
})))))); }))))));
Bsp::w( Bsp::w(
@ -270,7 +275,7 @@ pub trait TracksView: HasSize<TuiOut> + HasTrackScroll + HasSelection + HasMidiI
Fill::x(Align::w(format!("[rec] [mon]")))), Fill::x(Align::w(format!("[rec] [mon]")))),
Map::south(1, ||track.sequencer.midi_ins.iter(), Map::south(1, ||track.sequencer.midi_ins.iter(),
|port, index|Tui::fg_bg(Rgb(255, 255, 255), track.color.dark.rgb, |port, index|Tui::fg_bg(Rgb(255, 255, 255), track.color.dark.rgb,
Fill::x(Align::w(format!("{index}: {}", port.name()))))))))); Fill::x(Align::w(format!("i{index}: {}", port.name())))))))));
} }
})))); }))));
@ -300,28 +305,26 @@ pub trait TracksView: HasSize<TuiOut> + HasTrackScroll + HasSelection + HasMidiI
{ {
add(&Fixed::xy(track.width as u16, h + 1, add(&Fixed::xy(track.width as u16, h + 1,
Tui::bg(track.color.dark.rgb, Align::nw(Map::south(1, move||0..h, Tui::bg(track.color.dark.rgb, Align::nw(Map::south(1, move||0..h,
|_, index|format!("{index}: {}", "--------")))))); |_, index|format!("d{index}: {}", "--------"))))));
} }
})))))) }))))))
} }
fn view_track_header <'a, T: Content<TuiOut>> ( fn view_track_header <'a, T: Content<TuiOut>> (
&'a self, theme: ItemTheme, content: T &'a self, theme: ItemTheme, content: T
) -> impl Content<TuiOut> { ) -> impl Content<TuiOut> {
Fixed::x(20, Tui::bg(theme.darker.rgb, Fill::x(Align::e(content)))) Fixed::x(12, Tui::bg(theme.darker.rgb, Fill::x(Align::e(content))))
} }
} }
pub trait ScenesView: HasSelection + HasSceneScroll + Send + Sync { pub trait ScenesView: HasSelection + HasSceneScroll + Send + Sync {
/// Default scene height. /// Default scene height.
const H_SCENE: usize = 2; const H_SCENE: usize = 2;
/// Default editor height. /// Default editor height.
const H_EDITOR: usize = 15; const H_EDITOR: usize = 15;
fn arrangement (&self) -> &Arrangement; fn arrangement (&self) -> &Arrangement;
fn scene_selected (&self) -> Option<usize>; fn h_scenes (&self) -> u16;
fn track_selected (&self) -> Option<usize>; fn w_side (&self) -> u16;
fn scenes_height (&self) -> u16; fn w_mid (&self) -> u16;
fn width_side (&self) -> u16;
fn width_mid (&self) -> u16;
fn view_scenes_names (&self) -> impl Content<TuiOut> { fn view_scenes_names (&self) -> impl Content<TuiOut> {
Stack::south(move|add: &mut dyn FnMut(&dyn Render<TuiOut>)|{ Stack::south(move|add: &mut dyn FnMut(&dyn Render<TuiOut>)|{
for (index, scene) in self.scenes().iter().enumerate().skip(self.scene_scroll()) { for (index, scene) in self.scenes().iter().enumerate().skip(self.scene_scroll()) {
@ -338,7 +341,7 @@ pub trait ScenesView: HasSelection + HasSceneScroll + Send + Sync {
format!(" {index:2} "), format!(" {index:2} "),
Tui::fg(Rgb(255, 255, 255), Tui::fg(Rgb(255, 255, 255),
Tui::bold(true, format!("{}", scene.name))))))) Tui::bold(true, format!("{}", scene.name)))))))
//let height = (1 + y2 - y1) as u16; //let height = (1 + y2 - y1 as u16;
//let name = Some(scene.name.clone()); //let name = Some(scene.name.clone());
//let content = Fill::x(Align::w(Tui::bold(true, Bsp::e(" ⯈ ", name)))); //let content = Fill::x(Align::w(Tui::bold(true, Bsp::e(" ⯈ ", name))));
//let selected = self.scene_selected() == Some(s); //let selected = self.scene_selected() == Some(s);
@ -387,11 +390,11 @@ pub trait ScenesView: HasSelection + HasSceneScroll + Send + Sync {
false, // FIXME self.is_editing(), false, // FIXME self.is_editing(),
Self::H_SCENE, Self::H_EDITOR, Self::H_SCENE, Self::H_EDITOR,
selection.track(), selection.scene(), selection.track(), selection.scene(),
).map_while(|(s, scene, y1, y2)|(y2<=self.scenes_height() as usize) ).map_while(|(s, scene, y1, y2)|(y2<=self.h_scenes() as usize)
.then_some((s, scene, y1, y2))) .then_some((s, scene, y1, y2)))
} }
/// Height required to display all scenes. /// Height required to display all scenes.
fn scenes_height_total (&self, is_editing: bool) -> u16 { fn h_scenes_total (&self, is_editing: bool) -> u16 {
self.scenes_with_sizes( self.scenes_with_sizes(
is_editing, is_editing,
Self::H_SCENE, Self::H_SCENE,
@ -405,7 +408,7 @@ pub trait ScenesView: HasSelection + HasSceneScroll + Send + Sync {
} }
pub trait ClipsView: TracksView + ScenesView + Send + Sync { pub trait ClipsView: TracksView + ScenesView + Send + Sync {
fn view_scenes_clips <'a> (&'a self, editor: &'a Option<MidiEditor>) fn view_scenes_clips <'a> (&'a self)
-> impl Content<TuiOut> + 'a -> impl Content<TuiOut> + 'a
{ {
Fill::xy(Stack::<TuiOut, _>::east(move|column: &mut dyn FnMut(&dyn Render<TuiOut>)|{ Fill::xy(Stack::<TuiOut, _>::east(move|column: &mut dyn FnMut(&dyn Render<TuiOut>)|{

24
crates/device/src/editor/editor_model.rs
View file

@ -103,12 +103,24 @@ impl MidiViewer for MidiEditor {
fn set_clip (&mut self, p: Option<&Arc<RwLock<MidiClip>>>) { self.mode.set_clip(p) } fn set_clip (&mut self, p: Option<&Arc<RwLock<MidiClip>>>) { self.mode.set_clip(p) }
} }
pub trait HasEditor { impl<T: Has<Option<MidiEditor>>> HasEditor for T {}
fn editor (&self) -> Option<&MidiEditor>;
fn editor_mut (&mut self) -> Option<&mut MidiEditor>; pub trait HasEditor: Has<Option<MidiEditor>> {
fn is_editing (&self) -> bool { self.editor().is_some() } fn editor (&self) -> Option<&MidiEditor> {
fn editor_w (&self) -> usize { 0 } self.get().as_ref()
fn editor_h (&self) -> usize { 0 } }
fn editor_mut (&mut self) -> Option<&mut MidiEditor> {
self.get_mut().as_mut()
}
fn is_editing (&self) -> bool {
self.editor().is_some()
}
fn editor_w (&self) -> usize {
self.editor().map(|e|e.size.w()).unwrap_or(0)
}
fn editor_h (&self) -> usize {
self.editor().map(|e|e.size.h()).unwrap_or(0)
}
} }
#[macro_export] macro_rules! has_editor { #[macro_export] macro_rules! has_editor {