unspeaker/tek
1
0
Fork 0
mirror of https://codeberg.org/unspeaker/tek.git synced 2026-10-08 18:56:42 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

open editor

Browse source
This commit is contained in:
i do not exist 2026-09-23 06:22:18 +03:00
parent fdee3fbfc8
commit 6aff4e55a6
6 changed files with 212 additions and 303 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/midi_piano.rs
View file

@ -5,7 +5,7 @@ use crate::*;
/// ``` /// ```
/// let piano = tek::PianoHorizontal::default(); /// let piano = tek::PianoHorizontal::default();
/// ``` /// ```
#[derive(Clone)] pub struct PianoHorizontal { #[derive(Clone, Default)] pub struct PianoHorizontal {
pub clip: ClipSlot, pub clip: ClipSlot,
/// Buffer where the whole clip is rerendered on change /// Buffer where the whole clip is rerendered on change
pub buffer: Arc<RwLock<BigBuffer>>, pub buffer: Arc<RwLock<BigBuffer>>,
@ -23,8 +23,8 @@ use crate::*;
impl_has!(Sizer: |self: PianoHorizontal| self.size); impl_has!(Sizer: |self: PianoHorizontal| self.size);
impl Default for PianoHorizontal { impl PianoHorizontal {
fn default () -> Self { pub fn new () -> Self {
let size = Sizer::default(); let size = Sizer::default();
let mut range = MidiSelection::from((12, true)); let mut range = MidiSelection::from((12, true));
range.time_axis = size.0.clone(); range.time_axis = size.0.clone();

4
src/proj_track.rs
View file

@ -91,10 +91,6 @@ pub trait HasTrack: AsRefOpt<Track> + AsMutOpt<Track> {
} }
} }
pub(crate) fn track_width (_index: usize, track: &Track) -> u16 {
track.width as u16
}
def_sizes_iter!(TracksSizes => Track); def_sizes_iter!(TracksSizes => Track);
impl_has!(Vec<Track>: |self: Project| self.tracks); impl_has!(Vec<Track>: |self: Project| self.tracks);
impl_as_ref!(Vec<Track>: |self: App| self.project.as_ref()); impl_as_ref!(Vec<Track>: |self: App| self.project.as_ref());

48
src/tek.rs
View file

@ -172,9 +172,8 @@ pub struct App {
pub project: Project, pub project: Project,
/// Error, if any /// Error, if any
pub error: Arc<RwLock<Option<Arc<str>>>>, pub error: Arc<RwLock<Option<Arc<str>>>>,
#[cfg(feature = "prof2")]
/// Tracing guard /// Tracing guard
pub guard: Option<tracing_flame::FlushGuard<std::io::BufWriter<std::fs::File>>>, #[cfg(feature = "prof2")] pub guard: Option<tracing_flame::FlushGuard<std::io::BufWriter<std::fs::File>>>,
} }
impl App { impl App {
@ -359,18 +358,17 @@ fn get_vec_arc_str <'a> (_: &App, _: impl Language) -> Perhaps<Vec<Arc<str>>> {
todo!() todo!()
} }
impl_has!(Sizer: |self: App|self.size); impl_has!(Clock: |self: App|self.project.clock);
impl_has!(Dialog: |self: App|self.dialog); impl_has!(Dialog: |self: App|self.dialog);
impl_has!(Jack<'static>: |self: App|self.jack); impl_has!(Jack<'static>: |self: App|self.jack);
impl_has!(Clock: |self: App|self.project.clock);
impl_has!(Pool<MidiClip>: |self: App|self.project.clips); impl_has!(Pool<MidiClip>: |self: App|self.project.clips);
impl_has!(Pool<Sample>: |self: App|self.project.samples); impl_has!(Pool<Sample>: |self: App|self.project.samples);
impl_has!(Selection: |self: App|self.project.selection); impl_has!(Selection: |self: App|self.project.selection);
impl_as_ref!(Option<Project>: |self: App|todo!()); impl_has!(Sizer: |self: App|self.size);
impl_as_mut!(Option<Project>: |self: App|todo!()); impl_as_ref!(Option<Project>: |self: App|todo!());
impl_as_ref!(Option<MidiEditor>: |self: App|self.project.as_ref()); impl_as_mut!(Option<Project>: |self: App|todo!());
impl_as_mut!(Option<MidiEditor>: |self: App|self.project.as_mut()); impl_as_ref!(Option<MidiEditor>: |self: App|self.project.as_ref());
impl_as_mut!(Option<MidiEditor>: |self: App|self.project.as_mut());
impl HasClip for App { impl HasClip for App {
fn clip_slot (&self) -> Option<Slot<MidiClip>> { fn clip_slot (&self) -> Option<Slot<MidiClip>> {
self.project.clip_slot() self.project.clip_slot()
@ -548,26 +546,16 @@ impl Dialog {
Self::Menu(1, Arc::new([ Self::Menu(1, Arc::new([
MenuItem::new(" Resume session ", [ MenuItem::new(" Resume session ", [
AppCmd::Project { AppCmd::Project { command: ProjectCmd::LoadLast }
command: ProjectCmd::LoadLast
}
]), ]),
MenuItem::new(" Create session ", [ MenuItem::new(" Create session ", [
AppCmd::Dialog { AppCmd::Dialog { dialog: Dialog::None },
dialog: Dialog::None AppCmd::Mode { command: ModeCmd::Reset { modes: vec!["Arranger".into()] } },
}, AppCmd::Tracks { command: TracksCmd::Add },
AppCmd::Mode { AppCmd::Scenes { command: ScenesCmd::Add },
command: ModeCmd::Reset { AppCmd::MidiClip { command: MidiClipCmd::Upsert },
modes: vec!["Arranger".into()] AppCmd::MidiEdit { command: MidiEditCmd::Toggle },
}
},
AppCmd::Tracks {
command: TracksCmd::Add
},
AppCmd::Scenes {
command: ScenesCmd::Add
}
]), ]),
MenuItem::new(" Load session ", [ MenuItem::new(" Load session ", [

16
src/tek_ctrl.rs
View file

@ -400,7 +400,7 @@ impl<T: HasScene
} }
} }
impl<T: HasEditor impl<T: HasClip + HasEditor
+ Namespace<u32> + Namespace<u32>
+ Namespace<f64> + Namespace<f64>
+ Namespace<bool> + Namespace<bool>
@ -409,7 +409,7 @@ impl<T: HasEditor
+ Namespace<ClipSlot> + Namespace<ClipSlot>
> MidiEditControl for T {} > MidiEditControl for T {}
#[tek_proc::commands(MidiEditCmd)] pub trait MidiEditControl: HasEditor #[tek_proc::commands(MidiEditCmd)] pub trait MidiEditControl: HasClip + HasEditor
+ Namespace<u32> + Namespace<u32>
+ Namespace<f64> + Namespace<f64>
+ Namespace<bool> + Namespace<bool>
@ -420,8 +420,16 @@ impl<T: HasEditor
#[command(Toggle = "toggle")] fn edit_toggle (&mut self) -> Perhaps<MidiEditCmd> { #[command(Toggle = "toggle")] fn edit_toggle (&mut self) -> Perhaps<MidiEditCmd> {
if self.is_editing() { if self.is_editing() {
*self.editor_mut() = None; *self.editor_mut() = None;
} else { } else if let Some(clip) = self.clip() {
todo!() let editor = MidiEditor {
mode: Default::default(),
size: Sizer(
Arc::new(0usize.into()),
Arc::new(0usize.into()),
),
};
*editor.mode.clip.0.write() = clip.clone();
*self.editor_mut() = Some(editor);
} }
Ok(Some(MidiEditCmd::Toggle)) Ok(Some(MidiEditCmd::Toggle))
} }

439
src/tek_view.rs
View file

@ -385,7 +385,7 @@ impl View<Tui, App> {
Some("MetersIn") => draw!(|___|bg(Rgb(30, 30, 30), "Input Meters".align_s().full_h())), Some("MetersIn") => draw!(|___|bg(Rgb(30, 30, 30), "Input Meters".align_s().full_h())),
Some("MetersOut") => draw!(|___|bg(Rgb(30, 30, 30), "Output Meters".align_s().full_h())), Some("MetersOut") => draw!(|___|bg(Rgb(30, 30, 30), "Output Meters".align_s().full_h())),
Some("ModeList") => draw!(|app|app.modes.read().get(0)), // TODO all Some("ModeList") => draw!(|app|app.modes.read().get(0)), // TODO all
Some("ScenesClips") => draw!(|app|app.view_scenes_clips()), Some("ScenesClips") => draw!(|app|view_scenes_clips(app)),
Some("ScenesNames") => draw!(|app|app.view_scenes_names()), Some("ScenesNames") => draw!(|app|app.view_scenes_names()),
Some("Sessions") => draw!(|___|view_sessions()), Some("Sessions") => draw!(|___|view_sessions()),
Some("Templates") => draw!(|app|view_templates(app)), Some("Templates") => draw!(|app|view_templates(app)),
@ -685,146 +685,69 @@ pub trait TracksView:
}) })
} }
/// Draw name of each track fn view_track_column <'t, S, D, F> (&'t self, f: F) -> impl Draw<S> where
fn view_track_names (&self, theme: ItemTheme) -> impl Draw<Tui> { S: Screen,
view_track_row_section(theme, D: Draw<S> + 't,
self.view_track_names_count(), F: Fn(usize, &'t Track, &Selection, Option<&MidiEditor>)->D + Copy + 't
self.view_track_names_add(), {
self.view_track_names_cells() let select = self.selection();
) let editor = self.editor().as_ref();
}
fn view_track_names_add (&self) -> impl Draw<Tui> {
south(self.view_track_add(), self.view_scene_add())
}
fn view_track_names_count (&self) -> impl Draw<Tui> {
south(self.view_track_count(), self.view_scene_count())
}
fn view_track_names_cells <'a> (&'a self) -> impl Draw<Tui> {
iter_east(||self.tracks_with_sizes().map(|(index, track, _x1, _x2)|{
let b = if self.selection().track() == Some(index) {
track.color.light.term
} else {
track.color.base.term
};
bg(b, south(
east!(
"·t",
index,
" ",
fg(Rgb(255, 255, 255), bold(true, &track.name))
)
.align_nw()
.full_w(),
""
))
.exact_w(track_width(index, track))
.exact_h(2)
}))
}
/// Draw outputs per track
fn view_track_outputs <'a> (&'a self, theme: ItemTheme, _h: u16) -> impl Draw<Tui> {
view_track_row_section(theme,
self.view_track_output_count(),
self.view_track_output_add(),
self.view_track_output_cells()
)
}
fn view_track_output_cells <'a> (&'a self) -> impl Draw<Tui> {
iter_east(move||self.tracks_with_sizes().map(move|(index, track, _x1, _x2)|{
let f = Rgb(255, 255, 255);
let b = track.color.dark.term;
iter_south(move||track.sequencer.midi_outs.iter().map(move|port: &MidiOutput|{
fg(f, bg(b, east!("·o", index, " ", port.port_name()).full_w().align_w()).exact_h(1))
}))
.full_h()
.align_nw()
.exact_w(track_width(index, track))
}))
}
fn view_track_device_count (&self) -> impl Draw<Tui> {
button_3("d", "evice", self.track().map(|t|t.devices.len()).unwrap_or(0), false).min_h(2)
}
fn view_track_devices (&self, theme: ItemTheme) -> impl Draw<Tui> {
let height = self.tracks_devices_height();
let btn1 = self.view_track_device_count();
let btn2 = self.view_track_device_add();
view_track_row_section(theme, btn1, btn2, self.view_track_device_cells(height))
}
fn view_track_device_cells (&self, height: u16) -> impl Draw<Tui> {
iter_east(move||self.tracks_with_sizes() iter_east(move||self.tracks_with_sizes()
.enumerate() .map(move|(i, t, _x1, _x2)|f(i, t, select, editor)))
.map(move|(index, (_, track, _x1, _x2))|bg( }
track.color.dark.term,
iter_south(move||(0..height).map(|_|fg_bg( fn view_track_names_cells (&self) -> impl Draw<Tui> {
ItemTheme::G[32].lightest.term, self.view_track_column(|i, t, select, editor|{
ItemTheme::G[32].dark.term, let b = if select.track() == Some(i) { t.color.light } else { t.color.base }.term;
" · --".align_nw() bg(b, south(east!(
).exact_wh(track.width as u16, 2))) "·t", i, " ", fg(Rgb(255, 255, 255), bold(true, &t.name))
.align_nw() ).align_nw().full_w(), "")).exact_wh(
view_track_w(select, i, t, editor),
2
) )
.exact_wh( })
Some(track_width(index, track)),
Some(height + 1),
)))
} }
fn tracks_devices_height (&self) -> u16 { fn view_track_output_cells (&self) -> impl Draw<Tui> {
let mut h = 2; self.view_track_column(|i, t, select, editor|{
for track in self.tracks().iter() { let f = Rgb(255, 255, 255);
h = h.max(track.devices.len() * 2); let b = t.color.dark.term;
} iter_south(move||t.sequencer.midi_outs.iter().map(move|port: &MidiOutput|{
h as u16 fg(f, bg(b, east!("·o", i, " ", port.port_name()).full_w().align_w()).exact_h(1))
})).full_h().align_nw().exact_w(
view_track_w(select, i, t, editor)
)
})
} }
fn view_inputs (&self) -> impl Draw<Tui> + '_ { fn view_track_device_cells (&self, height: u16) -> impl Draw<Tui> + '_ {
let title_1 = button_3("i", "nput ", self.midi_ins().len(), false).align_w().exact_wh(20, 1); self.view_track_column(move|i, t, select, editor|bg(
let title_2 = self.view_track_input_add().exact_wh(4, 1); t.color.dark.term,
east(title_1, west(title_2, self.view_input_cells())) iter_south(move||(0..height).map(|_|fg_bg(
} ItemTheme::G[32].lightest.term,
ItemTheme::G[32].dark.term,
fn tracks_inputs_height (&self) -> u16 { " · --".align_nw()
let mut height = 0u16; ).exact_wh(t.width as u16, 2))).align_nw()
for track in self.tracks().iter() { ).exact_wh(
height = height.max(track.sequencer.midi_ins.len() as u16); view_track_w(select, i, t, editor),
} height + 1
height ))
}
/// Draw inputs per track
fn view_track_inputs <'a> (&'a self, theme: ItemTheme) -> impl Draw<Tui> {
view_track_row_section(theme,
self.view_track_input_count(),
self.view_track_input_add(),
self.view_track_input_cells(self.tracks_inputs_height())
)
} }
fn view_track_input_cells (&self, height: u16) -> impl Draw<Tui> { fn view_track_input_cells (&self, height: u16) -> impl Draw<Tui> {
iter_east(move||self self.view_track_column(move|i, t, select, editor|south(
.tracks_with_sizes() bg(t.color.base.term,
.map(move|(index, track, _x1, _x2)|{ east!(
south( either(t.sequencer.monitoring, fg(Green, "●mon "), "·mon "),
bg(track.color.base.term, either(t.sequencer.recording, fg(Red, "●rec "), "·rec "),
east!( either(t.sequencer.overdub, fg(Yellow, "●dub "), "·dub "),
either(track.sequencer.monitoring, fg(Green, "●mon "), "·mon "), ).align_w().full_w()),
either(track.sequencer.recording, fg(Red, "●rec "), "·rec "), iter_south(move||t.sequencer.midi_ins.iter().map(move|port|fg_bg(
either(track.sequencer.overdub, fg(Yellow, "●dub "), "·dub "), Rgb(255, 255, 255), t.color.dark.term, east!(
).align_w().full_w()), "·i", i, " ", port.port_name()
iter_south(move||track.sequencer.midi_ins.iter().map(move|port|fg_bg( ).align_w().full_w()
Rgb(255, 255, 255), )))).align_nw().exact_wh(view_track_w(select, i, t, editor), height + 1)
track.color.dark.term, ).align_w()
east!("·i", index, " ", port.port_name()).align_w().full_w()))))
.align_nw()
.exact_wh(track_width(index, track), height + 1)
})).align_w()
} }
fn view_input_cells (&self) -> impl Draw<Tui> { fn view_input_cells (&self) -> impl Draw<Tui> {
@ -861,14 +784,6 @@ pub trait TracksView:
}) })
} }
fn outputs_height (&self) -> u16 {
let mut h = 1;
for output in self.midi_outs().iter() {
h += 1 + output.connections.len();
}
h as u16
}
fn view_outputs (&self, theme: ItemTheme) -> impl Draw<Tui> { fn view_outputs (&self, theme: ItemTheme) -> impl Draw<Tui> {
let height = self.outputs_height(); let height = self.outputs_height();
let list = south( let list = south(
@ -921,54 +836,68 @@ pub trait TracksView:
}).align_w().full_w())).exact_h(height) }).align_w().full_w())).exact_h(height)
} }
fn view_track_count (&self) -> impl Draw<Tui> { fn tracks_devices_height (&self) -> u16 { self.tracks().iter().fold(2, |h, t|h.max(t.devices.len() * 2)) as u16 }
button_3("t", "rack ", east( fn tracks_inputs_height (&self) -> u16 { self.tracks().iter().fold(0, |h, t|h.max(t.sequencer.midi_ins.len())) as u16 }
self.selection().track().map(|track|east(track, "/")), fn outputs_height (&self) -> u16 { self.midi_outs().iter().fold(1, |h, o|h + o.connections.len()) as u16 }
self.tracks().len()
), false) fn view_track_add (&self) -> impl Draw<Tui> { button_2("T", "+", false) }
fn view_scene_add (&self) -> impl Draw<Tui> { button_2("S", "+", false) }
fn view_track_output_add (&self) -> impl Draw<Tui> { button_2("O", "+", false) }
fn view_track_input_add (&self) -> impl Draw<Tui> { button_2("I", "+", false) }
fn view_track_device_add (&self) -> impl Draw<Tui> { button_2("D", "+", false) }
fn view_track_names_add (&self) -> impl Draw<Tui> { south(self.view_track_add(), self.view_scene_add()) }
fn view_track_count (&self) -> impl Draw<Tui> { view_n_of_m("t", "rack", self.selection().track(), self.tracks().len()); }
fn view_scene_count (&self) -> impl Draw<Tui> { view_n_of_m("s", "cene", self.selection().scene(), self.scenes().len()); }
fn view_track_input_count (&self) -> impl Draw<Tui> { button_2("i", "nput", false) }
fn view_track_output_count (&self) -> impl Draw<Tui> { button_3("o", "utput", 0, false) }
fn view_track_names_count (&self) -> impl Draw<Tui> { south(self.view_track_count(), self.view_scene_count()) }
fn view_track_device_count (&self) -> impl Draw<Tui> { button_3("d", "evice", self.track().map(|t|t.devices.len()).unwrap_or(0), false).min_h(2) }
/// Draw outputs per track
fn view_track_outputs <'a> (&'a self, theme: ItemTheme, _h: u16) -> impl Draw<Tui> {
view_track_row_section(theme,
self.view_track_output_count(),
self.view_track_output_add(),
self.view_track_output_cells()
)
} }
fn view_scene_count (&self) -> impl Draw<Tui> { /// Draw name of each track
button_3("s", "cene ", east( fn view_track_names (&self, theme: ItemTheme) -> impl Draw<Tui> {
self.selection().scene().map(|scene|east(scene, "/")), view_track_row_section(theme,
self.scenes().len() self.view_track_names_count(),
), false) self.view_track_names_add(),
self.view_track_names_cells()
)
} }
fn view_track_add (&self) -> impl Draw<Tui> { /// Draw inputs per track
button_2("T", "+", false) fn view_track_inputs <'a> (&'a self, theme: ItemTheme) -> impl Draw<Tui> {
view_track_row_section(theme,
self.view_track_input_count(),
self.view_track_input_add(),
self.view_track_input_cells(self.tracks_inputs_height())
)
} }
fn view_scene_add (&self) -> impl Draw<Tui> { fn view_track_devices (&self, theme: ItemTheme) -> impl Draw<Tui> {
button_2("S", "+", false) let height = self.tracks_devices_height();
let btn1 = self.view_track_device_count();
let btn2 = self.view_track_device_add();
view_track_row_section(theme, btn1, btn2, self.view_track_device_cells(height))
} }
fn view_track_input_count (&self) -> impl Draw<Tui> { fn view_inputs (&self) -> impl Draw<Tui> + '_ {
button_2("i", "nput", false) let title_1 = button_3("i", "nput ", self.midi_ins().len(), false).align_w().exact_wh(20, 1);
let title_2 = self.view_track_input_add().exact_wh(4, 1);
east(title_1, west(title_2, self.view_input_cells()))
} }
fn view_track_output_count (&self) -> impl Draw<Tui> { }
button_3("o", "utput", 0, false)
//draw(|to: &mut Tui|{
//for port in self.midi_outs().iter() {
//let _ = port.port_name().align_w().full_w().draw(to)?;
//}
//Ok(Some(XYWH(0, 0, 0, 0)))
//})),
}
fn view_track_output_add (&self) -> impl Draw<Tui> {
button_2("O", "+", false)
}
fn view_track_input_add (&self) -> impl Draw<Tui> {
button_2("I", "+", false)
}
fn view_track_device_add (&self) -> impl Draw<Tui> {
button_2("D", "+", false)
}
fn view_n_of_m (key: &str, name: &str, index: Option<usize>, count: usize) -> impl Draw<Tui> {
button_3(key, name, east(index, count), false)
} }
pub trait ScenesView: HasEditor + HasSelection + HasSceneScroll + HasClipsSize + Send + Sync { pub trait ScenesView: HasEditor + HasSelection + HasSceneScroll + HasClipsSize + Send + Sync {
@ -1028,41 +957,78 @@ impl ScenesView for Project {
} }
} }
impl<T: TracksView + ScenesView + Send + Sync> ClipsView for T {} /// Draw clips per scene
fn view_scenes_clips <S: TracksView + ScenesView> (state: &S) -> impl Draw<Tui> {
pub trait ClipsView: TracksView + ScenesView { let select = state.selection();
let editor = state.editor();
/// Draw clips per scene let editing = state.is_editing();
fn view_scenes_clips (&self) -> impl Draw<Tui> { let sized = move|it|state.with_clips_size(true, it).align_c();
let select = self.selection(); let tracks = move|it|iter_east(move||state.tracks_with_sizes().map(it));
let editor = self.editor(); let scenes = move|it|iter_south(move||state.scenes_with_sizes().map(it));
let editing = self.is_editing(); sized(tracks(move|(track_index, track, _, _)|{
self.with_clips_size(true, iter_east(move||self.tracks_with_sizes() let w = view_track_w(select, track_index, track, editor.as_ref()) as u16;
.map(move|(track_index, track, _, _)|iter_south(move||self.scenes_with_sizes() scenes(move|(scene_index, scene, _, _)|{
.map(move|(scene_index, scene, _, _)|{ let (name, theme): (Arc<str>, ItemTheme) = view_scene_name_theme(scene, track_index);
let (name, theme): (Arc<str>, ItemTheme) = view_scene_name_theme(scene, track_index); let f = theme.lightest.term;
let f = theme.lightest.term; let (b, o) = view_scene_bg(theme, select, track_index, scene_index);
let (b, o) = view_scene_bg(theme, select, track_index, scene_index); let is_sel = view_scene_sel(select, track_index, scene_index, editing);
let is_selected = view_scene_sel(select, track_index, scene_index, editing); below(
Outer(true, Style::default().fg(o)).full_wh(),
below(
below( below(
Outer(true, Style::default().fg(o)).full_wh(), fg_bg(o, b, "".full_wh()),
below( fg_bg(f, b, bold(true, name)).align_nw().full_wh(),
below( ),
fg_bg(o, b, "".full_wh()), when(is_sel, editor).full_wh()
fg_bg(f, b, bold(true, name)).align_nw().full_wh(), ).full_wh()
), ).exact_wh(w, view_scene_y(select, scene_index, editor.as_ref()),)
when(is_selected, editor).full_wh() }).exact_w(w)
).full_wh() }))
).exact_wh( }
view_scene_w(track, select, track_index, editor.as_ref()),
view_scene_y(select, scene_index, editor.as_ref()),
)
})
)
.exact_w(track.width as u16))
)).align_c()
}
pub fn view_scene_bg (
theme: ItemTheme, select: &Selection, track_index: usize, scene_index: usize
) -> (Color, Color) {
let mut outline = theme.base.term;
(if select.track() == Some(track_index) && select.scene() == Some(scene_index) {
outline = theme.lighter.term;
theme.light.term
} else if select.track() == Some(track_index) || select.scene() == Some(scene_index) {
outline = theme.darkest.term;
theme.base.term
} else {
theme.dark.term
}, outline)
}
pub fn view_scene_sel (
select: &Selection, track_index: usize, scene_index: usize, editing: bool
) -> bool {
editing && select.track() == Some(track_index) && select.scene() == Some(scene_index)
}
pub fn view_track_w (
select: &Selection, track_index: usize, track: &Track, editor: Option<&MidiEditor>
) -> u16 {
if select.track() == Some(track_index) && let Some(editor) = editor {
(editor.size.w() as usize).max(24).max(track.width) as u16
} else {
track.width as u16
}
}
pub(crate) fn track_width (_index: usize, track: &Track) -> u16 {
track.width as u16
}
pub fn view_scene_y (
select: &Selection, scene_index: usize, editor: Option<&MidiEditor>
) -> u16 {
if select.scene() == Some(scene_index) && let Some(editor) = editor {
editor.size.h().max(12)
} else {
Scene::DEFAULT_HEIGHT as u16
}
} }
pub fn draw_sample ( pub fn draw_sample (
@ -1277,45 +1243,6 @@ pub fn view_scene_name_theme (scene: &Scene, track_index: usize) -> (Arc<str>, I
}) })
} }
pub fn view_scene_bg (
theme: ItemTheme, select: &Selection, track_index: usize, scene_index: usize
) -> (Color, Color) {
let mut outline = theme.base.term;
(if select.track() == Some(track_index) && select.scene() == Some(scene_index) {
outline = theme.lighter.term;
theme.light.term
} else if select.track() == Some(track_index) || select.scene() == Some(scene_index) {
outline = theme.darkest.term;
theme.base.term
} else {
theme.dark.term
}, outline)
}
pub fn view_scene_w (
track: &Track, select: &Selection, track_index: usize, editor: Option<&MidiEditor>
) -> u16 {
if select.track() == Some(track_index) && let Some(editor) = editor {
(editor.size.w() as usize).max(24).max(track.width) as u16
} else {
track.width as u16
}
}
pub fn view_scene_y (
select: &Selection, scene_index: usize, editor: Option<&MidiEditor>
) -> u16 {
if select.scene() == Some(scene_index) && let Some(editor) = editor {
editor.size.h().max(12)
} else {
Scene::DEFAULT_HEIGHT as u16
}
}
pub fn view_scene_sel (select: &Selection, track_index: usize, scene_index: usize, editing: bool) -> bool {
editing && select.track() == Some(track_index) && select.scene() == Some(scene_index)
}
pub fn view_templates <'a> (state: &'a App) -> impl Draw<Tui> + use<'a> { pub fn view_templates <'a> (state: &'a App) -> impl Draw<Tui> + use<'a> {
let height = (state.config.modes.len() * 2) as u16; let height = (state.config.modes.len() * 2) as u16;
draw(move |to: &mut Tui|{ draw(move |to: &mut Tui|{
@ -1635,23 +1562,13 @@ impl PianoHorizontal {
}; };
} }
pub struct Memo<T, U> { pub struct Memo<T, U> { value: T, view: U, }
value: T, impl<T, U> Memo<T, U> { pub fn new (value: T, view: U) -> Self { Self { value, view } } }
view: U,
}
impl<T, U> Memo<T, U> {
pub fn new (value: T, view: U) -> Self {
Self { value, view }
}
}
impl<T: PartialEq + Debug, U: Debug> Debug for Memo<T, U> { impl<T: PartialEq + Debug, U: Debug> Debug for Memo<T, U> {
fn fmt (&self, _: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> { fn fmt (&self, _: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
todo!() todo!()
} }
} }
impl<T: PartialEq, U> Memo<T, U> { impl<T: PartialEq, U> Memo<T, U> {
pub fn update <R> (&mut self, newval: T, render: impl Fn(&mut U, &T, &T)->R) -> Option<R> { pub fn update <R> (&mut self, newval: T, render: impl Fn(&mut U, &T, &T)->R) -> Option<R> {
if newval != self.value { if newval != self.value {

2
tengri

@ -1 +1 @@
Subproject commit 7237121a508556ee98714a6af387e325a371e368 Subproject commit 21d6674ffb81b78eb7efe281c43f0a085cbd94ad