unspeaker/tek
1
0
Fork 0
mirror of https://codeberg.org/unspeaker/tek.git synced 2025-05-02 06:40:14 +02:00
Code Issues Actions1 Packages Projects Releases Wiki Activity

fold view_iter

Browse source
This commit is contained in:
🪞👃🪞 2025-03-17 00:15:03 +02:00
parent 74ce1b9f55
commit fbcf148293
5 changed files with 143 additions and 139 deletions

122
app/src/view.rs
View file

@ -1,7 +1,6 @@
use crate::*;
mod view_clock; pub use self::view_clock::*;
mod view_color; pub use self::view_color::*;
mod view_iter; pub use self::view_iter::*;
mod view_memo; pub use self::view_memo::*;
mod view_meter; pub use self::view_meter::*;
mod view_sizes; pub use self::view_sizes::*;
@ -64,6 +63,8 @@ pub(crate) struct ArrangerView<'a> {
track_count: usize,
track_selected: Option<usize>,
tracks_height: u16,
show_debug_info: bool,
}
impl<'a> Content<TuiOut> for ArrangerView<'a> {
@ -113,15 +114,122 @@ impl<'a> ArrangerView<'a> {
total: app.h_scenes() as usize,
})),
show_debug_info: false
}
}
pub(crate) fn inputs_with_sizes (&'a self) -> impl PortsSizes<'a> {
self.app.inputs_sizes()
pub(crate) fn tracks_with_sizes_scrolled (&'a self)
-> impl TracksSizes<'a>
{
let width = self.width_mid;
self.app.tracks_with_sizes().map_while(move|(t, track, x1, x2)|{
(width > x2 as u16).then_some((t, track, x1, x2))
})
}
pub(crate) fn outputs_with_sizes (&'a self) -> impl PortsSizes<'a> {
self.app.outputs_sizes()
pub(crate) fn scenes_with_scene_colors (&self)
-> impl ScenesColors<'_>
{
self.app.scenes_with_sizes(self.is_editing, Tek::H_SCENE, Tek::H_EDITOR).map_while(
move|(s, scene, y1, y2)|if y2 as u16 > self.tracks_height {
None
} else { Some((s, scene, y1, y2, if s == 0 {
None
} else {
Some(self.app.scenes()[s-1].color)
}))
})
}
pub(crate) fn tracks_with_sizes (&'a self) -> impl TracksSizes<'a> {
self.app.tracks_sizes_scrolled()
pub(crate) fn scenes_with_track_colors (&self)
-> impl ScenesColors<'_>
{
self.app.scenes_with_sizes(self.is_editing, Tek::H_SCENE, Tek::H_EDITOR).map_while(
move|(s, scene, y1, y2)|if y2 as u16 > self.tracks_height {
None
} else { Some((s, scene, y1, y2, if s == 0 {
None
} else {
Some(self.app.scenes[s-1].clips[self.track_selected.unwrap_or(0)].as_ref()
.map(|c|c.read().unwrap().color)
.unwrap_or(ItemPalette::G[32]))
}))
})
}
}
impl Tek {
pub(crate) fn inputs_with_sizes (&self)
-> impl PortsSizes<'_>
{
let mut y = 0;
self.midi_ins.iter().enumerate().map(move|(i, input)|{
let height = 1 + input.conn().len();
let data = (i, input.name(), input.conn(), y, y + height);
y += height;
data
})
}
pub(crate) fn outputs_with_sizes (&self)
-> impl PortsSizes<'_>
{
let mut y = 0;
self.midi_outs.iter().enumerate().map(move|(i, output)|{
let height = 1 + output.conn().len();
let data = (i, output.name(), output.conn(), y, y + height);
y += height;
data
})
}
pub(crate) fn tracks_with_sizes (&self)
-> impl TracksSizes<'_>
{
let mut x = 0;
let editing = self.is_editing();
let active = match self.selected() {
Selection::Track(t) if editing => Some(t),
Selection::Clip(t, _) if editing => Some(t),
_ => None
};
let bigger = self.editor_w();
self.tracks().iter().enumerate().map(move |(index, track)|{
let width = if Some(index) == active.copied() { bigger } else { track.width.max(8) };
let data = (index, track, x, x + width);
x += width + Tek::TRACK_SPACING;
data
})
}
pub(crate) fn scenes_with_sizes (&self, editing: bool, height: usize, larger: usize)
-> impl ScenesSizes<'_>
{
let (selected_track, selected_scene) = match self.selected() {
Selection::Track(t) => (Some(*t), None),
Selection::Scene(s) => (None, Some(*s)),
Selection::Clip(t, s) => (Some(*t), Some(*s)),
_ => (None, None)
};
let mut y = 0;
self.scenes().iter().enumerate().map(move|(s, scene)|{
let active = editing && selected_track.is_some() && selected_scene == Some(s);
let height = if active { larger } else { height };
let data = (s, scene, y, y + height);
y += height;
data
})
}
}
#[cfg(test)] #[test] fn test_view_iter () {
let mut tek = Tek::default();
tek.editor = Some(Default::default());
let _: Vec<_> = tek.inputs_with_sizes().collect();
let _: Vec<_> = tek.outputs_with_sizes().collect();
let _: Vec<_> = tek.tracks_with_sizes().collect();
let _: Vec<_> = tek.scenes_with_sizes(true, 10, 10).collect();
let _: Vec<_> = tek.scenes_with_colors(true, 10).collect();
let _: Vec<_> = tek.scenes_with_track_colors(true, 10, 10).collect();
}

94
app/src/view/view_iter.rs
View file

@ -1,94 +0,0 @@
use crate::*;
impl Tek {
pub(crate) fn inputs_sizes (&self) -> impl PortsSizes<'_> {
let mut y = 0;
self.midi_ins.iter().enumerate().map(move|(i, input)|{
let height = 1 + input.conn().len();
let data = (i, input.name(), input.conn(), y, y + height);
y += height;
data
})
}
pub(crate) fn outputs_sizes (&self) -> impl PortsSizes<'_> {
let mut y = 0;
self.midi_outs.iter().enumerate().map(move|(i, output)|{
let height = 1 + output.conn().len();
let data = (i, output.name(), output.conn(), y, y + height);
y += height;
data
})
}
pub(crate) fn tracks_sizes <'a> (&'a self) -> impl TracksSizes<'a> {
let editing = self.is_editing();
let bigger = self.editor_w();
let mut x = 0;
let active = match self.selected() {
Selection::Track(t) if editing => Some(t),
Selection::Clip(t, _) if editing => Some(t),
_ => None
};
self.tracks().iter().enumerate().map(move |(index, track)|{
let width = if Some(index) == active.copied() { bigger } else { track.width.max(8) };
let data = (index, track, x, x + width);
x += width + Self::TRACK_SPACING;
data
})
}
pub(crate) fn tracks_sizes_scrolled <'a> (&'a self) -> impl TracksSizes<'a> {
let width = self.w_tracks_area();
self.tracks_sizes().map_while(move|(t, track, x1, x2)|{
(width > x2 as u16).then_some((t, track, x1, x2))
})
}
pub(crate) fn scenes_sizes (&self, editing: bool, height: usize, larger: usize) -> impl ScenesSizes<'_> {
let (selected_track, selected_scene) = match self.selected() {
Selection::Track(t) => (Some(*t), None),
Selection::Scene(s) => (None, Some(*s)),
Selection::Clip(t, s) => (Some(*t), Some(*s)),
_ => (None, None)
};
let mut y = 0;
self.scenes().iter().enumerate().map(move|(s, scene)|{
let active = editing && selected_track.is_some() && selected_scene == Some(s);
let height = if active { larger } else { height };
let data = (s, scene, y, y + height);
y += height;
data
})
}
pub(crate) fn scenes_with_colors (&self, editing: bool, h: u16) -> impl ScenesColors<'_> {
self.scenes_sizes(editing, Self::H_SCENE, Self::H_EDITOR).map_while(
move|(s, scene, y1, y2)|if y2 as u16 > h {
None
} else { Some((s, scene, y1, y2, if s == 0 {
None
} else {
Some(self.scenes[s-1].color)
}))
})
}
pub(crate) fn scenes_with_track_colors (&self, editing: bool, h: u16, t: usize) -> impl ScenesColors<'_> {
self.scenes_sizes(editing, Self::H_SCENE, Self::H_EDITOR).map_while(
move|(s, scene, y1, y2)|if y2 as u16 > h {
None
} else { Some((s, scene, y1, y2, if s == 0 {
None
} else {
Some(self.scenes[s-1].clips[t].as_ref()
.map(|c|c.read().unwrap().color)
.unwrap_or(ItemPalette::G[32]))
}))
})
}
}
#[cfg(test)] #[test] fn test_view_iter () {
let mut tek = Tek::default();
tek.editor = Some(Default::default());
let _: Vec<_> = tek.inputs_sizes().collect();
let _: Vec<_> = tek.outputs_sizes().collect();
let _: Vec<_> = tek.tracks_sizes().collect();
let _: Vec<_> = tek.scenes_sizes(true, 10, 10).collect();
let _: Vec<_> = tek.scenes_with_colors(true, 10).collect();
let _: Vec<_> = tek.scenes_with_track_colors(true, 10, 10).collect();
}

39
app/src/view/view_ports.rs
View file

@ -8,13 +8,16 @@ impl<'a> ArrangerView<'a> {
fn input_routes (&'a self) -> impl Content<TuiOut> + 'a {
Tryptich::top(self.inputs_height)
.left(self.width_side, io_ports(Tui::g(224), Tui::g(32), ||self.inputs_with_sizes()))
.middle(self.width_mid, per_track_top(
self.width_mid,
||self.tracks_with_sizes(),
move|_, &Track { color, .. }|{
io_conns(color.dark.rgb, color.darker.rgb, ||self.inputs_with_sizes())
}))
.left(self.width_side,
io_ports(Tui::g(224), Tui::g(32), ||self.app.inputs_with_sizes()))
.middle(self.width_mid,
per_track_top(
self.width_mid,
||self.app.tracks_with_sizes(),
move|_, &Track { color, .. }|{
io_conns(color.dark.rgb, color.darker.rgb, ||self.app.inputs_with_sizes())
}
))
}
fn input_ports (&'a self) -> impl Content<TuiOut> + 'a {
@ -26,7 +29,7 @@ impl<'a> ArrangerView<'a> {
.middle(self.width_mid,
per_track_top(
self.width_mid,
||self.tracks_with_sizes(),
||self.app.tracks_with_sizes(),
move|t, track|{
let rec = track.player.recording;
let mon = track.player.monitoring;
@ -52,7 +55,7 @@ impl<'a> ArrangerView<'a> {
.middle(self.width_mid,
per_track_top(
self.width_mid,
||self.tracks_with_sizes(),
||self.app.tracks_with_sizes(),
|_, _|{
Tui::bg(Reset, Align::c(Bsp::s(OctaveVertical::default(), " ------ ")))
}))
@ -77,7 +80,7 @@ impl<'a> ArrangerView<'a> {
.left(self.width_side, Align::ne("From:"))
.middle(self.width_mid, per_track_top(
self.width_mid,
||self.tracks_with_sizes(),
||self.tracks_with_sizes_scrolled(),
|_, _|{
Tui::bg(Reset, Align::c(Bsp::s(" ------ ", OctaveVertical::default())))
}))
@ -87,7 +90,7 @@ impl<'a> ArrangerView<'a> {
.left(self.width_side, Align::ne("Next:"))
.middle(self.width_mid, per_track_top(
self.width_mid,
||self.tracks_with_sizes(),
||self.tracks_with_sizes_scrolled(),
|t, track|Either(
track.player.next_clip.is_some(),
Thunk::new(||Tui::bg(Reset, format!("{:?}",
@ -107,7 +110,7 @@ impl<'a> ArrangerView<'a> {
.middle(self.width_mid,
per_track_top(
self.width_mid,
||self.tracks_with_sizes(),
||self.tracks_with_sizes_scrolled(),
move|i, t|{
let mute = false;
let solo = false;
@ -123,12 +126,14 @@ impl<'a> ArrangerView<'a> {
fn output_conns (&'a self) -> impl Content<TuiOut> + 'a {
Tryptich::top(self.outputs_height)
.left(self.width_side,
io_ports(Tui::g(224), Tui::g(32), ||self.outputs_with_sizes()))
io_ports(Tui::g(224), Tui::g(32), ||self.app.outputs_with_sizes()))
.middle(self.width_mid, per_track_top(
self.width_mid,
||self.tracks_with_sizes(),
|_, t|{
io_conns(t.color.dark.rgb, t.color.darker.rgb, ||self.outputs_with_sizes())
}))
||self.tracks_with_sizes_scrolled(),
|_, t|io_conns(
t.color.dark.rgb,
t.color.darker.rgb,
||self.app.outputs_with_sizes()
)))
}
}

8
app/src/view/view_sizes.rs
View file

@ -29,7 +29,7 @@ impl Tek {
}
/// Width taken by all tracks.
pub(crate) fn w_tracks (&self) -> u16 {
self.tracks_sizes().last().map(|(_, _, _, x)|x as u16).unwrap_or(0)
self.tracks_with_sizes().last().map(|(_, _, _, x)|x as u16).unwrap_or(0)
}
/// Width available to display tracks.
pub(crate) fn w_tracks_area (&self) -> u16 {
@ -45,15 +45,15 @@ impl Tek {
}
/// Height taken by all inputs.
pub(crate) fn h_inputs (&self) -> u16 {
1 + self.inputs_sizes().last().map(|(_, _, _, _, y)|y as u16).unwrap_or(0)
1 + self.inputs_with_sizes().last().map(|(_, _, _, _, y)|y as u16).unwrap_or(0)
}
/// Height taken by all outputs.
pub(crate) fn h_outputs (&self) -> u16 {
1 + self.outputs_sizes().last().map(|(_, _, _, _, y)|y as u16).unwrap_or(0)
1 + self.outputs_with_sizes().last().map(|(_, _, _, _, y)|y as u16).unwrap_or(0)
}
/// Height taken by all scenes.
pub(crate) fn h_scenes (&self) -> u16 {
self.scenes_sizes(self.is_editing(), Self::H_SCENE, Self::H_EDITOR).last()
self.scenes_with_sizes(self.is_editing(), Self::H_SCENE, Self::H_EDITOR).last()
.map(|(_, _, _, y)|y as u16).unwrap_or(0)
}
}

19
app/src/view/view_track.rs
View file

@ -12,7 +12,7 @@ impl<'a> ArrangerView<'a> {
.middle(self.width_mid,
per_track(
self.width_mid,
||self.tracks_with_sizes(),
||self.tracks_with_sizes_scrolled(),
|t, track|view_track_header(t, track, self.track_selected == Some(t))))
}
@ -32,7 +32,7 @@ impl<'a> ArrangerView<'a> {
}))
.middle(self.width_mid, per_track(
self.width_mid,
||self.tracks_with_sizes(),
||self.tracks_with_sizes_scrolled(),
move|track_index, track|Map::new(
||self.scenes_with_track_colors(),
move|(scene_index, scene, y1, y2, prev_scene): SceneWithColor, _|
@ -58,21 +58,6 @@ impl<'a> ArrangerView<'a> {
button_3("S", "add scene", self.app.fmtd.read().unwrap().scns.view.clone(), self.is_editing)
}
fn scenes_with_scene_colors (&'a self) -> impl ScenesColors<'a> {
self.app.scenes_with_colors(
self.is_editing,
self.tracks_height
)
}
fn scenes_with_track_colors (&'a self) -> impl ScenesColors<'a> {
self.app.scenes_with_track_colors(
self.is_editing,
self.tracks_height,
self.track_selected.unwrap_or(0)
)
}
fn track_counter (&'a self) -> Arc<RwLock<String>> {
let track_counter_data = (self.track_selected.unwrap_or(0), self.track_count);
self.app.fmtd.write().unwrap().trks.update(