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

compiles again

Browse source
This commit is contained in:
🪞👃🪞 2025-09-02 22:39:04 +03:00
parent 34070de5f7
commit 1434adae09
21 changed files with 654 additions and 591 deletions
Download patch file Download diff file Expand all files Collapse all files

6
crates/device/src/arranger.rs
View file

@ -13,12 +13,6 @@ def_sizes_iter!(InputsSizes => MidiInput);
def_sizes_iter!(OutputsSizes => MidiOutput);
def_sizes_iter!(PortsSizes => Arc<str>, [Connect]);
pub(crate) fn wrap (bg: Color, fg: Color, content: impl Content<TuiOut>) -> impl Content<TuiOut> {
let left = Tui::fg_bg(bg, Reset, Fixed::x(1, RepeatV("▐")));
let right = Tui::fg_bg(bg, Reset, Fixed::x(1, RepeatV("▌")));
Bsp::e(left, Bsp::w(right, Tui::fg_bg(fg, bg, content)))
}
#[derive(Default, Debug)] pub struct Arrangement {
/// Project name.
pub name: Arc<str>,

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

@ -241,34 +241,38 @@ impl Track {
pub trait HasTrack {
fn track (&self) -> Option<&Track>;
fn track_mut (&mut self) -> Option<&mut Track>;
fn view_midi_ins_status (&self, theme: ItemTheme) -> impl Content<TuiOut> {
fn view_midi_ins_status (&self, theme: ItemTheme) -> impl Draw<TuiOut> {
self.track().map(|track|{
let ins = track.sequencer.midi_ins.len() as u16;
Fixed::xy(20, 1 + ins, Outer(true, Style::default().fg(Tui::g(96))).enclose(
let border = Outer(true, Style::default().fg(Tui::g(96)));
Fixed::xy(20, 1 + ins, border.enclose(
Fixed::xy(20, 1 + ins, FieldV(theme, format!("MIDI ins: "),
Map::south(1, ||track.sequencer.midi_ins.iter(),
|port, index|Fill::x(Align::w(format!(" {index} {}", port.port_name()))))))))})
}
fn view_midi_outs_status (&self, theme: ItemTheme) -> impl Content<TuiOut> {
fn view_midi_outs_status (&self, theme: ItemTheme) -> impl Draw<TuiOut> {
self.track().map(|track|{
let outs = track.sequencer.midi_outs.len() as u16;
Fixed::xy(20, 1 + outs, Outer(true, Style::default().fg(Tui::g(96))).enclose(
let border = Outer(true, Style::default().fg(Tui::g(96)));
Fixed::xy(20, 1 + outs, border.enclose(
Fixed::xy(20, 1 + outs, FieldV(theme, format!("MIDI outs: "),
Map::south(1, ||track.sequencer.midi_outs.iter(),
|port, index|Fill::x(Align::w(format!(" {index} {}", port.port_name()))))))))})
}
fn view_audio_ins_status (&self, theme: ItemTheme) -> impl Content<TuiOut> {
fn view_audio_ins_status (&self, theme: ItemTheme) -> impl Draw<TuiOut> {
self.track().and_then(|track|track.devices.get(0)).map(|device|{
let ins = device.audio_ins().len() as u16;
Fixed::xy(20, 1 + ins, Outer(true, Style::default().fg(Tui::g(96))).enclose(
let border = Outer(true, Style::default().fg(Tui::g(96)));
Fixed::xy(20, 1 + ins, border.enclose(
Fixed::xy(20, 1 + ins, FieldV(theme, format!("Audio ins: "),
Map::south(1, ||device.audio_ins().iter(),
|port, index|Fill::x(Align::w(format!(" {index} {}", port.port_name()))))))))})
}
fn view_audio_outs_status (&self, theme: ItemTheme) -> impl Content<TuiOut> {
fn view_audio_outs_status (&self, theme: ItemTheme) -> impl Draw<TuiOut> {
self.track().and_then(|track|track.devices.last()).map(|device|{
let outs = device.audio_outs().len() as u16;
Fixed::xy(20, 1 + outs, Outer(true, Style::default().fg(Tui::g(96))).enclose(
let border = Outer(true, Style::default().fg(Tui::g(96)));
Fixed::xy(20, 1 + outs, border.enclose(
Fixed::xy(20, 1 + outs, FieldV(theme, format!("Audio outs: "),
Map::south(1, ||device.audio_outs().iter(),
|port, index|Fill::x(Align::w(format!(" {index} {}", port.port_name()))))))))})
@ -276,10 +280,10 @@ pub trait HasTrack {
}
impl Track {
pub fn per <'a, T: Content<TuiOut> + 'a, U: TracksSizes<'a>> (
pub fn per <'a, T: Draw<TuiOut> + Layout<TuiOut> + 'a, U: TracksSizes<'a>> (
tracks: impl Fn() -> U + Send + Sync + 'a,
callback: impl Fn(usize, &'a Track)->T + Send + Sync + 'a
) -> impl Content<TuiOut> + 'a {
) -> impl Draw<TuiOut> + Layout<TuiOut> + 'a {
Map::new(tracks,
move|(index, track, x1, x2): (usize, &'a Track, usize, usize), _|{
let width = (x2 - x1) as u16;
@ -290,10 +294,10 @@ impl Track {
}
}
pub(crate) fn per_track_top <'a, T: Content<TuiOut> + 'a, U: TracksSizes<'a>> (
pub(crate) fn per_track_top <'a, T: Draw<TuiOut> + Layout<TuiOut> + 'a, U: TracksSizes<'a>> (
tracks: impl Fn() -> U + Send + Sync + 'a,
callback: impl Fn(usize, &'a Track)->T + Send + Sync + 'a
) -> impl Content<TuiOut> + 'a {
) -> impl Draw<TuiOut> + Layout<TuiOut> + 'a {
Align::x(Tui::bg(Reset, Map::new(tracks,
move|(index, track, x1, x2): (usize, &'a Track, usize, usize), _|{
let width = (x2 - x1) as u16;
@ -303,37 +307,39 @@ pub(crate) fn per_track_top <'a, T: Content<TuiOut> + 'a, U: TracksSizes<'a>> (
callback(index, track))))})))
}
pub(crate) fn per_track <'a, T: Content<TuiOut> + 'a, U: TracksSizes<'a>> (
pub(crate) fn per_track <'a, T: Draw<TuiOut> + Layout<TuiOut> + 'a, U: TracksSizes<'a>> (
tracks: impl Fn() -> U + Send + Sync + 'a,
callback: impl Fn(usize, &'a Track)->T + Send + Sync + 'a
) -> impl Content<TuiOut> + 'a {
) -> impl Draw<TuiOut> + 'a {
per_track_top(tracks, move|index, track|Fill::y(Align::y(callback(index, track))))
}
pub(crate) fn io_ports <'a, T: PortsSizes<'a>> (
fg: Color, bg: Color, iter: impl Fn()->T + Send + Sync + 'a
) -> impl Content<TuiOut> + 'a {
) -> impl Draw<TuiOut> + Layout<TuiOut> + 'a {
Map::new(iter, move|(
_index, name, connections, y, y2
): (usize, &'a Arc<str>, &'a [Connect], usize, usize), _|
map_south(y as u16, (y2-y) as u16, Bsp::s(
Fill::x(Tui::bold(true, Tui::fg_bg(fg, bg, Align::w(Bsp::e(" 󰣲 ", name))))),
Fill::x(Tui::bold(true, Tui::fg_bg(fg, bg, Align::w(Bsp::e(&" 󰣲 ", name))))),
Map::new(||connections.iter(), move|connect: &'a Connect, index|map_south(index as u16, 1,
Fill::x(Align::w(Tui::bold(false, Tui::fg_bg(fg, bg,
&connect.info)))))))))
}
pub(crate) fn io_conns <'a, T: PortsSizes<'a>> (
fg: Color, bg: Color, iter: impl Fn()->T + Send + Sync + 'a
) -> impl Content<TuiOut> + 'a {
Map::new(iter, move|(
_index, _name, connections, y, y2
): (usize, &'a Arc<str>, &'a [Connect], usize, usize), _|
map_south(y as u16, (y2-y) as u16, Bsp::s(
Fill::x(Tui::bold(true, wrap(bg, fg, Fill::x(Align::w("▞▞▞▞ ▞▞▞▞"))))),
Map::new(||connections.iter(), move|_conn, index|map_south(index as u16, 1,
Fill::x(Align::w(Tui::bold(false, wrap(bg, fg, Fill::x(""))))))))))
}
//pub(crate) fn io_conns <'a, T: PortsSizes<'a>> (
//fg: Color, bg: Color, iter: &mut impl Iterator<Item = (usize, &'a Arc<str>, &'a [Connect], usize, usize)>
//) -> impl Draw<TuiOut> + Layout<TuiOut> + 'a {
//Fill::xy(Thunk::new(move|to: &mut TuiOut|for (_, _, connections, y, y2) in &mut *iter {
//to.place(&map_south(y as u16, (y2-y) as u16, Bsp::s(
//Fill::x(Tui::bold(true, wrap(bg, fg, Fill::x(Align::w(&"▞▞▞▞ ▞▞▞▞"))))),
//Thunk::new(|to: &mut TuiOut|for (index, _connection) in connections.iter().enumerate() {
//to.place(&map_south(index as u16, 1, Fill::x(Align::w(Tui::bold(false,
//wrap(bg, fg, Fill::x(&"")))))))
//})
//)))
//}))
//}
//track_scroll: Fill::x(Fixed::y(1, ScrollbarH {
//offset: arrangement.track_scroll,
//length: h_tracks_area as usize,

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

@ -1,38 +1,55 @@
use crate::*;
pub(crate) fn wrap (
bg: Color, fg: Color, content: impl Draw<TuiOut> + Layout<TuiOut>
) -> impl Draw<TuiOut> + Layout<TuiOut> {
let left = Tui::fg_bg(bg, Reset, Fixed::x(1, RepeatV("▐")));
let right = Tui::fg_bg(bg, Reset, Fixed::x(1, RepeatV("▌")));
Bsp::e(left, Bsp::w(right, Tui::fg_bg(fg, bg, content)))
}
type Add<'a> = &'a dyn FnMut(&dyn Draw<TuiOut>);
impl Arrangement {
pub fn view_inputs <'a> (&'a self, _theme: ItemTheme) -> impl Content<TuiOut> + 'a {
Stack::south(move|add|{
add(&Fixed::y(1,
Bsp::e(Fixed::x(20, Align::w(button_3("i", "nput ", format!("{}", self.midi_ins.len()), false))),
Bsp::w(Fixed::x(4, button_2("I", "+", false)),
Stack::east(move|add|{
for (_index, track, _x1, _x2) in self.tracks_with_sizes() {
add(&Tui::bg(track.color.dark.rgb, Align::w(Fixed::x(track.width as u16, row!(
Either(track.sequencer.monitoring, Tui::fg(Green, "mon "), "mon "),
Either(track.sequencer.recording, Tui::fg(Red, "rec "), "rec "),
Either(track.sequencer.overdub, Tui::fg(Yellow, "dub "), "dub "),
)))))
}
})))));
for (_index, port) in self.midi_ins().iter().enumerate() {
add(&Fixed::y(1, Bsp::e(
Fixed::x(20, Align::w(Bsp::e(" ● ",
Tui::bold(true, Tui::fg(Rgb(255,255,255), port.port_name()))))),
Bsp::w(Fixed::x(4, ()),
Stack::east(move|add|{
for (_index, track, _x1, _x2) in self.tracks_with_sizes() {
add(&Tui::bg(track.color.darker.rgb, Align::w(Fixed::x(track.width as u16, row!(
Either(track.sequencer.monitoring, Tui::fg(Green, " ● "), " · "),
Either(track.sequencer.recording, Tui::fg(Red, " ● "), " · "),
Either(track.sequencer.overdub, Tui::fg(Yellow, " ● "), " · "),
)))))
}
})))));
pub fn view_inputs (&self, _theme: ItemTheme) -> impl Draw<TuiOut> + Layout<TuiOut> + '_ {
Bsp::s(self.view_inputs_header(), Thunk::new(|to: &mut TuiOut|{
for port in self.midi_ins().iter() {
to.place(&self.view_inputs_row(port))
}
})
}))
}
pub fn view_outputs <'a> (&'a self, theme: ItemTheme) -> impl Content<TuiOut> + 'a {
fn view_inputs_header (&self) -> impl Draw<TuiOut> + Layout<TuiOut> + '_ {
Fixed::y(1, Bsp::e(
Fixed::x(20, Align::w(
button_3("i", "nput ", format!("{}", self.midi_ins.len()), false))),
Bsp::w(Fixed::x(4, button_2("I", "+", false)),
Thunk::new(|to: &mut TuiOut|for (_index, track, _x1, _x2) in self.tracks_with_sizes() {
to.place(&Tui::bg(track.color.dark.rgb, Align::w(Fixed::x(track.width as u16, row!(
Either::new(track.sequencer.monitoring, Tui::fg(Green, "mon "), "mon "),
Either::new(track.sequencer.recording, Tui::fg(Red, "rec "), "rec "),
Either::new(track.sequencer.overdub, Tui::fg(Yellow, "dub "), "dub "),
)))))
}))))
}
fn view_inputs_row (&self, port: &MidiInput) -> impl Draw<TuiOut> + Layout<TuiOut> {
Fixed::y(1, Bsp::e(
Fixed::x(20, Align::w(
Bsp::e(" ● ", Tui::bold(true, Tui::fg(Rgb(255,255,255), port.port_name()))))),
Bsp::w(Fixed::x(4, ()), Thunk::new(|to: &mut TuiOut|{
for (_index, track, _x1, _x2) in self.tracks_with_sizes() {
to.place(&Tui::bg(track.color.darker.rgb, Align::w(Fixed::x(track.width as u16, row!(
Either::new(track.sequencer.monitoring, Tui::fg(Green, " ● "), " · "),
Either::new(track.sequencer.recording, Tui::fg(Red, " ● "), " · "),
Either::new(track.sequencer.overdub, Tui::fg(Yellow, " ● "), " · "),
)))))
}
}))))
}
pub fn view_outputs (&self, theme: ItemTheme) -> impl Draw<TuiOut> + Layout<TuiOut> {
let mut h = 1;
for output in self.midi_outs().iter() {
h += 1 + output.connections.len();
@ -40,59 +57,68 @@ impl Arrangement {
let h = h as u16;
let list = Bsp::s(
Fixed::y(1, Fill::x(Align::w(button_3("o", "utput", format!("{}", self.midi_outs.len()), false)))),
Fixed::y(h - 1, Fill::xy(Align::nw(Stack::south(|add|{
Fixed::y(h - 1, Fill::xy(Align::nw(Thunk::new(|to: &mut TuiOut|{
for (_index, port) in self.midi_outs().iter().enumerate() {
add(&Fixed::y(1,Fill::x(Bsp::e(
to.place(&Fixed::y(1,Fill::x(Bsp::e(
Align::w(Bsp::e(" ● ", Tui::fg(Rgb(255,255,255),Tui::bold(true, port.port_name())))),
Fill::x(Align::e(format!("{}/{} ",
port.port().get_connections().len(),
port.connections.len())))))));
for (index, conn) in port.connections.iter().enumerate() {
add(&Fixed::y(1, Fill::x(Align::w(format!(" c{index:02}{}", conn.info())))));
to.place(&Fixed::y(1, Fill::x(Align::w(format!(" c{index:02}{}", conn.info())))));
}
}
})))));
Fixed::y(h, Self::view_track_row_section(theme, list, button_2("O", "+", false),
Fixed::y(h, view_track_row_section(theme, list, button_2("O", "+", false),
Tui::bg(theme.darker.rgb, Align::w(Fill::x(
Stack::east(move|add|{
Thunk::new(|to: &mut TuiOut|{
for (index, track, _x1, _x2) in self.tracks_with_sizes() {
add(&Fixed::x(self.track_width(index, track),
Stack::south(move|add|{
add(&Fixed::y(1, Align::w(Bsp::e(
Either(true, Tui::fg(Green, "play "), "play "),
Either(false, Tui::fg(Yellow, "solo "), "solo "),
to.place(&Fixed::x(self.track_width(index, track),
Thunk::new(|to: &mut TuiOut|{
to.place(&Fixed::y(1, Align::w(Bsp::e(
Either::new(true, Tui::fg(Green, "play "), "play "),
Either::new(false, Tui::fg(Yellow, "solo "), "solo "),
))));
for (_index, port) in self.midi_outs().iter().enumerate() {
add(&Fixed::y(1, Align::w(Bsp::e(
Either(true, Tui::fg(Green, " ● "), " · "),
Either(false, Tui::fg(Yellow, " ● "), " · "),
to.place(&Fixed::y(1, Align::w(Bsp::e(
Either::new(true, Tui::fg(Green, " ● "), " · "),
Either::new(false, Tui::fg(Yellow, " ● "), " · "),
))));
for (_index, _conn) in port.connections.iter().enumerate() {
add(&Fixed::y(1, Fill::x("")));
to.place(&Fixed::y(1, Fill::x("")));
}
}})))}}))))))
}
pub fn view_track_devices <'a> (&'a self, theme: ItemTheme) -> impl Content<TuiOut> + 'a {
pub fn view_track_devices (&self, theme: ItemTheme) -> impl Draw<TuiOut> + Layout<TuiOut> {
let mut h = 2u16;
for track in self.tracks().iter() {
h = h.max(track.devices.len() as u16 * 2);
}
Self::view_track_row_section(
theme,
view_track_row_section(theme,
button_3("d", "evice", format!("{}", self.track().map(|t|t.devices.len()).unwrap_or(0)), false),
button_2("D", "+", false),
Stack::east(move|add|{
for (index, track, _x1, _x2) in self.tracks_with_sizes() {
add(&Fixed::xy(self.track_width(index, track), h + 1,
Tui::bg(track.color.dark.rgb, Align::nw(Map::south(2, move||0..h,
|_, _index|Fixed::xy(track.width as u16, 2,
Tui::fg_bg(
ItemTheme::G[32].lightest.rgb,
ItemTheme::G[32].dark.rgb,
Align::nw(format!(" · {}", "--")))))))));
}
Thunk::new(move|to: &mut TuiOut|for (index, track, _x1, _x2) in self.tracks_with_sizes() {
to.place(&Fixed::xy(self.track_width(index, track), h + 1,
Tui::bg(track.color.dark.rgb, Align::nw(Map::south(2, move||0..h,
|_, _index|Fixed::xy(track.width as u16, 2,
Tui::fg_bg(
ItemTheme::G[32].lightest.rgb,
ItemTheme::G[32].dark.rgb,
Align::nw(format!(" · {}", "--")))))))));
}))
}
}
fn view_track_row_section (
_theme: ItemTheme,
button: impl Draw<TuiOut> + Layout<TuiOut>,
button_add: impl Draw<TuiOut> + Layout<TuiOut>,
content: impl Draw<TuiOut> + Layout<TuiOut>,
) -> impl Draw<TuiOut> + Layout<TuiOut> {
Bsp::w(Fill::y(Fixed::x(4, Align::nw(button_add))),
Bsp::e(Fixed::x(20, Fill::y(Align::nw(button))), Fill::xy(Align::c(content))))
}
pub trait HasClipsSize {
@ -135,21 +161,12 @@ pub trait TracksView:
}
})
}
fn view_track_row_section (
_theme: ItemTheme,
button: impl Content<TuiOut>,
button_add: impl Content<TuiOut>,
content: impl Content<TuiOut>
) -> impl Content<TuiOut> {
Bsp::w(Fill::y(Fixed::x(4, Align::nw(button_add))),
Bsp::e(Fixed::x(20, Fill::y(Align::nw(button))), Fill::xy(Align::c(content))))
}
fn view_track_header <'a, T: Content<TuiOut>> (
&'a self, theme: ItemTheme, content: T
) -> impl Content<TuiOut> {
fn view_track_header <'a> (
&'a self, theme: ItemTheme, content: impl Draw<TuiOut> + Layout<TuiOut>
) -> impl Draw<TuiOut> + Layout<TuiOut> {
Fixed::x(12, Tui::bg(theme.darker.rgb, Fill::x(Align::e(content))))
}
fn view_track_names (&self, theme: ItemTheme) -> impl Content<TuiOut> {
fn view_track_names (&self, theme: ItemTheme) -> impl Draw<TuiOut> + Layout<TuiOut> {
let track_count = self.tracks().len();
let scene_count = self.scenes().len();
let selected = self.selection();
@ -161,10 +178,10 @@ pub trait TracksView:
let button_2 = Bsp::s(
button_2("T", "+", false),
button_2("S", "+", false));
Self::view_track_row_section(theme, button, button_2, Tui::bg(theme.darker.rgb,
Fixed::y(2, Fill::x(Stack::east(move|add|{
view_track_row_section(theme, button, button_2, Tui::bg(theme.darker.rgb,
Fixed::y(2, Thunk::new(|to: &mut TuiOut|{
for (index, track, _x1, _x2) in self.tracks_with_sizes() {
add(&Fixed::x(self.track_width(index, track),
to.place(&Fixed::x(self.track_width(index, track),
Tui::bg(if selected.track() == Some(index) {
track.color.light.rgb
} else {
@ -172,55 +189,49 @@ pub trait TracksView:
}, Bsp::s(Fill::x(Align::nw(Bsp::e(
format!("·t{index:02} "),
Tui::fg(Rgb(255, 255, 255), Tui::bold(true, &track.name))
))), ""))) );
}
})))))
))), ""))) );}}))))
}
fn view_track_outputs <'a> (&'a self, theme: ItemTheme, _h: u16) -> impl Content<TuiOut> {
Self::view_track_row_section(theme,
Bsp::s(
Fill::x(Align::w(button_2("o", "utput", false))),
Fill::xy(Stack::south(|add|{
for port in self.midi_outs().iter() {
add(&Fill::x(Align::w(port.port_name())));
}
}))),
fn view_track_outputs <'a> (&'a self, theme: ItemTheme, _h: u16) -> impl Draw<TuiOut> + Layout<TuiOut> {
view_track_row_section(theme,
Bsp::s(Fill::x(Align::w(button_2("o", "utput", false))),
Thunk::new(|to: &mut TuiOut|for port in self.midi_outs().iter() {
to.place(&Fill::x(Align::w(port.port_name())));
})),
button_2("O", "+", false),
Tui::bg(theme.darker.rgb, Align::w(Fill::x(
Stack::east(move|add|{
for (index, track, _x1, _x2) in self.tracks_with_sizes() {
add(&Fixed::x(self.track_width(index, track),
Align::nw(Fill::y(Map::south(1, ||track.sequencer.midi_outs.iter(),
|port, index|Tui::fg(Rgb(255, 255, 255),
Fixed::y(1, Tui::bg(track.color.dark.rgb, Fill::x(Align::w(
format!("·o{index:02} {}", port.port_name())))))))))));
}
})))))
Tui::bg(theme.darker.rgb, Align::w(Thunk::new(|to: &mut TuiOut|{
for (index, track, _x1, _x2) in self.tracks_with_sizes() {
to.place(&Fixed::x(self.track_width(index, track),
Align::nw(Fill::y(Map::south(1, ||track.sequencer.midi_outs.iter(),
|port, index|Tui::fg(Rgb(255, 255, 255),
Fixed::y(1, Tui::bg(track.color.dark.rgb, Fill::x(Align::w(
format!("·o{index:02} {}", port.port_name())))))))))));}}))))
}
fn view_track_inputs <'a> (&'a self, theme: ItemTheme) -> impl Content<TuiOut> {
fn view_track_inputs <'a> (&'a self, theme: ItemTheme) -> impl Draw<TuiOut> + Layout<TuiOut> {
let mut h = 0u16;
for track in self.tracks().iter() {
h = h.max(track.sequencer.midi_ins.len() as u16);
}
Self::view_track_row_section(
theme,
view_track_row_section(theme,
button_2("i", "nput", false),
button_2("I", "+", false),
Tui::bg(theme.darker.rgb, Align::w(Fill::x(
Stack::east(move|add|{
for (index, track, _x1, _x2) in self.tracks_with_sizes() {
add(&Fixed::xy(self.track_width(index, track), h + 1,
Align::nw(Bsp::s(
Tui::bg(track.color.base.rgb,
Fill::x(Align::w(row!(
Either(track.sequencer.monitoring, Tui::fg(Green, "●mon "), "·mon "),
Either(track.sequencer.recording, Tui::fg(Red, "●rec "), "·rec "),
Either(track.sequencer.overdub, Tui::fg(Yellow, "●dub "), "·dub "),
)))),
Map::south(1, ||track.sequencer.midi_ins.iter(),
|port, index|Tui::fg_bg(Rgb(255, 255, 255), track.color.dark.rgb,
Fill::x(Align::w(format!("·i{index:02} {}", port.port_name())))))))));
}})))))
Tui::bg(theme.darker.rgb, Align::w(Thunk::new(move|to: &mut TuiOut|{
for (index, track, _x1, _x2) in self.tracks_with_sizes() {
to.place(&Fixed::xy(self.track_width(index, track), h + 1,
Align::nw(Bsp::s(
Tui::bg(track.color.base.rgb,
Fill::x(Align::w(row!(
Either::new(track.sequencer.monitoring,
Tui::fg(Green, "●mon "), "·mon "),
Either::new(track.sequencer.recording,
Tui::fg(Red, "●rec "), "·rec "),
Either::new(track.sequencer.overdub,
Tui::fg(Yellow, "●dub "), "·dub "),
)))),
Map::south(1, ||track.sequencer.midi_ins.iter(),
|port, index|Tui::fg_bg(Rgb(255, 255, 255), track.color.dark.rgb,
Fill::x(Align::w(format!("·i{index:02} {}", port.port_name())))))))));
}
}))))
}
fn track_width (&self, index: usize, track: &Track) -> u16 {
track.width as u16
@ -259,14 +270,12 @@ pub trait ScenesView:
}
})
}
fn view_scenes_names (&self) -> impl Content<TuiOut> {
Fixed::x(20, Stack::south(move|add|{
for (index, scene, ..) in self.scenes_with_sizes() {
add(&self.view_scene_name(index, scene));
}
fn view_scenes_names (&self) -> impl Draw<TuiOut> + Layout<TuiOut> {
Fixed::x(20, Thunk::new(|to: &mut TuiOut|for (index, scene, ..) in self.scenes_with_sizes() {
to.place(&self.view_scene_name(index, scene));
}))
}
fn view_scene_name (&self, index: usize, scene: &Scene) -> impl Content<TuiOut> {
fn view_scene_name <'a> (&'a self, index: usize, scene: &'a Scene) -> impl Draw<TuiOut> + Layout<TuiOut> + 'a {
let h = if self.selection().scene() == Some(index) && let Some(_editor) = self.editor() {
7
} else {
@ -277,15 +286,13 @@ pub trait ScenesView:
} else {
scene.color.base.rgb
};
Fixed::xy(20, h, Tui::bg(bg, Align::nw(Bsp::s(
Fill::x(Align::w(Bsp::e(
format!("·s{index:02} "),
Tui::fg(Rgb(255, 255, 255), Tui::bold(true, &scene.name))
))),
When(self.selection().scene() == Some(index) && self.is_editing(),
Fill::xy(Align::nw(Bsp::s(
self.editor().as_ref().map(|e|e.clip_status()),
self.editor().as_ref().map(|e|e.edit_status())))))))))
let a = Fill::x(Align::w(Bsp::e(format!("·s{index:02} "),
Tui::fg(Tui::g(255), Tui::bold(true, &scene.name)))));
let b = When(self.selection().scene() == Some(index) && self.is_editing(),
Fill::xy(Align::nw(Bsp::s(
self.editor().as_ref().map(|e|e.clip_status()),
self.editor().as_ref().map(|e|e.edit_status())))));
Fixed::xy(20, h, Tui::bg(bg, Align::nw(Bsp::s(a, b))))
}
}
@ -297,70 +304,68 @@ pub trait ClipsView:
Sync
{
fn view_scenes_clips <'a> (&'a self)
-> impl Content<TuiOut> + 'a
-> impl Draw<TuiOut> + 'a
{
self.clips_size().of(Fill::xy(Bsp::a(
Fill::xy(Align::se(Tui::fg(Green, format!("{}x{}", self.clips_size().w(), self.clips_size().h())))),
Stack::<TuiOut, _>::east(move|column|{
for (track_index, track, _, _) in self.tracks_with_sizes() {
//column(&Fixed::x(5, Fill::xy(Tui::bg(Green, "kyp"))));
column(&Fixed::x(
track.width as u16,
Fill::y(self.view_track_clips(track_index, track))
))
}
Thunk::new(|to: &mut TuiOut|for (
track_index, track, _, _
) in self.tracks_with_sizes() {
to.place(&Fixed::x(track.width as u16,
Fill::y(self.view_track_clips(track_index, track))))
}))))
}
fn view_track_clips <'a> (&'a self, track_index: usize, track: &'a Track) -> impl Content<TuiOut> + 'a {
Stack::south(move|cell|{
for (scene_index, scene, ..) in self.scenes_with_sizes() {
let (name, theme): (Arc<str>, ItemTheme) = if let Some(Some(clip)) = &scene.clips.get(track_index) {
let clip = clip.read().unwrap();
(format!(" ⏹ {}", &clip.name).into(), clip.color)
} else {
(" ⏹ -- ".into(), ItemTheme::G[32])
};
let fg = theme.lightest.rgb;
let mut outline = theme.base.rgb;
let bg = if self.selection().track() == Some(track_index)
&& self.selection().scene() == Some(scene_index)
{
outline = theme.lighter.rgb;
theme.light.rgb
} else if self.selection().track() == Some(track_index)
|| self.selection().scene() == Some(scene_index)
{
outline = theme.darkest.rgb;
theme.base.rgb
} else {
theme.dark.rgb
};
let w = if self.selection().track() == Some(track_index)
&& let Some(editor) = self.editor ()
{
editor.width().max(24).max(track.width)
} else {
track.width
} as u16;
let y = if self.selection().scene() == Some(scene_index)
&& let Some(editor) = self.editor ()
{
editor.height().max(12)
} else {
Self::H_SCENE
} as u16;
cell(&Fixed::xy(w, y, Bsp::b(
Fill::xy(Outer(true, Style::default().fg(outline))),
Fill::xy(Bsp::b(
Bsp::b(
Tui::fg_bg(outline, bg, Fill::xy("")),
Fill::xy(Align::nw(Tui::fg_bg(fg, bg, Tui::bold(true, name)))),
),
Fill::xy(When(self.selection().track() == Some(track_index)
&& self.selection().scene() == Some(scene_index)
&& self.is_editing(), self.editor())))))));
}
fn view_track_clips <'a> (&'a self, track_index: usize, track: &'a Track) -> impl Draw<TuiOut> + 'a {
Thunk::new(move|to: &mut TuiOut|for (
scene_index, scene, ..
) in self.scenes_with_sizes() {
let (name, theme): (Arc<str>, ItemTheme) = if let Some(Some(clip)) = &scene.clips.get(track_index) {
let clip = clip.read().unwrap();
(format!(" ⏹ {}", &clip.name).into(), clip.color)
} else {
(" ⏹ -- ".into(), ItemTheme::G[32])
};
let fg = theme.lightest.rgb;
let mut outline = theme.base.rgb;
let bg = if self.selection().track() == Some(track_index)
&& self.selection().scene() == Some(scene_index)
{
outline = theme.lighter.rgb;
theme.light.rgb
} else if self.selection().track() == Some(track_index)
|| self.selection().scene() == Some(scene_index)
{
outline = theme.darkest.rgb;
theme.base.rgb
} else {
theme.dark.rgb
};
let w = if self.selection().track() == Some(track_index)
&& let Some(editor) = self.editor ()
{
editor.width().max(24).max(track.width)
} else {
track.width
} as u16;
let y = if self.selection().scene() == Some(scene_index)
&& let Some(editor) = self.editor ()
{
editor.height().max(12)
} else {
Self::H_SCENE
} as u16;
to.place(&Fixed::xy(w, y, Bsp::b(
Fill::xy(Outer(true, Style::default().fg(outline))),
Fill::xy(Bsp::b(
Bsp::b(
Tui::fg_bg(outline, bg, Fill::xy("")),
Fill::xy(Align::nw(Tui::fg_bg(fg, bg, Tui::bold(true, name)))),
),
Fill::xy(When(self.selection().track() == Some(track_index)
&& self.selection().scene() == Some(scene_index)
&& self.is_editing(), self.editor())))))));
})
}
}

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

@ -6,7 +6,7 @@ pub fn view_transport (
bpm: Arc<RwLock<String>>,
beat: Arc<RwLock<String>>,
time: Arc<RwLock<String>>,
) -> impl Content<TuiOut> {
) -> impl Draw<TuiOut> + Layout<TuiOut> {
let theme = ItemTheme::G[96];
Tui::bg(Black, row!(Bsp::a(
Fill::xy(Align::w(button_play_pause(play))),
@ -23,7 +23,7 @@ pub fn view_status (
sr: Arc<RwLock<String>>,
buf: Arc<RwLock<String>>,
lat: Arc<RwLock<String>>,
) -> impl Content<TuiOut> {
) -> impl Draw<TuiOut> + Layout<TuiOut> {
let theme = ItemTheme::G[96];
Tui::bg(Black, row!(Bsp::a(
Fill::xy(Align::w(sel.map(|sel|FieldH(theme, "Selected", sel)))),
@ -35,18 +35,18 @@ pub fn view_status (
)))
}
pub(crate) fn button_play_pause (playing: bool) -> impl Content<TuiOut> {
pub(crate) fn button_play_pause (playing: bool) -> impl Draw<TuiOut> + Layout<TuiOut> {
let compact = true;//self.is_editing();
Tui::bg(if playing { Rgb(0, 128, 0) } else { Rgb(128, 64, 0) },
Either::new(compact,
Thunk::new(move||Fixed::x(9, Either::new(playing,
Thunk::new(move|to: &mut TuiOut|to.place(&Fixed::x(9, Either::new(playing,
Tui::fg(Rgb(0, 255, 0), " PLAYING "),
Tui::fg(Rgb(255, 128, 0), " STOPPED ")))
),
Thunk::new(move||Fixed::x(5, Either::new(playing,
)),
Thunk::new(move|to: &mut TuiOut|to.place(&Fixed::x(5, Either::new(playing,
Tui::fg(Rgb(0, 255, 0), Bsp::s(" 🭍🭑🬽 ", " 🭞🭜🭘 ",)),
Tui::fg(Rgb(255, 128, 0), Bsp::s(" ▗▄▖ ", " ▝▀▘ ",))))
)
))
)
)
}
@ -93,7 +93,7 @@ impl ViewCache {
//}
//pub fn scene_add (cache: &Arc<RwLock<Self>>, scene: usize, scenes: usize, is_editing: bool)
//-> impl Content<TuiOut>
//-> impl Draw<TuiOut>
//{
//let data = (scene, scenes);
//cache.write().unwrap().scns.update(Some(data), rewrite!(buf, "({}/{})", data.0, data.1));
@ -133,7 +133,7 @@ impl ViewCache {
}
}
//pub fn view_h2 (&self) -> impl Content<TuiOut> {
//pub fn view_h2 (&self) -> impl Draw<TuiOut> {
//let cache = self.project.clock.view_cache.clone();
//let cache = cache.read().unwrap();
//add(&Fixed::x(15, Align::w(Bsp::s(

6
crates/device/src/editor/editor_view.rs
View file

@ -1,5 +1,7 @@
use crate::*;
tui_layout!(|self: MidiEditor, to|self.content().layout(to));
tui_draw!(|self: MidiEditor, to|self.content().draw(to));
content!(TuiOut: |self: MidiEditor| {
self.autoscroll();
//self.autozoom();
@ -8,7 +10,7 @@ content!(TuiOut: |self: MidiEditor| {
impl MidiEditor {
pub fn clip_status (&self) -> impl Content<TuiOut> + '_ {
pub fn clip_status (&self) -> impl Draw<TuiOut> + Layout<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 { (ItemTheme::G[64], String::new().into(), 0, false) };
@ -25,7 +27,7 @@ impl MidiEditor {
))
}
pub fn edit_status (&self) -> impl Content<TuiOut> + '_ {
pub fn edit_status (&self) -> impl Draw<TuiOut> + Layout<TuiOut> + '_ {
let (_color, length) = if let Some(clip) = self.clip().as_ref().map(|p|p.read().unwrap()) {
(clip.color, clip.length)
} else { (ItemTheme::G[64], 0) };

20
crates/device/src/editor/editor_view_h.rs
View file

@ -23,7 +23,7 @@ has!(Measure<TuiOut>:|self:PianoHorizontal|self.size);
impl PianoHorizontal {
pub fn new (clip: Option<&Arc<RwLock<MidiClip>>>) -> Self {
let size = Measure::new();
let mut range = MidiRangeModel::from((12, true));
let mut range = MidiRangeModel::from((12, true));
range.time_axis = size.x.clone();
range.note_axis = size.y.clone();
let piano = Self {
@ -46,6 +46,8 @@ pub(crate) fn note_y_iter (note_lo: usize, note_hi: usize, y0: u16)
(note_lo..=note_hi).rev().enumerate().map(move|(y, n)|(y, y0 + y as u16, n))
}
tui_layout!(|self: PianoHorizontal, to|self.content().layout(to));
tui_draw!(|self: PianoHorizontal, to|self.content().draw(to));
content!(TuiOut:|self: PianoHorizontal| Bsp::s(
Bsp::e(
Fixed::x(5, format!("{}x{}", self.size.w(), self.size.h())),
@ -139,12 +141,12 @@ impl PianoHorizontal {
}
}
fn notes (&self) -> impl Content<TuiOut> {
fn notes (&self) -> impl Draw<TuiOut> {
let time_start = self.get_time_start();
let note_lo = self.get_note_lo();
let note_hi = self.get_note_hi();
let buffer = self.buffer.clone();
ThunkRender::new(move|to: &mut TuiOut|{
Thunk::new(move|to: &mut TuiOut|{
let source = buffer.read().unwrap();
let [x0, y0, w, _h] = to.area().xywh();
//if h as usize != note_axis {
@ -170,7 +172,7 @@ impl PianoHorizontal {
}
})
}
fn cursor (&self) -> impl Content<TuiOut> {
fn cursor (&self) -> impl Draw<TuiOut> + Layout<TuiOut> {
let note_hi = self.get_note_hi();
let note_lo = self.get_note_lo();
let note_pos = self.get_note_pos();
@ -179,7 +181,7 @@ impl PianoHorizontal {
let time_start = self.get_time_start();
let time_zoom = self.get_time_zoom();
let style = Some(Style::default().fg(self.color.lightest.rgb));
ThunkRender::new(move|to: &mut TuiOut|{
Thunk::new(move|to: &mut TuiOut|{
let [x0, y0, w, _] = to.area().xywh();
for (_area_y, screen_y, note) in note_y_iter(note_lo, note_hi, y0) {
if note == note_pos {
@ -201,7 +203,7 @@ impl PianoHorizontal {
}
})
}
fn keys (&self) -> impl Content<TuiOut> {
fn keys (&self) -> impl Draw<TuiOut> + Layout<TuiOut> {
let state = self;
let color = state.color;
let note_lo = state.get_note_lo();
@ -210,7 +212,7 @@ impl PianoHorizontal {
let key_style = Some(Style::default().fg(Rgb(192, 192, 192)).bg(Rgb(0, 0, 0)));
let off_style = Some(Style::default().fg(Tui::g(255)));
let on_style = Some(Style::default().fg(Rgb(255,0,0)).bg(color.base.rgb).bold());
Fill::y(Fixed::x(self.keys_width, ThunkRender::new(move|to: &mut TuiOut|{
Fill::y(Fixed::x(self.keys_width, Thunk::new(move|to: &mut TuiOut|{
let [x, y0, _w, _h] = to.area().xywh();
for (_area_y, screen_y, note) in note_y_iter(note_lo, note_hi, y0) {
to.blit(&to_key(note), x, screen_y, key_style);
@ -225,8 +227,8 @@ impl PianoHorizontal {
}
})))
}
fn timeline (&self) -> impl Content<TuiOut> + '_ {
Fill::x(Fixed::y(1, ThunkRender::new(move|to: &mut TuiOut|{
fn timeline (&self) -> impl Draw<TuiOut> + Layout<TuiOut> + '_ {
Fill::x(Fixed::y(1, Thunk::new(move|to: &mut TuiOut|{
let [x, y, w, _h] = to.area();
let style = Some(Style::default().dim());
let length = self.clip.as_ref().map(|p|p.read().unwrap().length).unwrap_or(1);

4
crates/device/src/editor/editor_view_v.rs
View file

@ -1,3 +1,5 @@
//! TODO
use crate::*;
pub struct OctaveVertical {
@ -24,7 +26,7 @@ impl OctaveVertical {
}
impl Content<TuiOut> for OctaveVertical {
fn content (&self) -> impl Render<TuiOut> {
fn content (&self) -> impl Draw<TuiOut> + Layout<TuiOut> + '_ {
row!(
Tui::fg_bg(self.color(0), self.color(1), "▙"),
Tui::fg_bg(self.color(2), self.color(3), "▙"),

41
crates/device/src/lib.rs
View file

@ -14,7 +14,7 @@ pub(crate) use std::error::Error;
pub(crate) use std::ffi::OsString;
pub(crate) use ::tengri::{from, has, maybe_has, Usually, Perhaps, Has, MaybeHas};
pub(crate) use ::tengri::{dsl::*, input::*, output::*, tui::{*, ratatui::prelude::*}};
pub(crate) use ::tengri::{dsl::*, input::*, output::{*, Layout}, tui::{*, ratatui::prelude::*}};
pub(crate) use ::tek_engine::*;
pub(crate) use ::tek_engine::midi::{u7, LiveEvent, MidiMessage};
pub(crate) use ::tek_engine::jack::{Control, ProcessScope, RawMidi};
@ -47,45 +47,6 @@ macro_rules! def_sizes_iter {
#[cfg(feature = "vst2")] mod vst2; #[cfg(feature = "vst2")] pub use self::vst2::*;
#[cfg(feature = "vst3")] mod vst3; #[cfg(feature = "vst3")] pub use self::vst3::*;
pub fn button_2 <'a> (
key: impl Content<TuiOut> + 'a, label: impl Content<TuiOut> + 'a, editing: bool,
) -> impl Content<TuiOut> + 'a {
let key = Tui::fg_bg(Tui::orange(), Tui::g(0), Bsp::e(
Tui::fg(Tui::g(0), "▐"),
Bsp::e(key, Tui::fg(Tui::g(96), "▐"))
));
let label = When::new(!editing, Tui::fg_bg(Tui::g(255), Tui::g(96), label));
Tui::bold(true, Bsp::e(key, label))
}
pub fn button_3 <'a, K, L, V> (
key: K,
label: L,
value: V,
editing: bool,
) -> impl Content<TuiOut> + 'a where
K: Content<TuiOut> + 'a,
L: Content<TuiOut> + 'a,
V: Content<TuiOut> + 'a,
{
let key = Tui::fg_bg(Tui::orange(), Tui::g(0),
Bsp::e(Tui::fg(Tui::g(0), "▐"), Bsp::e(key, Tui::fg(if editing {
Tui::g(128)
} else {
Tui::g(96)
}, "▐"))));
let label = Bsp::e(
When::new(!editing, Bsp::e(
Tui::fg_bg(Tui::g(255), Tui::g(96), label),
Tui::fg_bg(Tui::g(128), Tui::g(96), "▐"),
)),
Bsp::e(
Tui::fg_bg(Tui::g(224), Tui::g(128), value),
Tui::fg_bg(Tui::g(128), Reset, "▌"),
));
Tui::bold(true, Bsp::e(key, label))
}
pub fn swap_value <T: Clone + PartialEq, U> (
target: &mut T, value: &T, returned: impl Fn(T)->U
) -> Perhaps<U> {

4
crates/device/src/lv2/lv2_tui.rs
View file

@ -1,8 +1,8 @@
use crate::*;
use super::*;
impl Content<TuiOut> for Lv2 {
fn render (&self, to: &mut TuiOut) {
impl Draw<TuiOut> for Lv2 {
fn draw (&self, to: &mut TuiOut) {
let area = to.area();
let [x, y, _, height] = area;
let mut width = 20u16;

10
crates/device/src/meter.rs
View file

@ -9,8 +9,8 @@ pub enum MeteringMode {
#[derive(Debug, Default, Clone)]
pub struct Log10Meter(pub f32);
render!(TuiOut: |self: Log10Meter, to| {
tui_layout!(|self: Log10Meter, to|to);
tui_draw!(|self: Log10Meter, to| {
let [x, y, w, h] = to.area();
let signal = 100.0 - f32::max(0.0, f32::min(100.0, self.0.abs()));
let v = (signal * h as f32 / 100.0).ceil() as u16;
@ -32,7 +32,7 @@ pub fn to_log10 (samples: &[f32]) -> f32 {
#[derive(Debug, Default, Clone)]
pub struct RmsMeter(pub f32);
render!(TuiOut: |self: RmsMeter, to| {
draw!(TuiOut: |self: RmsMeter, to| {
let [x, y, w, h] = to.area();
let signal = f32::max(0.0, f32::min(100.0, self.0.abs()));
let v = (signal * h as f32).ceil() as u16;
@ -53,7 +53,7 @@ pub fn to_rms (samples: &[f32]) -> f32 {
(sum / samples.len() as f32).sqrt()
}
pub fn view_meter <'a> (label: &'a str, value: f32) -> impl Content<TuiOut> + 'a {
pub fn view_meter <'a> (label: &'a str, value: f32) -> impl Draw<TuiOut> + 'a {
col!(
FieldH(ItemTheme::G[128], label, format!("{:>+9.3}", value)),
Fixed::xy(if value >= 0.0 { 13 }
@ -74,7 +74,7 @@ pub fn view_meter <'a> (label: &'a str, value: f32) -> impl Content<TuiOut> + 'a
else { Green }, ())))
}
pub fn view_meters (values: &[f32;2]) -> impl Content<TuiOut> + use<'_> {
pub fn view_meters (values: &[f32;2]) -> impl Draw<TuiOut> + use<'_> {
let left = format!("L/{:>+9.3}", values[0]);
let right = format!("R/{:>+9.3}", values[1]);
Bsp::s(left, right)

4
crates/device/src/sampler/sampler_browse.rs
View file

@ -143,8 +143,8 @@ fn scan (dir: &PathBuf) -> Usually<(Vec<OsString>, Vec<OsString>)> {
Ok((subdirs, files))
}
impl Content<TuiOut> for AddSampleModal {
fn render (&self, _to: &mut TuiOut) {
impl Draw<TuiOut> for AddSampleModal {
fn draw (&self, _to: &mut TuiOut) {
todo!()
//let area = to.area();
//to.make_dim();

69
crates/device/src/sampler/sampler_view.rs
View file

@ -2,28 +2,31 @@ use crate::*;
impl Sampler {
pub fn view_grid (&self) -> impl Content<TuiOut> + use<'_> {
pub fn view_grid (&self) -> impl Draw<TuiOut> + Layout<TuiOut> + use<'_> {
let cells_x = 8u16;
let cells_y = 8u16;
let cell_width = 10u16;
let cell_height = 2u16;
//let width = cells_x * cell_width;
//let height = cells_y * cell_height;
let cols = Map::east(
cell_width,
move||0..cells_x,
move|x, _|Map::south(
cell_height,
move||0..cells_y,
move|y, _|self.view_grid_cell("........", x, y, cell_width, cell_height)
)
);
cols
//let cols = Map::east(
//cell_width,
//move||0..cells_x,
//move|x, _|Map::south(
//cell_height,
//move||0..cells_y,
//move|y, _|self.view_grid_cell("........", x, y, cell_width, cell_height)
//)
//);
//cols
//Thunk::new(|to: &mut TuiOut|{
//})
"TODO"
}
pub fn view_grid_cell <'a> (
&'a self, name: &'a str, x: u16, y: u16, w: u16, h: u16
) -> impl Content<TuiOut> + use<'a> {
) -> impl Draw<TuiOut> + use<'a> {
let cursor = self.cursor();
let hi_fg = Color::Rgb(64, 64, 64);
let hi_bg = if y == 0 { Color::Reset } else { Color::Rgb(64, 64, 64) /*prev*/ };
@ -55,7 +58,7 @@ impl Sampler {
pub fn view_list <'a, T: NotePoint + NoteRange> (
&'a self, compact: bool, editor: &T
) -> impl Content<TuiOut> + 'a {
) -> impl Draw<TuiOut> + 'a {
let note_lo = editor.get_note_lo();
let note_pt = editor.get_note_pos();
let note_hi = editor.get_note_hi();
@ -97,7 +100,7 @@ impl Sampler {
}
}
pub fn view_sample (&self, note_pt: usize) -> impl Content<TuiOut> + use<'_> {
pub fn view_sample (&self, note_pt: usize) -> impl Draw<TuiOut> + use<'_> {
Outer(true, Style::default().fg(Tui::g(96)))
.enclose(Fill::xy(draw_viewer(if let Some((_, Some(sample))) = &self.recording {
Some(sample)
@ -108,7 +111,7 @@ impl Sampler {
})))
}
pub fn view_sample_info (&self, note_pt: usize) -> impl Content<TuiOut> + use<'_> {
pub fn view_sample_info (&self, note_pt: usize) -> impl Draw<TuiOut> + use<'_> {
Fill::x(Fixed::y(1, draw_info(if let Some((_, Some(sample))) = &self.recording {
Some(sample)
} else if let Some(sample) = &self.mapped[note_pt] {
@ -118,7 +121,7 @@ impl Sampler {
})))
}
pub fn view_sample_status (&self, note_pt: usize) -> impl Content<TuiOut> + use<'_> {
pub fn view_sample_status (&self, note_pt: usize) -> impl Draw<TuiOut> + use<'_> {
Fixed::x(20, draw_info_v(if let Some((_, Some(sample))) = &self.recording {
Some(sample)
} else if let Some(sample) = &self.mapped[note_pt] {
@ -128,20 +131,20 @@ impl Sampler {
}))
}
pub fn view_status (&self, index: usize) -> impl Content<TuiOut> {
pub fn view_status (&self, index: usize) -> impl Draw<TuiOut> {
draw_status(self.mapped[index].as_ref())
}
pub fn view_meters_input (&self) -> impl Content<TuiOut> + use<'_> {
pub fn view_meters_input (&self) -> impl Draw<TuiOut> + use<'_> {
draw_meters(&self.input_meters)
}
pub fn view_meters_output (&self) -> impl Content<TuiOut> + use<'_> {
pub fn view_meters_output (&self) -> impl Draw<TuiOut> + use<'_> {
draw_meters(&self.output_meters)
}
}
fn draw_meters (meters: &[f32]) -> impl Content<TuiOut> + use<'_> {
fn draw_meters (meters: &[f32]) -> impl Draw<TuiOut> + use<'_> {
Tui::bg(Black, Fixed::x(2, Map::east(1, ||meters.iter(), |value, _index|{
Fill::y(RmsMeter(*value))
})))
@ -163,9 +166,9 @@ fn draw_list_item (sample: &Option<Arc<RwLock<Sample>>>) -> String {
}
}
fn draw_viewer (sample: Option<&Arc<RwLock<Sample>>>) -> impl Content<TuiOut> + use<'_> {
fn draw_viewer (sample: Option<&Arc<RwLock<Sample>>>) -> impl Draw<TuiOut> + Layout<TuiOut> + use<'_> {
let min_db = -64.0;
ThunkRender::new(move|to: &mut TuiOut|{
Thunk::new(move|to: &mut TuiOut|{
let [x, y, width, height] = to.area();
let area = Rect { x, y, width, height };
if let Some(sample) = &sample {
@ -218,41 +221,41 @@ fn draw_viewer (sample: Option<&Arc<RwLock<Sample>>>) -> impl Content<TuiOut> +
})
}
fn draw_info (sample: Option<&Arc<RwLock<Sample>>>) -> impl Content<TuiOut> + use<'_> {
When(sample.is_some(), Thunk::new(move||{
fn draw_info (sample: Option<&Arc<RwLock<Sample>>>) -> impl Draw<TuiOut> + Layout<TuiOut> + use<'_> {
When(sample.is_some(), Thunk::new(move|to: &mut TuiOut|{
let sample = sample.unwrap().read().unwrap();
let theme = sample.color;
row!(
to.place(&row!(
FieldH(theme, "Name", format!("{:<10}", sample.name.clone())),
FieldH(theme, "Length", format!("{:<8}", sample.channels[0].len())),
FieldH(theme, "Start", format!("{:<8}", sample.start)),
FieldH(theme, "End", format!("{:<8}", sample.end)),
FieldH(theme, "Trans", "0"),
FieldH(theme, "Gain", format!("{}", sample.gain)),
)
))
}))
}
fn draw_info_v (sample: Option<&Arc<RwLock<Sample>>>) -> impl Content<TuiOut> + use<'_> {
Either(sample.is_some(), Thunk::new(move||{
fn draw_info_v (sample: Option<&Arc<RwLock<Sample>>>) -> impl Draw<TuiOut> + Layout<TuiOut> + use<'_> {
Either::new(sample.is_some(), Thunk::new(move|to: &mut TuiOut|{
let sample = sample.unwrap().read().unwrap();
let theme = sample.color;
Fixed::x(20, col!(
to.place(&Fixed::x(20, col!(
Fill::x(Align::w(FieldH(theme, "Name ", format!("{:<10}", sample.name.clone())))),
Fill::x(Align::w(FieldH(theme, "Length", format!("{:<8}", sample.channels[0].len())))),
Fill::x(Align::w(FieldH(theme, "Start ", format!("{:<8}", sample.start)))),
Fill::x(Align::w(FieldH(theme, "End ", format!("{:<8}", sample.end)))),
Fill::x(Align::w(FieldH(theme, "Trans ", "0"))),
Fill::x(Align::w(FieldH(theme, "Gain ", format!("{}", sample.gain)))),
))
}), Thunk::new(move||Tui::fg(Red, col!(
)))
}), Thunk::new(|to: &mut TuiOut|to.place(&Tui::fg(Red, col!(
Tui::bold(true, "× No sample."),
"[r] record",
"[Shift-F9] import",
))))
)))))
}
fn draw_status (sample: Option<&Arc<RwLock<Sample>>>) -> impl Content<TuiOut> {
fn draw_status (sample: Option<&Arc<RwLock<Sample>>>) -> impl Draw<TuiOut> + Layout<TuiOut> {
Tui::bold(true, Tui::fg(Tui::g(224), sample
.map(|sample|{
let sample = sample.read().unwrap();

4
crates/device/src/sequencer/seq_launch.rs
View file

@ -38,7 +38,7 @@ pub trait HasPlayClip: HasClock {
*self.reset_mut() = true;
}
fn play_status (&self) -> impl Content<TuiOut> {
fn play_status (&self) -> impl Draw<TuiOut> {
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)
@ -51,7 +51,7 @@ pub trait HasPlayClip: HasClock {
FieldV(color, "Now:", format!("{} {}", time, name))
}
fn next_status (&self) -> impl Content<TuiOut> {
fn next_status (&self) -> impl Draw<TuiOut> {
let mut time: Arc<str> = String::from("--.-.--").into();
let mut name: Arc<str> = String::from("").into();
let mut color = ItemTheme::G[64];